Java容器类分析之List、ArrayList、Vector

 

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;
    }