Java容器类分析之List ArrayList Vector-java vector类

List是接口，声明了各个方法，不多说。且看ArrayList类。

ArrayList类的成员变量有Object[] elementData，int size;其中elementData数组用来存储加入到ArrayList的对象，size为列表中实际的对象数目。ArrayList类不是线程安全的。

Vector与ArrayList的实现基本相同，只是Vector类是线程安全的，其方法都带有synchronized关键字，如果不考虑线程同步的话，ArrayList性能要好一些。当前它们内部实现原理都是用到对象数组来实现，如果元素数目确定，直接用数组效率***。

简单的用法：(后面是数据打印结果)

public class ListDemo {  
 
    /**  
     * @param args  
     */ 
    public static void main(String[] args) {  
        List<String> list = new ArrayList<String>();  
        String[] strArr = new String[3];  
        boolean ret = list.add("haha");  
        list.add(new String("aa"));  
        list.add(null);   
        System.out.println(list.size());//3  
        System.out.println(ret);//true  
        System.out.println(list);//[haha, aa, null]  
        System.out.println(strArr);//[Ljava.lang.String;@1fee6fc  
        System.out.println(strArr.getClass().getName());//[Ljava.lang.String;  
        System.out.println(list.indexOf("aa"));//1  
        System.out.println(list.indexOf(null));//2  
        String str = list.set(1, "ee");  
        System.out.println(str);//aa  
        System.out.println(list);//[haha, ee, null]  
        String remove = list.remove(0);  
        System.out.println(remove);//haha  
        System.out.println(list);//[ee, null]  
        boolean result = list.remove("ff");  
        System.out.println(result);//false  
        result = list.remove("ee");  
        System.out.println(result);//true  
        System.out.println(list);//[null]  
    }  
 
}

public ArrayList() {  
    this(10);  
    }  
 public ArrayList(int initialCapacity) {  
    super();  
            if (initialCapacity < 0)  
                 throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);  
    this.elementData = new Object[initialCapacity];  
    }  
   public boolean add(E e) {  
    ensureCapacity(size + 1);  // Increments modCount!!  
    elementData[size++] = e;  
    return true;  
    }  
 
 
 
/*移除指定位置元素，注意每次移除数据都会将数组中后面数据移动来填充数组*/ 
 public E remove(int index) {  
    RangeCheck(index);  
 
    modCount++;  
    E oldValue = (E) elementData[index];  
 
    int numMoved = size - index - 1;  
    if (numMoved > 0)  
        System.arraycopy(elementData, index+1, elementData, index,  
                 numMoved);  
    elementData[--size] = null; // index后面数据依次往前移动，将***一个位置赋值为0，让gc来回收空间。  
    return oldValue;  
    }  
 
public void ensureCapacity(int minCapacity) {  
    modCount++;//这个变量不用管。  
    int oldCapacity = elementData.length; //初始时设定的数组长度  
    if (minCapacity > oldCapacity) {    //如果数组对象数目>初始数组长度，则需要扩容。  
        Object oldData[] = elementData;  
        int newCapacity = (oldCapacity * 3)/2 + 1; //新的容量大小  
            if (newCapacity < minCapacity)  
        newCapacity = minCapacity;  
     /*该方法会创建一个新的对象数组，然后调用  System.arraycopy(original, 0, copy, 0,  
                Math.min(original.length, newLength));方法将源数组数据拷贝到新数组中。引用更新，指    向新的对象数组。*/ 
                   elementData = Arrays.copyOf(elementData, newCapacity);   
    }  
    }  
 
/*将对象数组削减到当前元素数目大小，减少存储空间*/     
public void trimToSize() {   
    modCount++;  
    int oldCapacity = elementData.length;  
    if (size < oldCapacity) {  
            elementData = Arrays.copyOf(elementData, size);  
    }  
    }  
 
/*查找对象***出现的位置，若没有找到，返回-1。由  
代码可知，可以在list中加入null对象，并查找到。*/ 
 public int indexOf(Object o) {  
    if (o == null) {  
        for (int i = 0; i < size; i++)  
        if (elementData[i]==null)  
            return i;  
    } else {  
        for (int i = 0; i < size; i++)  
        if (o.equals(elementData[i]))  
            return i;  
    }  
    return -1;  
    }  
 
/*替换指定位置的元素值，返回该位置中old值*/ 
public E set(int index, E element) {  
    RangeCheck(index); //检查范围  
    E oldValue = (E) elementData[index];  
    elementData[index] = element;  
    return oldValue;  
    }  
 
/*返回指定位置的值*/ 
public E get(int index) {  
    RangeCheck(index);  
 
    return (E) elementData[index];  
    }  
 
 private void RangeCheck(int index) {  
    if (index >= size)  
        throw new IndexOutOfBoundsException(  
        "Index: "+index+", Size: "+size);  
    }  
  public int size() {  
    return size;  
    }  
 
    public boolean isEmpty() {  
    return size == 0;  
    }

原文链接：http://qiemengdao.iteye.com/blog/1415761

【编辑推荐】