Java集合

Java集合

继承关系

集合类存放于Java.util包中。包含Collection和Map两大类

public interface Collection<E> extends Iterable<E> {
    int size();
    boolean isEmpty();
    boolean contains(Object o);
    Iterator<E> iterator();
    boolean equals(Object o);
    int hashCode();
    ...
}

List

List表示有序的Collection接口，实现类为ArrayList、Vector、LinkedList。

ArrayList、Vector底层为数组，LinkedList底层为链表

仅Vector为线程安全的

数据结构中的栈结构在Java中实现为Vector的其中一个子类

Set

Set表示无序的不重复的Collection接口，实现类有HashSet、TreeSet、LinkHashSet

HashSet底层为散列表、TreeSet底层为二叉树、LinkHashSet底层为TreeMap的SortedSet

Queue

Queue表示队列形式的Collection接口，主要实现类有BlockingQueue、PriorityQueue等种类繁多的队列。

BlockingQueue是线程安全的队列

PriorityQueue底层为数据结构中的大顶堆和小顶堆

Map

Map表示一键对多值的Collection，实现类有HashMap、ConcurrentHashMap、TreeMap、LinkedHashMap等。Map并不属于Collection。

public interface Map<K, V> {
    boolean isEmpty();
    boolean containsKey(Object key);
    boolean containsValue(Object value);
    void clear();
    boolean equals(Object o);
    int hashCode();
    ...
}

HashMap

HashMap 根据键的 hashCode 值存储数据，大多数情况下可以直接定位到它的值，因而具有很快的访问速度，但遍历顺序却是不确定的。最多只允许一条记录的键为 null，允许多条记录的值为 null。它不是线程安全的。如果需要满足线程安全，可以用 Collections 的 synchronizedMap 方法使 HashMap 具有线程安全的能力。

HashMap方法hashCode源码

public final int hashCode() {
	return Objects.hashCode(key) ^ Objects.hashCode(value);
}

Objects方法hashCode源码

public static int hashCode(Object o) {
	return o != null ? o.hashCode() : 0;
}

由此可见HashMap对hashCode进行了进一步封装，将键值对作为一个整体看待。

JDK7及以前HashMap的底层为传统的散列表结构，JDK8中当桶中的元素超过8个以后，会转化为红黑树结构，从而将查找的时间复杂度从O(N)降为O(lgN)。

ConcurrentHashMap

ConcurrentHashMap是HashMap的线程安全版本。

HashTable是一个遗留类，它也是线程安全的，如今已经不再推荐使用。它使用synchronized来锁住整张哈希表来实现线程安全，即每次锁住整张表让线程独占，相当于所有线程进行读写时都去竞争一把锁，导致效率非常低下。

在JDK7中，ConcurrentHashMap 是一个 Segment 数组，Segment 通过继承ReentrantLock 来进行加锁，所以每次需要加锁的操作锁住的是一个 segment，这样只要保证每个 Segment 是线程安全的，也就实现了全局的线程安全。

而大多数情况开发者仅需要一个Segment即可，这样的ConcurrentHashMap与HashTable差别不大。于是JDK8降低了锁的粒度，为每一个桶配一把锁。

以下为插入值部分的源码。仅有的两处注释处为检验锁的代码。

final V putVal(K key, V value, boolean onlyIfAbsent) {
    if (key == null || value == null) throw new NullPointerException();
    int hash = spread(key.hashCode());
    int binCount = 0;
    for (Node<K,V>[] tab = table;;) {
        Node<K,V> f; int n, i, fh; K fk; V fv;
        if (tab == null || (n = tab.length) == 0)
            tab = initTable();
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
            if (casTabAt(tab, i, null, new Node<K,V>(hash, key, value)))
                break;                   // no lock when adding to empty bin
        }
        else if ((fh = f.hash) == MOVED)
            tab = helpTransfer(tab, f);
        else if (onlyIfAbsent // check first node without acquiring lock
                 && fh == hash
                 && ((fk = f.key) == key || (fk != null && key.equals(fk)))
                 && (fv = f.val) != null)
            return fv;
        else {
            V oldVal = null;
            synchronized (f) {
                if (tabAt(tab, i) == f) {
                    if (fh >= 0) {
                        binCount = 1;
                        for (Node<K,V> e = f;; ++binCount) {
                            K ek;
                            if (e.hash == hash &&
                                ((ek = e.key) == key ||
                                 (ek != null && key.equals(ek)))) {
                                oldVal = e.val;
                                if (!onlyIfAbsent)
                                    e.val = value;
                                break;
                            }
                            Node<K,V> pred = e;
                            if ((e = e.next) == null) {
                                pred.next = new Node<K,V>(hash, key, value);
                                break;
                            }
                        }
                    }
                    else if (f instanceof TreeBin) {
                        Node<K,V> p;
                        binCount = 2;
                        if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
                                                              value)) != null) {
                            oldVal = p.val;
                            if (!onlyIfAbsent)
                                p.val = value;
                        }
                    }
                    else if (f instanceof ReservationNode)
                        throw new IllegalStateException("Recursive update");
                }
            }
            if (binCount != 0) {
                if (binCount >= TREEIFY_THRESHOLD)
                    treeifyBin(tab, i);
                if (oldVal != null)
                    return oldVal;
                break;
            }
        }
    }
    addCount(1L, binCount);
    return null;
}

TableTree

TreeMap 实现 SortedMap 接口，底层为二叉树，能够把它保存的记录根据键排序，默认是按键值的升序排序，也可以指定排序的比较器，当用 Iterator 遍历 TreeMap 时，得到的记录是排过序的。如果使用排序的映射，建议使用 TreeMap。

LinkedHashMap

LinkedHashMap保留了插入的顺序，底层为链表。

(你也可以在我的个人网站阅读此文章)
点击进入