Java7之集合类型 ArrayList与Vector

来源：互联网发布：如何生命一个数组编辑：程序博客网时间：2024/05/17 03:03

转载：http://www.it165.net/pro/html/201402/9489.html

1.转载请注明出处：http://blog.csdn.net/mazhimazh/article/details/19543911

view sourceprint?
1. 

先来看ArrayList写法如下：

view sourceprint?
1.publicclass ArrayList<E> extendsAbstractList<E> implementsList<E>, RandomAccess, Cloneable, java.io.Serializable

ArrayList 继承了AbstractList抽象类并且实现了List接口，所以提供了数组相关的添加、删除、修改、遍历等功能ArrayList 实现了RandmoAccess接口，即提供了随机访问功能。也就是说，可以通过索引来快速获取元素对象ArrayList 实现了Cloneable接口，即覆盖了函数clone()，能被克隆

在ArrayList中，主要是通过Object[]数组来完成实现的，与数组相比，它的容量能动态增长，这个由它自己进行管理。

1、创建ArrayList对象

来看一下构造函数：

view sourceprint?
// 数组缓冲区,用来存储元素
privatetransient Object[] elementData;// 当进行串行化时，这个属性并不会被写入
privateint size;                      // 数组中存储的元素个数                   
 
publicArrayList(int initialCapacity) {
    super();   //  
    if(initialCapacity < 0)
        thrownew IllegalArgumentException("Illegal Capacity: "+ initialCapacity);
    this.elementData =new Object[initialCapacity];
}
publicArrayList() {// 默认分配的大小为10
    this(10);
}
// in the order they are returned by the collection's iterator.
publicArrayList(Collection<? extendsE> c) {
    elementData = c.toArray();//
    size = elementData.length;
    if(elementData.getClass() != Object[].class)
        elementData = Arrays.copyOf(elementData, size, Object[].class);
}

初始时可以指定大小，如果不指定则默认分配的大小为10。还提供了一个有Collection参数的接口，这就为List和其他的集合之间相互转换提供了便利。

2、添加元素

ArrayList中添加元素方法的实现源代码如下：

view sourceprint?
publicboolean add(E e) {
     ensureCapacityInternal(size +1);   // 保证elementData数组有足够的大小
     elementData[size++] = e;           // 向数组中添加新元素
     returntrue;
 }
 publicvoid add(intindex, E element) {
     rangeCheckForAdd(index);
     ensureCapacityInternal(size +1);   // 保证数组的大小
     // 将index索引处后的所有元素向后移动一个位置
     System.arraycopy(elementData, index, elementData, index +1,size - index);
     elementData[index] = element;      // 将新的元素添加到指定的索引处
     size++;                            // 元素个数加1
 }

在添加新元素时，会改变数组的内容。所以在每次调用ensureCapacityInternal()方法进行扩容时，还会对modCount加1，这个方法及相关方法的源代码如下：

view sourceprint?
privatestatic final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
 
privatevoid ensureCapacityInternal(intminCapacity) {
    modCount++;                                        // 对modCount加1，表示数组内容发生了变化
    if(minCapacity - elementData.length > 0)          // 当（数组中实际元素个数+1)>数组的长度时，需要进行扩容操作
        grow(minCapacity);
}
 
