java集合框架(二)——Collection(集合)类

学习完接口后，开始学习实现他们的标准类

一、ArrayList类

ArrayList类扩展AbstractList接口，并实现list接口，底层使用数组保存所有元素，分析源码：

1、底层使用数组实现

private transient Object[] elementData;  

2、构造函数

public ArrayList() {  
    this(10);  
}  
  
public ArrayList(int initialCapacity) {  
    super();  
    if (initialCapacity < 0)  
        throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);  
    this.elementData = new Object[initialCapacity];  
}  
  
public ArrayList(Collection<? extends E> c) {  
    elementData = c.toArray();  
    size = elementData.length;  
    // c.toArray might (incorrectly) not return Object[] (see 6260652)  
    if (elementData.getClass() != Object[].class)  
        elementData = Arrays.copyOf(elementData, size, Object[].class);  
}  

3、存储

提供了三种方法，set，add，addall

public E set(int index, E element) {  
    RangeCheck(index);  
  
    E oldValue = (E) elementData[index];  
    elementData[index] = element;  
    return oldValue;  
}  

public boolean add(E e) {  
    ensureCapacity(size + 1);   
    elementData[size++] = e;  
    return true;  
}  

public boolean addAll(Collection<? extends E> c) {  
    Object[] a = c.toArray();  
    int numNew = a.length;  
    ensureCapacity(size + numNew);  // Increments modCount  
    System.arraycopy(a, 0, elementData, size, numNew);  
    size += numNew;  
    return numNew != 0;  
}  

4、读取get

// 返回此列表中指定位置上的元素。  
public E get(int index) {  
    RangeCheck(index);  
  
    return (E) elementData[index];  
}  

5、删除

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; // Let gc do its work  
  
    return oldValue;  //返回被删除值
} 

public boolean remove(Object o) {  
    // 由于ArrayList中允许存放null，因此下面通过两种情况来分别处理。  
    if (o == null) {  
        for (int index = 0; index < size; index++)  
            if (elementData[index] == null) {  
                // 类似remove(int index)，移除列表中指定位置上的元素。  
                fastRemove(index);  
                return true;  
            }  
} else {  
    for (int index = 0; index < size; index++)  
        if (o.equals(elementData[index])) {  
            fastRemove(index);  
            return true;  
        }  
    }  
    return false;  
} 

6、数组扩容

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;  
      // minCapacity is usually close to size, so this is a win:  
      elementData = Arrays.copyOf(elementData, newCapacity);  
    }  
}  

分析一下可得：

1、底层数组实现导致ArrayList查询效率高，增删效率低，由数组在内存上的存储方式决定，只需要一个偏移量就能计算出元素位置，但增删效率低是由于该过程以迭代方式进行，影响其他元素

2、数组扩容需要将旧数组复制到新数组中，有一定代价

二、LinkedList

该类实现List接口和Queue接口，链表型数据结构

public class LinkedList<E>
     extends AbstractSequentialList<E>  //双向链表，序列化，双向队列，clone
     implements List<E>, Deque<E>, Cloneable, java.io.Serializable

底层实现

private transient Entry<E> header = new Entry<E>(null, null, null);
private transient int size = 0;

节点类

private static class Entry<E> {
    E element;
    Entry<E> next;
    Entry<E> previous;
 
    Entry(E element, Entry<E> next, Entry<E> previous) {
          this.element = element;
          this.next = next;
          this.previous = previous;
   }
}

分析：

1、增删效率高，查询低

三、HashSet

该数据结构是基于hashmap实现的，其操作基本都调用底层hashmap实现，无一定顺序

四、TreeSet

底层实现，红黑树，一种基于自平衡二叉树的数据结构，看源码，Treeset底层实现一个NavigableMap接口，实现该接口的类包括treemap，treeset的底层操作基于treemap的操作