基本数据结构解析之ArrayList

ArrayList:

使用大小可按需动态增加的数组实现 IList 接口。(From MSDN)

初始化，内部默认是4的Capacity, 还是采用Object存储

private const int _defaultCapacity = 4;
private Object[] _items;
private static readonly Object[] emptyArray = new Object[0]; 
  
// Note: this constructor is a bogus constructor that does nothing
// and is for use only with SyncArrayList.
internal ArrayList( bool trash )
{
}
  
// Constructs a ArrayList. The list is initially empty and has a capacity
// of zero. Upon adding the first element to the list the capacity is
// increased to _defaultCapacity, and then increased in multiples of two as required.
public ArrayList() {
    _items = emptyArray;  
}
  
// Constructs a ArrayList with a given initial capacity. The list is
// initially empty, but will have room for the given number of elements
// before any reallocations are required.
// 
 public ArrayList(int capacity) {
    if (capacity < 0) throw new ArgumentOutOfRangeException("capacity", Environment.GetResourceString("ArgumentOutOfRange_MustBeNonNegNum", "capacity"));
    _items = new Object[capacity];
}
  
// Constructs a ArrayList, copying the contents of the given collection. The
// size and capacity of the new list will both be equal to the size of the
// given collection.
// 
public ArrayList(ICollection c) {
    if (c==null)
        throw new ArgumentNullException("c", Environment.GetResourceString("ArgumentNull_Collection"));
    _items = new Object[c.Count];
    AddRange(c);
}

Capacity 比较有趣的是如果设置新的Capacity, 如果大于原有的length则会发生

1. 建立新的以新的Capacity为容量大小的Object数组

2. 将原有数据拷贝到新的数组上去

3. 将原有引用指向新的Object数组上去