privatevoid grow(intminCapacity) {
    intoldCapacity = elementData.length;
    intnewCapacity = oldCapacity + (oldCapacity >> 1); // 计算新的数组容量大小
    /*
     *  扩容后仍然小于要求的最小容量时,新数组容量大于就为最小容量大小
     *  扩容后新容量大于MAX_ARRAY_SIZE值时,调用hugeCapacity()进行处理
     */
    if(newCapacity - minCapacity < 0)                  
        newCapacity = minCapacity;
    if(newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    elementData = Arrays.copyOf(elementData, newCapacity);// 将元素复制到新的数组中
}
privatestatic int hugeCapacity(int minCapacity) {
    if(minCapacity < 0)// overflow
        thrownew OutOfMemoryError();
    return(minCapacity > MAX_ARRAY_SIZE) ?Integer.MAX_VALUE : MAX_ARRAY_SIZE;
}

如上就是具体的扩容方法。

3、迭代元素

关于集合元素的迭代，在前面也说过不少了。如果不清楚，可以进行查看：

传送门： http://blog.csdn.net/mazhimazh/article/details/17759579

下面来看一个具体的例子：

view sourceprint?
ArrayList<String>  aList=newArrayList<String>();
        aList.add("a");
        aList.add("b");
        aList.add("d");
        ListIterator<String> it=aList.iterator();// 下面要获取到Iterator对象后添加元素，所以生成的必须是ListIterator对象
        // aList.add("x");      // 抛出异常ConcurrentModificationException
        // aList.remove(2);       // 抛出异常ConcurrentModificationException
        it.add("x");          // 调用自身的方法去修改正常
        while(it.hasNext()){
            System.out.print(it.next()+" ");
        }

程序输出的结果如下：

a b c // 注意输出结果中不含有x

可以看到，在获取了iterator实例后，aList就不可改变。当ArrayList使用了iterator()方法产生自身对应的Iterator后，只能使用Iterator自身的remove()和add()方法来修改ArrayList的结构，因为这些方法会对expectedModCount和modCount变量会自动同步，如ListItr中的add(E e)方法，如下：

view sourceprint?
publicvoid add(E e) {
      checkForComodification();
      try{
          inti = cursor;
          ArrayList.this.add(i, e);      // 调用ArrayList对象的add()方法进行元素的添加
          cursor = i +1;
          lastRet = -1;
          expectedModCount = modCount;  // 重新设置expectedModCount的值为修改后的modCount值
      }catch (IndexOutOfBoundsException ex) {
          thrownew ConcurrentModificationException();
      }
  }

还有Itr中的remove()方法，如下：

view sourceprint?
publicvoid remove() {
      if(lastRet < 0)
          thrownew IllegalStateException();
      checkForComodification();
      try{
          ArrayList.this.remove(lastRet);
          cursor = lastRet;
          lastRet = -1;
          expectedModCount = modCount;  // 重新设置expectedModCount值,所以在获取Itr实例时，只能通过调用这个实例中的方法进行数组内容的修改
      }catch (IndexOutOfBoundsException ex) {
          thrownew ConcurrentModificationException();
      }
  }

调用ArrayList中本身定义的添加和删除方法都会引起ConcurrentModificationException异常，因为他们并不会重新设置expectedModCount值，如下：

view sourceprint?
publicboolean add(E e) {
     ensureCapacityInternal(size +1);  // 会对modCount的值做加1操作
     elementData[size++] = e;
     returntrue;
 }
 publicvoid add(intindex, E element) {
     rangeCheckForAdd(index);
     ensureCapacityInternal(size +1);  // 会对modCount值做加1操作
     System.arraycopy(elementData, index, elementData, index +1,size - index);
     elementData[index] = element;
     size++;
 }
 
 publicE remove(int index) {
     rangeCheck(index);
     modCount++;                       // 对modCount值做加1操作
     E oldValue = elementData(index);
     intnumMoved = size - index - 1;
     if(numMoved > 0)
         System.arraycopy(elementData, index+1, elementData, index,numMoved);
     elementData[--size] =null;       // 有利于垃圾回收器进行回收
     returnoldValue;
 }

ArrayList使用AbstractList.modCount(初始的默认值为0)作为数组内容改变的标识。在ArrayList中，凡是会引起ArrayList结构变化的方法，都会修改modCount(modCount++)，以区别是否修改了ArrayList中存储的内容。

如果是对ArrayList的Iterator做修改，在Iterator中会重置expectedModCount=modCount，如上面ListIterator类中的remove()方法。这样就可以保证在生成Iterator后，只能由Iterator来修改对应的ArrayList的内容。

4、克隆ArrayList对象

view sourceprint?
//  克隆出ArrayList的复本，是一个深克隆（继承了Cloneable接口）
publicObject clone() { 
    try{
        ArrayList<E> v = (ArrayList<E>)super.clone();    
        v.elementData = Arrays.copyOf(elementData, size);// 拷贝数组中的内容到新数组中
        v.modCount =0;
        returnv;                                         // 返回新的数组的引用
    }catch (CloneNotSupportedException e) {
        thrownew InternalError();
    }
}

进行的是深度的克隆，修改内容时不会相互影响，相当于两个完全独立的副本。

Vector类也是基于数组实现的队列，代码与ArrayList非常相似，只不过在可能发生线程安全的方法上加上了Synchorized关键字，使得其执行的效率相比ArrayList就低了。看一下两个最主要的构造函数：

view sourceprint?
// capacity是Vector的默认容量大小，capacityIncrement是每次Vector容量增加时的增量值。
publicVector(int initialCapacity, int capacityIncrement) {
    super();
    if(initialCapacity < 0)
        thrownew IllegalArgumentException("Illegal Capacity: "+ initialCapacity);
    this.elementData =new Object[initialCapacity];
    this.capacityIncrement = capacityIncrement;
}
// 创建一个包含collection元素的Vector
publicVector(Collection<? extendsE> c) {
    elementData = c.toArray();
    elementCount = elementData.length;
    // c.toArray might (incorrectly) not return Object[] (see 6260652)
    if(elementData.getClass() != Object[].class)
        elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
}

0 0