Java提升班（四）面试必备—你不知道的数据集合

导读：Map居然不属于Java集合框架的子集？队列也和List同样属于集合的三大子集之一？更有队列的正确使用姿式，一块儿来看吧！

Java中的集合一般指的是Collection下的三个集合框架List、Set、Queue和Map集合，Map并不属于Collection的子集，而是和它平行的顶级接口。Collection下的子集的关系如文章开头图片所示。

本文的重点将会围绕： 集合的使用、性能、线程安全、差别性、源码解读等几个方面进行介绍。

本文涉及的知识点，分为两部分：

第一部分，Collection全部子集：

• List => Vector、ArrayList、LinkedList
• Set => HashSet、TreeSet
• Queue

第二部分，Map => Hashtable、HashMap、TreeMap、ConcurrentHashMap。

1、List

咱们先来看List、Vector、ArrayList、LinkedList，它们之间的继承关系图，以下图：

能够看出Vector、ArrayList、LinkedList，这三者都是实现集合框架中的List，也就是所谓的有序集合，所以具体功能也比较近似，好比都提供按照位置进行定位、添加或者删除的操做，都提供迭代器以遍历其内容等。但由于具体的设计区别，在行为、性能、线程安全等方面，表现又有很大不一样。

来看它们的主要方法，以下图：

经常使用方法：

• size 集合个数
• add()/add(int, E) 添加末尾/添加指定位置
• get(int) 获取
• remove 删除
• clear 清空
• ...

1.1 Vector

Vector是Java早期提供的 线程安全的动态数组， 若是不须要线程安全，并不建议选择，毕竟同步是有额外开销的。Vector 内部是使用对象数组来保存数据，能够根据须要自动的增长容量，当数组已满时，会建立新的数组，并拷贝原有数组数据。

看源代码能够知道，咱们Vector是经过 synchronized 实现线程安全的：

public synchronized boolean add(E e) {
    modCount++;
    ensureCapacityHelper(elementCount + 1);
    elementData[elementCount++] = e;
    return true;
}

Vector动态增长容量，源码查看：

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;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    elementData = Arrays.copyOf(elementData, newCapacity);
}

capacityIncrement变量是what？答案以下：

public Vector(int initialCapacity, int capacityIncrement) {
    super();
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    this.elementData = new Object[initialCapacity];
    this.capacityIncrement = capacityIncrement;
}

Vector动态增长容量总结： 由上面的源码可知，若是初始化Vector的时候指定了动态容量扩展大小，就增长指定的动态大小，若是未指定，则扩展一倍的容量。

1.2 ArrayList

ArrayList 是应用更加普遍的动态数组，它自己不是线程安全的，因此性能要好不少。

ArrayList的使用与Vector相似，但有着不一样的动态扩容机制，以下源码：

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

其中“>> 1”是位运算至关于除2，全部ArrayList扩容是动态扩展50%.

1.3 LinkedList

LinkedList 顾名思义是 Java 提供的双向链表，因此它不须要像上面两种那样调整容量，它也不是线程安全的，它包含一个很是重要的内部类：Entry。Entry是双向链表节点所对应的数据结构，它包括的属性有：当前节点所包含的值，上一个节点，下一个节点。

1.4 Vector、ArrayList、LinkedList区别

Vector、ArrayList、LinkedList的区别，能够从如下几个维度进行对比：

1.4.1 底层实现的区别

Vector、ArrayList 内部使用数组进行实现，LinkedList 内部使用双向链表实现。

1.4.2 读写性能方面的区别

ArrayList 对元素 非末位 的增长和删除都会引发内存分配空间的动态变化，所以非末位的操做速度较慢，但检索速度很快。

LinkedList 基于链表方式存放数据，增长和删除元素的速度较快，可是检索速度较慢。

1.4.3 线程安全方面的区别

Vector 使用了synchronized 修饰了操做方法是线程安全的，而 ArrayList、LinkedList 是非线程安全的。

若是须要使用线程安全的List可使用CopyOnWriteArrayList类。

2、Map

Hashtable、HashMap、TreeMap 都是最多见的一些 Map 实现，是以键值对的形式存储和操做数据的容器类型。

它们之间的关系，以下图：

• Hashtable 是早期 Java 类库提供的一个哈希表实现，自己是同步的，不支持 null 键和值，因为同步致使的性能开销，因此已经不多被推荐使用。
• HashMap 是应用更加普遍的哈希表实现，行为上大体上与 HashTable 一致，主要区别在于 HashMap 不是同步的，支持 null 键和值等。一般状况下，HashMap 进行 put 或者 get 操做，能够达到常数时间的性能，因此它是绝大部分利用键值对存取场景的首选，好比，实现一个用户 ID 和用户信息对应的运行时存储结构。
• TreeMap 则是基于红黑树的一种提供顺序访问的 Map，和 HashMap 不一样，它的 get、put、remove 之类操做都是 O（log(n)）的时间复杂度，具体顺序能够由指定的 Comparator 来决定，或者根据键的天然顺序来判断。

HashMap 的性能表现很是依赖于哈希码的有效性，请务必掌握 hashCode 和 equals 的一些基本约定，好比：

• equals 相等，hashCode 必定要相等；
• 重写了 equals 也要重写 hashCode；
• hashCode 须要保持一致性，状态改变返回的哈希值仍然要一致；
• equals 的对称、反射、传递等特性；