// Gets and sets the capacity of this list.  The capacity is the size of
// the internal array used to hold items.  When set, the internal 
// array of the list is reallocated to the given capacity.
// 
 public virtual int Capacity {
    get { return _items.Length; }
    set {
        // We don't want to update the version number when we change the capacity.
        // Some existing applications have dependency on this.
        if (value != _items.Length) {
            if (value < _size) {
                throw new ArgumentOutOfRangeException("value", Environment.GetResourceString("ArgumentOutOfRange_SmallCapacity"));
            }
  
            if (value > 0) {
                Object[] newItems = new Object[value];
                if (_size > 0) { 
                    Array.Copy(_items, 0, newItems, 0, _size);
                }
                _items = newItems;
            }
            else {
                _items = new Object[_defaultCapacity];
            }
        }            
    }

ListWrapper 把一个IList转换为ArrayList

// Creates a ArrayList wrapper for a particular IList.  This does not
// copy the contents of the IList, but only wraps the ILIst.  So any
// changes to the underlying list will affect the ArrayList.  This would
// be useful if you want to Reverse a subrange of an IList, or want to
// use a generic BinarySearch or Sort method without implementing one yourself.
// However, since these methods are generic, the performance may not be
// nearly as good for some operations as they would be on the IList itself.
//
public static ArrayList Adapter(IList list) {
    if (list==null)
        throw new ArgumentNullException("list");
    return new IListWrapper(list);
}

添加元素, 在超出容量时还是会Double原来的Size

// Adds the given object to the end of this list. The size of the list is
// increased by one. If required, the capacity of the list is doubled
// before adding the new element.
//
public virtual int Add(Object value) {
    if (_size == _items.Length) EnsureCapacity(_size + 1);
    _items[_size] = value;
    _version++;
    return _size++;
}
  
// Ensures that the capacity of this list is at least the given minimum
// value. If the currect capacity of the list is less than min, the
// capacity is increased to twice the current capacity or to min,
// whichever is larger.
private void EnsureCapacity(int min) {
    if (_items.Length < min) {
        int newCapacity = _items.Length == 0? _defaultCapacity: _items.Length * 2;
        if (newCapacity < min) newCapacity = min;
        Capacity = newCapacity;
    }
}

批量插入元素, 和插入元素类似

// Adds the elements of the given collection to the end of this list. If
// required, the capacity of the list is increased to twice the previous
// capacity or the new size, whichever is larger.
//
public virtual void AddRange(ICollection c) {
    InsertRange(_size, c);
}
  
// Inserts the elements of the given collection at a given index. If
// required, the capacity of the list is increased to twice the previous
// capacity or the new size, whichever is larger.  Ranges may be added
// to the end of the list by setting index to the ArrayList's size.
//
public virtual void InsertRange(int index, ICollection c) {
    if (c==null)
        throw new ArgumentNullException("c", Environment.GetResourceString("ArgumentNull_Collection"));
    if (index < 0 || index > _size) throw new ArgumentOutOfRangeException("index", Environment.GetResourceString("ArgumentOutOfRange_Index"));
    int count = c.Count;
    if (count > 0) {
        EnsureCapacity(_size + count);                
        // shift existing items
        if (index < _size) {
            Array.Copy(_items, index, _items, index + count, _size - index);
        }
  
        Object[] itemsToInsert = new Object[count];
        c.CopyTo(itemsToInsert, 0);
        itemsToInsert.CopyTo(_items, index);
        _size += count;
        _version++;
    }
}

二分查找

// Searches a section of the list for a given element using a binary search
  // algorithm. Elements of the list are compared to the search value using
  // the given IComparer interface. If comparer is null, elements of
  // the list are compared to the search value using the IComparable
  // interface, which in that case must be implemented by all elements of the
  // list and the given search value. This method assumes that the given
  // section of the list is already sorted; if this is not the case, the
  // result will be incorrect.
  //
  // The method returns the index of the given value in the list. If the
  // list does not contain the given value, the method returns a negative
  // integer. The bitwise complement operator (~) can be applied to a
  // negative result to produce the index of the first element (if any) that
  // is larger than the given search value. This is also the index at which
  // the search value should be inserted into the list in order for the list
  // to remain sorted.
  // 
  // The method uses the Array.BinarySearch method to perform the
  // search.
  // 
  public virtual int BinarySearch(int index, int count, Object value, IComparer comparer) {
      if (index < 0 || count < 0)
          throw new ArgumentOutOfRangeException((index<0 ? "index" : "count"), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
      if (_size - index < count)
          throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
  
      return Array.BinarySearch((Array)_items, index, count, value, comparer);
  }
  
  public virtual int BinarySearch(Object value)
  {
      return BinarySearch(0,Count,value,null);
  }
  
  public virtual int BinarySearch(Object value, IComparer comparer)
  {
      return BinarySearch(0,Count,value,comparer);
  }

调用Array.BinarySearch, 关于BinarySearch的内容较多，您可以查看MSDN, 还有这里看源码

不知道二分查找？看这里

这里的原理: 如果有Comparer则调用Comparer进行二分查找.如果是Comparer.Default在运行时查看类型，采用Switch进行处理，调用对应类型ArrayHelper<KIND>.BinarySearchBitwiseEquals,

// Searches a section of an array for a given element using a binary search
// algorithm. Elements of the array are compared to the search value using
// the IComparable interface, which must be implemented by all
// elements of the array and the given search value. This method assumes
// that the array is already sorted according to the IComparable
// interface; if this is not the case, the result will be incorrect.
//
// The method returns the index of the given value in the array. If the
// array does not contain the given value, the method returns a negative
// integer. The bitwise complement operator (~) can be applied to a
// negative result to produce the index of the first element (if any) that
// is larger than the given search value.
// 
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
public static int BinarySearch(Array array, int index, int length, Object value) {
   return BinarySearch(array, index, length, value, null);
}
  
// Searches an array for a given element using a binary search algorithm.
// Elements of the array are compared to the search value using the given
// IComparer interface. If comparer is null, elements of the
// array are compared to the search value using the IComparable
// interface, which in that case must be implemented by all elements of the
// array and the given search value. This method assumes that the array is
// already sorted; if this is not the case, the result will be incorrect.
// 
// The method returns the index of the given value in the array. If the
// array does not contain the given value, the method returns a negative
// integer. The bitwise complement operator (~) can be applied to a
// negative result to produce the index of the first element (if any) that
// is larger than the given search value.
// 
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
public static int BinarySearch(Array array, Object value, IComparer comparer) {
   if (array==null)
       throw new ArgumentNullException("array");
   int lb = array.GetLowerBound(0);
   return BinarySearch(array, lb, array.Length, value, comparer);
}
  
// Searches a section of an array for a given element using a binary search
// algorithm. Elements of the array are compared to the search value using
// the given IComparer interface. If comparer is null,
// elements of the array are compared to the search value using the
// IComparable interface, which in that case must be implemented by
// all elements of the array and the given search value. This method
// assumes that the array is already sorted; if this is not the case, the
// result will be incorrect.
// 
// The method returns the index of the given value in the array. If the
// array does not contain the given value, the method returns a negative
// integer. The bitwise complement operator (~) can be applied to a
// negative result to produce the index of the first element (if any) that
// is larger than the given search value.
// 
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
public static int BinarySearch(Array array, int index, int length, Object value, IComparer comparer) {
   if (array==null) 
       throw new ArgumentNullException("array");
   int lb = array.GetLowerBound(0);
   if (index < lb || length < 0)
       throw new ArgumentOutOfRangeException((index<lb ? "index" : "length"), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
   if (array.Length - (index - lb) < length)
       throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
   if (array.Rank != 1)
       throw new RankException(Environment.GetResourceString("Rank_MultiDimNotSupported"));
   
   if (comparer == null) comparer = Comparer.Default;
   if (comparer == Comparer.Default) {
       int retval;
       bool r = TrySZBinarySearch(array, index, length, value, out retval);
       if (r)
           return retval;
   }
  
   int lo = index;
   int hi = index + length - 1;   
   Object[] objArray = array as Object[];
   if(objArray != null) {
       while (lo <= hi) {
           // i might overflow if lo and hi are both large positive numbers. 
           int i = GetMedian(lo, hi);
  
           int c;
           try {
               c = comparer.Compare(objArray[i], value);
           }
           catch (Exception e) {
               throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_IComparerFailed"), e);
           }
           catch {
               throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_IComparerFailed"));
           }
           if (c == 0) return i;
           if (c < 0) {
               lo = i + 1;
           }
           else {
               hi = i - 1;
           }
       }
   }
   else {
       while (lo <= hi) {
           int i = GetMedian(lo, hi);                    
  
           int c;
           try {
               c = comparer.Compare(array.GetValue(i), value);
           }
           catch (Exception e) {
               throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_IComparerFailed"), e);
           }
           catch {
               throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_IComparerFailed"));
           }
           if (c == 0) return i;
           if (c < 0) {
               lo = i + 1;
           }
           else {
               hi = i - 1;
           }
       }
   }
   return ~lo;
}

Clear, Clone, Contains 同上

CopyTo, 跟Clone的方式类似，不同的是增加了索引拷贝的方式

锁定数组, 可以对IList和ArrayList进行锁定，添加和删除操作都会失败，但是替换操作依然可以执行, 是这样的吗?

// Returns a list wrapper that is fixed at the current size.  Operations
// that add or remove items will fail, however, replacing items is allowed.
//
public static IList FixedSize(IList list) {
   if (list==null)
       throw new ArgumentNullException("list");
   return new FixedSizeList(list);
}
  
// Returns a list wrapper that is fixed at the current size.  Operations
// that add or remove items will fail, however, replacing items is allowed.
//
public static ArrayList FixedSize(ArrayList list) {
   if (list==null)
       throw new ArgumentNullException("list");
   return new FixedSizeArrayList(list);
}

Reverse

首先会调用mscorworks中的方法来对对应的类型利用泛型的方式进行翻转。如果找不到对应的类型(即内建的基本类型)。则按首尾交换的原则进行翻转

调用方式如下查看代码

// Reverses the elements in this list.
public virtual void Reverse() {
    Reverse(0, Count);
}
 
// Reverses the elements in a range of this list. Following a call to this
// method, an element in the range given by index and count
// which was previously located at index i will now be located at
// index index + (index + count - i - 1).
// 
// This method uses the Array.Reverse method to reverse the
// elements.
// 
public virtual void Reverse(int index, int count) {
    if (index < 0 || count < 0)
        throw new ArgumentOutOfRangeException((index<0 ? "index" : "count"), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
    if (_size - index < count)
        throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
    Array.Reverse(_items, index, count);
    _version++;
}
 
// Reverses the elements in a range of an array. Following a call to this
// method, an element in the range given by index and count
// which was previously located at index i will now be located at
// index index + (index + count - i - 1).
// Reliability note: This may fail because it may have to box objects.
// 
[ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
public static void Reverse(Array array, int index, int length) {
    if (array==null) 
        throw new ArgumentNullException("array");
    if (index < array.GetLowerBound(0) || length < 0)
        throw new ArgumentOutOfRangeException((index<0 ? "index" : "length"), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
    if (array.Length - (index - array.GetLowerBound(0)) < length)
        throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
    if (array.Rank != 1)
        throw new RankException(Environment.GetResourceString("Rank_MultiDimNotSupported"));
 
    bool r = TrySZReverse(array, index, length);
    if (r)
        return;
 
    int i = index;
    int j = index + length - 1;
    Object[] objArray = array as Object[];
    if (objArray!=null) {
        while (i < j) {
            Object temp = objArray[i];
            objArray[i] = objArray[j];
            objArray[j] = temp;
            i++;
            j--;
        }
    }
    else {
        while (i < j) {
            Object temp = array.GetValue(i);
            array.SetValue(array.GetValue(j), i);
            array.SetValue(temp, j);
            i++;
            j--;
        }
    }
}
static void Reverse(KIND array[], UINT32 index, UINT32 count) {
    LEAF_CONTRACT;
 
    _ASSERTE(array != NULL);
    if (count == 0) {
        return;
    }
    UINT32 i = index;
    UINT32 j = index + count - 1;
    while(i < j) {
        KIND temp = array[i];
        array[i] = array[j];
        array[j] = temp;
        i++;
        j--;
    }
}

SetValue

通过读取index的索引处的指针, 调用内部的实现来设置值

InternalGetReference(&elemref, 3, pIndices);
InternalSetValue(&elemref,value);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
// reference to TypedReference is banned, so have to pass result as pointer
private unsafe extern void InternalGetReference(void * elemRef, int rank, int * pIndices);
 
[MethodImplAttribute(MethodImplOptions.InternalCall)]
private unsafe extern static void InternalSetValue(void * target, Object value);

Sort

首先查找内部底层实现中对应类型的快速排序，如果没有，则在BCL层次利用ICompare接口实现进行快速排序

代码太大，查看

CLR/SRC/SYSTEM/ArrayList.cs, Array.cs

CLR/SRC/VM/Array.cpp, ComArrayHelper.cpp

posted on 2008-11-29 19:01 xwang 阅读(1531) 评论(1) 编辑收藏举报

刷新页面返回顶部

Roboot - A New Wang