Java容器类分析之List ArrayList 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

【编辑推荐】

1. 有可能挑战Java优势的四种技术
2. Think in Java之斐波那契数列
3. Java的poi技术读取和导入Excel
4. Java SE 6生命将在今年11月终结
5. Java中线程安全问题个人理解