Java从入门到入坑：浅读集合框架

Java集合框架

---

---

1. 集合框架

- 对象[单列]: Collection 接口
	- 允许重复: List
		- 增删多: LinkedList [底层维护了一个双向链表]
		- 改查多: ArrayList [底层维护Object类型的可变数组]
    - 不允许重复: Set
    	- 无序: HashSet [底层是HashMap, 维护一个hash表 即(数组+链表+红黑树)]
    	- 有序: TreeSet [底层二叉排序树]
    	- 插入和取出顺序一致: LinkedHashSet [维护数组+双向链表]
- 键值对[双列]: Map 接口
	- 键无序: HashMap [底层: 哈希表, jdk7->数组+链表, jdk8->数组+链表+红黑树]
	- 键排序: TreeMap
    - 键插入和取出顺序一致: LinkedHashMap
    - 读取文件: Properties

2. List实现类

2.1 ArrayList

- ArrayList可以加入null，并且多个
- ArrayList是基于数组存储的
- ArrayList基本等同于Vector, ArrayList是线程不安全的(执行效率高), 在多数情况下,不建议使用ArrayList

- ArrayList 底层是一个Object[], transient修饰不会被序列化
- 当创建AarrayList时, 如果使用的是无参构造, 则初始化容量为0, 第一次添加, 则扩容为10, 往后按1.5被扩容
- 如果使用的是指定大小的构造器, 初始化容量为指定大小, 如果需要扩容, 则为指定大小的1.5倍

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
   

    
    // 底层使用Object数组存储元素
    transient Object[] elementData; // non-private to simplify nested class access
    
    private static final int DEFAULT_CAPACITY = 10;	 // Default initial capacity. 
    
    // 无参构造器: 初始化elementData ->  空数组{}
    // private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
    public ArrayList() {
   
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
    
    // 有参构造器: 根据initialCapacity(初始化容量) 构建数组大小
    public ArrayList(int initialCapacity) {
   
        if (initialCapacity > 0) {
   
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
   
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
   
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }
    
}

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
   
	// 执行list.add("xxx");
    
    public boolean add(E e) {
   
        // 先确定是否需要扩容, 再进行赋值, size + 1: minCapacity
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
    
    private void ensureCapacityInternal(int minCapacity) {
   
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }
    
    // 计算所需要的容量大小: 如果elementData == {} , 返回DEFAULT_CAPACITY与minCapacity的最大值
    // 如果elementData不为null, 返回传入的minCapacity
    private static int calculateCapacity(Object[] elementData, int minCapacity) {
   
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
   
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }
    
    // 这个方法确定是否需要扩容: minCapacity > elementData.length 则执行grow()进行扩容
    private void ensureExplicitCapacity(int minCapacity) {
   
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    
    /* 
    	扩容机制: 
    		if elementData == {}
    			elementData.length = 0, newCapacity = 0 , minCapacity = 10
    		    newCapacity = minCapacity;
            if newCapacity > MAX_ARRAY_SIZE 
            	newCapacity = hugeCapacity(minCapacity);
            else
            	newCapacity = oldCapacity + (oldCapacity >> 1);  // 1.5 倍扩容
			end
				elementData = Arrays.copyOf(elementData, newCapacity);
    */
    private void grow(int minCapacity) {
   
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
}

2.2 Vector

- Vector 底层也是一个Object数组elementData
- Vector 是线程同步的, 即线程安全, Vector类的操作方法带有synchronized
- 在开发中, 需要线程同步安全时, 考虑使用Vector

public class Vector<E>
    extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
   
 
    // 底层使用Object[] 存储
    protected Object[] elementData;
    
    // 使用无参构造: 默认初始化容量为10
    public Vector() {
   
        this(10);
    }
    
 	// 指定初始化容量
    public Vector(int initialCapacity) {
   
        this(initialCapacity, 0);
    }
    
    // capacityIncrement: 自定义容量增量
    // 指定初始化容量与容量增量
    public Vector(int initialCapacity, int capacityIncrement) {
   
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        this.elementData = new Object[initialCapacity];
        this.capacityIncrement = capacityIncrement;
    }
    
    
}

public class Vector<E>
    extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
   
 
    // 执行add();
    
    public synchronized boolean add(E e) {
   
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
    }
    
    // 确定是否需要扩容: minCapacity > elementData.length 则执行grow() 同ArrayList
    private void ensureCapacityHelper(int minCapacity) {
   
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    
    // newCapacity: 如果不自行定义capacityIncrement 则按两倍扩容
    // 若定义了capacityIncrement 则每次扩容为oldCapacity + capacityIncrement
    private void grow(int minCapacity) {
   
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                         capacityIncrement : oldCapacity);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;