线程安全： Hashtable是线程安全的，HashMap和TreeMap是非线程安全的。HashMap可使用ConcurrentHashMap来保证线程安全。

3、Set

Set有两个比较经常使用的子集：HashSet、TreeSet.

HashSet内部使用的是HashMap实现的，看源代码可知：

public HashSet() {
    map = new HashMap<>();
}

HashSet也并非线程安全的，HashSet用于存储无序(存入和取出的顺序不必定相同)元素，值也不能重复。

HashSet能够去除重复的值，以下代码：

public static void main(String[] args) {
        Set set = new HashSet();
        set.add("orange");
        set.add("apple");
        set.add("banana");
        set.add("grape");
        set.add("banana");
        System.out.println(set);
}

编译器不会报错，执行的结果为：[orange, banana, apple, grape]，去掉了重复的“banana”选项。但排序是无序的，若是要实现有序的存储就要使用TreeSet了。

public static void main(String[] args) {
    Set set = new TreeSet();
    set.add("orange");
    set.add("apple");
    set.add("banana");
    set.add("grape");
    set.add("banana");
    System.out.println(set);
}

输出的结果是：[apple, banana, grape, orange]

一样，咱们查看源码发现，TreeSet的底层实现是TreeMap，源码以下：

public TreeSet() {
    this(new TreeMap<E,Object>());
}

TreeSet也是非线程安全的。

4、Queue

Queue（队列）与栈是相对的一种数据结构。只容许在一端进行插入操做，而在另外一端进行删除操做的线性表。栈的特色是后进先出，而队列的特色是先进先出。队列的用处很大，但大多都是在其余的数据结构中，好比，树的按层遍历，图的广度优先搜索等都须要使用队列作为辅助数据结构。

Queue的直接子集，以下图：

其中最经常使用的就是线程安全类：BlockingQueue.

4.1 Queue方法

• 添加：add(e) / offer(e)
• 移除：remove() / poll()
• 查找：element() / peek()

注意：

1. 避免add()和remove()方法，而是要使用offer()和poll()添加和移除元素。后者操做失败不会报错，前者会抛出异常；
2. element() / peek() 都为查询第一个元素，不会删除集合，但element()查询失败会抛出异常，peek()不会。

4.2 Queue使用

Queue<String> queue =  new LinkedList<String>();
queue.offer("a");
queue.offer("b");
queue.offer("c");
queue.offer("d");
System.out.println(queue);
queue.poll();
System.out.println(queue);
queue.poll();
queue.poll();
queue.poll();
System.out.println(queue.peek());
// System.out.println(queue.element()); // element 查询失败会抛出异常
System.out.println(queue);

4.3 其余队列

ArrayBlockingQueue 底层是数组，有界队列，若是咱们要使用生产者-消费者模式，这是很是好的选择。

LinkedBlockingQueue 底层是链表，能够当作无界和有界队列来使用，因此你们不要觉得它就是无界队列。

SynchronousQueue 自己不带有空间来存储任何元素，使用上能够选择公平模式和非公平模式。

PriorityBlockingQueue 是无界队列，基于数组，数据结构为二叉堆，数组第一个也是树的根节点老是最小值。

ArrayBlockingQueue ：一个由数组结构组成的有界阻塞队列。

LinkedBlockingQueue ：一个由链表结构组成的有界阻塞队列。

PriorityBlockingQueue ：一个支持优先级排序的无界阻塞队列。

DelayQueue：一个使用优先级队列实现的无界阻塞队列。

SynchronousQueue：一个不存储元素的阻塞队列。

LinkedTransferQueue：一个由链表结构组成的无界阻塞队列。

LinkedBlockingDeque：一个由链表结构组成的双向阻塞队列

5、扩展：String的线程安全

关于String、StringBuffer、StringBuilder的线程安全

String是典型的Immutable（不可变）类，被声明为final全部属性也都是final，全部它是不可变的，全部拼加、截取等动做等会产生新的String对象。

StringBuffer是为了解决上面的问题，而诞生的，提供了append方法实现了对字符串的拼加，append方法使用了synchronized实现了线程安全。

StringBuilder是JDK 1.5 新出的特性，做为StringBuffer的性能补充，StringBuffer的append方法使用了synchronized实现了线程的安全，但同时也带来了性能开销，在没有线程安全的状况下能够优先使用StringBuilder。

6、总结

List 也就是咱们前面介绍最多的有序集合，它提供了方便的访问、插入、删除等操做。

Set 是不容许重复元素的，这是和 List 最明显的区别，也就是不存在两个对象 equals 返回 true。咱们在平常开发中有不少须要保证元素惟一性的场合。

Queue/Deque 则是 Java 提供的标准队列结构的实现，除了集合的基本功能，它还支持相似先入先出（FIFO， First-in-First-Out）或者后入先出（LIFO，Last-In-First-Out）等特定行为。这里不包括 BlockingQueue，由于一般是并发编程场合，因此被放置在并发包里。

Map 是广义 Java 集合框架中的另一部分，Map 接口存储一组键值对象，提供key（键）到value（值）的映射。

7、参考资料

《码出高效：Java开发手册》

Java核心技术36讲：http://t.cn/EwUJvWA

Oracle docs：https://docs.oracle.com/javase/tutorial/collections/interfaces/queue.html