c#系列 list详情

这里以list为介绍：

private static readonly t[] s_emptyarray = new t[0];
public list()
{
  this._items = list<t>.s_emptyarray;
}

list 本质是一个数组。

同样我们可以指定容量，如果我们知道了我们大概需要多少数据，那么我们可以指定一下，这样避免了resize的损耗。

就跟我们操作系统一样，提前申请内存大小。所以我们程序一般都有一个申请内存，实际使用内存，内存碎片这几个概念。

添加也是很简单哈

public void add(t item)
{
  ++this._version;
  t[] items = this._items;
  int size = this._size;
  if ((uint) size < (uint) items.length)
  {
 this._size = size + 1;
 items[size] = item;
  }
  else
 this.addwithresize(item);
}

判断是否满了，如果没满直接存到数组里面去，如果满了，那么resize一下。

看下resize：

private void addwithresize(t item)
{
  int size = this._size;
  this.ensurecapacity(size + 1);
  this._size = size + 1;
  this._items[size] = item;
}

然后看一下扩容步骤：

private void ensurecapacity(int min)
{
  if (this._items.length >= min)
 return;
  int num = this._items.length == 0 ? 4 : this._items.length * 2;
  if ((uint) num > 2146435071u)
 num = 2146435071;
  if (num < min)
 num = min;
  this.capacity = num;
}

首先在做了一次判断，判断是否容量够用，所以是size+1。

if (this._items.length >= min)
 return;

这里就有人问了外面不是判断了，为什么里面还有判断。

这个就是一些人喜欢谈性能的地方了，认为多此一举，如果里面不判断那么就不是一个成熟的方法，提现不出方法的封闭性,因为方法的作用是之和参数打交道，外面是什么其实是不管的。

那么可以看出，一开始是4，然后后面就是翻倍了。

然后重点看下:

 this.capacity = num;

这个this.capacity 并不是普通的变量，而是一个属性哈，不然你都纳闷它是怎么扩容了。

public int capacity
{
 get => _items.length;
 set
 {
  if (value < _size)
  {
   throwhelper.throwargumentoutofrangeexception(exceptionargument.value, exceptionresource.argumentoutofrange_smallcapacity);
  }

  if (value != _items.length)
  {
   if (value > 0)
   {
    t[] newitems = new t[value];
    if (_size > 0)
    {
     array.copy(_items, newitems, _size);
    }
    _items = newitems;
   }
   else
   {
    _items = s_emptyarray;
   }
  }
 }
}

首先判断了不能缩容，如果缩容直接异常，其次我们注意道这个capacity 是piblic的，也就是说我们在外部就可以直接调用。

后面逻辑就很简单创建一个新的数组，然后复制就ok了,然后重新赋值_items。

那么来看一下remove吧：

public bool remove(t item)
{
 int index = indexof(item);
 if (index >= 0)
 {
  removeat(index);
  return true;
 }

 return false;
}

首先是找到其位置:

public int indexof(t item)
 => array.indexof(_items, item, 0, _size);

int ilist.indexof(object? item)
{
 if (iscompatibleobject(item))
 {
  return indexof((t)item!);
 }
 return -1;
}

可以看一下这个iscompatibleobject，还是很有趣的。

private static bool iscompatibleobject(object? value)
{
 // non-null values are fine.  only accept nulls if t is a class or nullable<u>.
 // note that default(t) is not equal to null for value types except when t is nullable<u>.
 return (value is t) || (value == null && default(t) == null);
}

从这个说明，其实我们是可以传空对象的。

static void main(string[] args)
{
 list<object> lists = new list<object>();

 lists.add(null);

 console.writeline(lists.count);

 lists.remove(null);
 console.readline();
}

 

那么来看一下removeat吧：

public void removeat(int index)
{
 if ((uint)index >= (uint)_size)
 {
  throwhelper.throwargumentoutofrange_indexexception();
 }
 _size--;
 if (index < _size)
 {
  array.copy(_items, index + 1, _items, index, _size - index);
 }
 if (runtimehelpers.isreferenceorcontainsreferences<t>())
 {
  _items[_size] = default!;
 }
 _version++;
}

这里可以看出list的remove操作还是性能损耗很大的，尤其是大的list。

这里有没有注意道一个_version，这个有什么作用呢?

当遍历的时候我们就用的到

internal enumerator(list<t> list)
{
 _list = list;
 _index = 0;
 _version = list._version;
 _current = default;
}

public void dispose()
{
}

public bool movenext()
{
 list<t> locallist = _list;

 if (_version == locallist._version && ((uint)_index < (uint)locallist._size))
 {
  _current = locallist._items[_index];
  _index++;
  return true;
 }
 return movenextrare();
}

private bool movenextrare()
{
 if (_version != _list._version)
 {
  throwhelper.throwinvalidoperationexception_invalidoperation_enumfailedversion();
 }

 _index = _list._size + 1;
 _current = default;
 return false;
}

重点看上面的list，上面表面了，当我们使用foreach 进行遍历的时候，如果我们进行了删除或者添加，那么_version就会发生变化，那么可想而知会抛出异常。

例子:

static void main(string[] args)
{
 list<object> lists = new list<object>();

 lists.add("123456");

 lists.add("1231246");

 lists.add("dsadadsads");

 lists.add("eqewqew");

 foreach (var item in lists)
 {
  if (item.tostring() == "1231246")
  {
   lists.remove(item);
  }
 }

 console.readline();
}

然后就会抛出异常了。

那么这里就不介绍find了，find 就是遍历数组，找出是否相等。

哦，对了讲另外一个故事。

public int count => _size;

count-1 就是当前插入的位置。

那么如果你想删除某个元素的时候，那么你可以进行removeat 删除，这样避免了find。

那么非常值得注意的是如果删除了其他元素，如果那么元素的位置小于你记录的位置，那么应该是位置进行减一。

到此这篇关于c#系列 list详情的文章就介绍到这了,更多相关c#系列 list内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！