Java集合学习

一、java集合体系

java集合中分单列集合和双列集合，单列集合中的顶层接口是Collection，双列集合中的顶层接口是Map.

二、java集合特点

单列集合：

集合	特点
ArrayList	1).实现List接口,顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层是基于数组实现，默认初始容量为10,jdk1.8调用add()时进行初始化容量；扩容则调用grow()；存储的元素是有序，有索引的，为访问元素提供了方便2).在多线程情况下使用是线程不安全的。3).添加和删除元素时需要操作下标，所以ArrayList的插入和删除操作效率低，查找效率高.
LinkedList	1)实现了List接口允许有null元素；2）在多线程情况下使用是不安全的，可以使用Collections.synchronizedList(),实现线程安全；3）LinkedList的查询效率相比较是效率低的.
Vector	1）该类和ArrayList非常相似，该类是线程安全的，可以用在多线程的情况，默认扩容方式为原来的2倍
HashSet	1)该类实现了Set接口，不允许出现重复元素，不保证集合中元素的顺序，允许包含值为null的元素，但最多只能一个。
TreeSet	1）该类实现了Set接口，可以实现排序等功能。内部比较器：TreeSet内部通过Comparator接口中的compare() 比较，默认是升序。外部比较器：实现Comparable接口，重写compareTo()进行排序。2）TreeSet是基于TreeMap实现的

Set和List的区别

1. Set 接口实例存储的是无序的，不重复的数据。List 接口实例存储的是有序的，可以重复的元素。

2. Set检索效率低下，删除和插入效率高，插入和删除不会引起元素位置改变 <实现类有HashSet,TreeSet>。

3. List和数组类似，可以动态增长，根据实际存储的数据的长度自动增长List的长度。查找元素效率高，插入删除效率低，因为会引起其他元素位置改变 <实现类有ArrayList,LinkedList,Vector> 

双列集合：

集合	特点
HashMap	HashMap 是一个散列表，它存储的内容是键值对(key-value)映射。该类实现了Map接口，根据键的HashCode值存储数据，具有很快的访问速度，最多允许一条记录的键为null，不支持线程同步。1）1)jdk1.7:底层数据结构是数组+链表。jdk1.8底层数据结构是数组+链表+红黑树（数组长度大于64，链表高度大于8转为红黑树）；引入红黑树的目的是数据不停的往链表中添加的话，链表的查询效率是比较低的，会导致整个集合的查询效率降低。2）
TreeMap	1).无序，不允许重复；2).TreeMap集合默认会对键进行排序，所以键必须实现自然排序（Comparator）和定制排序（Comparable）中的一种;3).底层使用的数据结构是二叉树

三、java集合源码分析

ArrayList源码分析：

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
	//默认初始容量
    private static final int DEFAULT_CAPACITY = 10;
    private static final Object[] EMPTY_ELEMENTDATA = {};
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
    //底层数据结构
    transient Object[] elementData; // non-private to simplify nested class access
    private int size;
    …………
    //构造函数
	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 ArrayList() {
    	//此时集合中还是空的，在调用add()时才将默认的容量初始化
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
    //每当向数组中添加元素时，都要去检查添加后元素的个数是否会超出当前数组的长度，如果超出，
    //数组将会进行扩容，数组扩容通过ensureCapacity(int minCapacity)来实现。
    //数组进行扩容时，会将老数组中的元素重新拷贝一份到新的数组中，每次数组容量的增长是其原容量的1.5倍。
    //在实际使用时，我们应该尽量避免数组容量的扩张。在构造ArrayList实例时，就指定其容量，
    //以避免数组扩容的发生。或者根据实际需求，通过调用ensureCapacity方法来手动增加ArrayList实例的容量
    
	public void ensureCapacity(int minCapacity) {
        int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
            // any size if not default element table
            ? 0
            // larger than default for default empty table. It's already
            // supposed to be at default size.
            : DEFAULT_CAPACITY;

        if (minCapacity > minExpand) {
            ensureExplicitCapacity(minCapacity);
        }
    }
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
	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);
    }
 }
 

HashMap源码分析：

	public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable {
		static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
		static final int MAXIMUM_CAPACITY = 1 << 30;
		static final float DEFAULT_LOAD_FACTOR = 0.75f;
		static final int TREEIFY_THRESHOLD = 8;
		static final int MIN_TREEIFY_CAPACITY = 64;
		…………
		public HashMap() {
	        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
	    }
	     public V put(K key, V value) {
	        return putVal(hash(key), key, value, false, true);
	    }



	    static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    	}


		final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    	}
	}

---

总结

学习笔记！