Java集合类

所在包：java.util

总共有两大接口：Collection 和Map ，一个元素集合，一个是键值对集合； 其中List和Set接口继承了Collection接口，一个是有序元素集合，一个是无序元素集合； 而ArrayList和 LinkedList 实现了List接口，HashSet实现了Set接口，这几个都比较常用； HashMap 和HashTable实现了Map接口，并且HashTable是线程安全的，但是HashMap性能更好；

List：

ArrayList：基于数组实现（默认是长度为10的数组），ArrayList随机访问快，而插入移除比较慢。

LinkedList：采用的是链式存储。链式存储就会定一个节点Node。包括三部分前驱节点、后继节点以及data值。所以存储存储的时候他的物理地址不一定是连续的。提供了优化的顺序访问，但是在随机访问方面相对较慢。特性功能要比ArrayList强大的多。支持Queue和Stack。

Set：

Set也是一个集合，但是他的特点是不可以有重复的对象，所以Set最常用的就是测试归属性，很容易的询问出某个对象是否存在Set中。

HashSet：HashSet查询速度比较快，但是存储的元素是随机的并没有排序

TreeSet：TreeSet是将元素存储红-黑树结构中，所以存储的结果是有顺序的（所以如果你想要自己存储的集合有顺序那么选择TreeSet）

Queue：

Queue是队列，队列是典型的先进先出的容器，就是从容器的一端放入元素，从另一端取出，并且元素放入容器的顺序和取出的顺序是相同的。LinkedList提供了对Queue的实现，LinkedList向上转型为Queue。其中Queue有offer、peek、element、pool、remove等方法

offer是将元素插入队尾，返回false表示添加失败。peek和element都将在不移除的情况下返回对头，但是peek在对头为null的时候返回null，而element会抛出NoSuchElementException异常。poll和remove方法将移除并返回对头，但是poll在队列为null，而remove会抛出NoSuchElementException异常。

PriorityQueue：调用offer方法插入一个对象的时候，这个对象就会按照优先级在对列中进行排序，默认的情况是自然排序，当然我们可以通过Comparator来修改这个顺序（在下一篇讲解）。PriorityQueue可以确保当你调用peek、pool、remove方法时，获取的元素将是对列中优先级最高的元素。

Map

HashMap：采用是散列函数所以查询的效率是比较高的。

HashMap的键可以是null，而且键值不可以重复，如果重复了以后就会对第一个进行键值进行覆盖。put进行添加值键对，containsKey验证主要是否存在、containsValue验证值是否存在、keySet获取所有的键集合、values获取所有值集合、entrySet获取键值对。

TreeMap：有序

总结

1）：数组是将数字和对象联系起来，它保存明确的对象，查询对象时候不需要对查询结果进行转换，它可以是多维的，可以保存基本类型的数据，但是数组一旦生成，其容量不能改变。所以数组是不可以直接删除和添加元素。

2）：Collection保存单一的元素，而Map保存相关联的值键对，有了Java泛型，可以指定容器存放对象类型，不会将错误类型的对象放在容器中，取元素时候也不需要转型。而且Collection和Map都可以自动调整其尺寸。容器不可以持有基本类型。

3）：像数组一样，List也建立数字索性和对象的关联，因此，数组和List都是排好序的容器，List可以自动扩容

4）：如果需要大量的随机访问就要使用ArrayList，如果要经常从中间插入和删除就要使用LinkedList。

5）：各种Queue和Stack由LinkedList支持

6）：Map是一种将对象（而非数字）与对象相关联的设计。HashMap用于快速访问，TreeMap保持键始终处于排序状态，所以不如HashMap快，而LinkedHashMap保持元素插入的顺序，但是也通过散列提供了快速访问的能力

7）：Set不接受重复的元素，HashSet提供最快的访问能力，TreeSet保持元素排序状态，LinkedHashSet以插入顺序保存元素。

JAVA容器可参考：java容器详细解析

快速失败与安全失败

java.util包下面的所有的集合类都是快速失败的，而java.util.concurrent包下面的所有的类都是安全失败的。

一：快速失败（fail—fast）

在用迭代器遍历一个集合对象时，如果遍历过程中对集合对象的内容进行了修改（增加、删除、修改），则会抛出Concurrent Modification Exception。 

原理：迭代器在遍历时直接访问集合中的内容，并且在遍历过程中使用一个 modCount 变量。集合在被遍历期间如果内容发生变化，就会改变modCount的值。每当迭代器使用hashNext()/next()遍历下一个元素之前，都会检测modCount变量是否为expectedmodCount值，是的话就返回遍历；否则抛出异常，终止遍历。

注意：这里异常的抛出条件是检测到 modCount！=expectedmodCount 这个条件。如果集合发生变化时修改modCount值刚好又设置为了expectedmodCount值，则异常不会抛出。因此，不能依赖于这个异常是否抛出而进行并发操作的编程，这个异常只建议用于检测并发修改的bug。

场景：java.util包下的集合类都是快速失败的，不能在多线程下发生并发修改（迭代过程中被修改）。

二：安全失败（fail—safe）

采用安全失败机制的集合容器，在遍历时不是直接在集合内容上访问的，而是先复制原有集合内容，在拷贝的集合上进行遍历。

原理：由于迭代时是对原集合的拷贝进行遍历，所以在遍历过程中对原集合所作的修改并不能被迭代器检测到，所以不会触发Concurrent Modification Exception。

缺点：基于拷贝内容的优点是避免了Concurrent Modification Exception，但同样地，迭代器并不能访问到修改后的内容，即：迭代器遍历的是开始遍历那一刻拿到的集合拷贝，在遍历期间原集合发生的修改迭代器是不知道的。

场景：java.util.concurrent包下的容器都是安全失败，可以在多线程下并发使用，并发修改。

HashMap的工作原理（JDK1.8以下版本）：

HashMap的底层是用hash数组和单向链表实现的 ，当调用put方法是，首先计算key的hashcode，定位到合适的数组索引，然后再在该索引上的单向链表进行循环遍历用equals比较key是否存在，如果存在则用新的value覆盖原值，如果没有插入单向链表的头部。HashMap的两个重要属性是容量capacity和加载因子loadfactor，默认值分布为16和0.75，当容器中的元素个数大于 capacity*loadfactor时，容器会进行扩容resize 为2n，在初始化Hashmap时可以对着两个值进行修改，负载因子0.75被证明为是性能比较好的取值，通常不会修改，那么只有初始容量capacity会导致频繁的扩容行为，这是非常耗费资源的操作，所以，如果事先能估算出容器所要存储的元素数量，最好在初始化时修改默认容量capacity，以防止频繁的resize操作影响性能。

java8对hashmap做了优化 ，底层有两种实现方法，一种是数组和链表，一种是数组和红黑树，hsahmap会根据数据量选择存储结构

if (binCount >= TREEIFY_THRESHOLD - 1),符合这个条件的时候，把链表变成treemap，这样查找效率从o(n)变成了o(log n)

参考文章：HashMap实现原理分析

JDK1.8以下的版本源码解析请参照：【Java集合源码剖析】HashMap源码剖析

JDK1.8的请参考：Java源码分析之HashMap(JDK1.8)

hashCode()和equals()方法的重要性体现在什么地方？

hashCode和equals的详解：

hashCode的值是通过哈希函数计算得出的，它和地址值是映射关系，并不就是地址值，而当比较两个不同的对象时（比如在hashMap和hashSet）重写equals必须重写hashCode是为了提高比较的效率，当hashCode值不同时，二者的equals返回结果必为false，而当hashCode值相同时，则有哈希冲突，此时在哈希表中存储方式是通过探测方法逐一去查找空位，二者比较时则再调用equals方法

http://blog.youkuaiyun.com/javazejian/article/details/51348320

equals方法与‘==’运算符有什么区别？

默认情况下也就是从超类Object继承而来的equals方法与‘==’是完全等价的，比较的都是对象的内存地址，但我们可以重写equals方法，使其按照我们的需求的方式进行比较，如String类重写了equals方法，使其比较的是字符的序列，而不再是内存地址。

重写equals方法时也必须重写hashCode方法。

HashMap和HashTable有什么区别？

 1、继承的父类不同

      Hashtable继承自Dictionary类，而HashMap继承自AbstractMap类。但二者都实现了Map接口。

2、线程安全性不同

 Hashtable 中的方法是Synchronize的，而HashMap中的方法在缺省情况下是非Synchronize的。

 3、是否提供contains方法

      HashMap把Hashtable的contains方法去掉了，改成containsValue和containsKey，因为contains方法容易让人引起误解。

 4、key和value是否允许null值

      通过上面的ContainsKey方法和ContainsValue的源码我们可以很明显的看出：

      Hashtable中，key和value都不允许出现null值。但是如果在Hashtable中有类似put(null,null)的操作，编译同样可以通过，因为key和value都是Object类型，但运行时会抛出NullPointerException异常，这是JDK的规范规定的。
HashMap中，null可以作为键，这样的键只有一个；可以有一个或多个键所对应的值为null。当get()方法返回null值时，可能是 HashMap中没有该键，也可能使该键所对应的值为null。因此，在HashMap中不能由get()方法来判断HashMap中是否存在某个键， 而应该用containsKey()方法来判断。

 5、两个遍历方式的内部实现上不同

      Hashtable、HashMap都使用了 Iterator。而由于历史原因，Hashtable还使用了Enumeration的方式 。

 6、hash值不同

      哈希值的使用不同，HashTable直接使用对象的hashCode。而HashMap重新计算hash值。

 7、内部实现使用的数组初始化和扩容方式不同

      HashTable在不指定容量的情况下的默认容量为11，而HashMap为16，Hashtable不要求底层数组的容量一定要为2的整数次幂，而HashMap则要求一定为2的整数次幂。

为什么HashMap的容量是2的幂次？

非常重要的原因就是为了hash的平均分布。

hashMap源码获取元素的位置：

static int indexFor(int h, int length) {
    // assert Integer.bitCount(length) == 1 : "length must be a non-zero power of 2";
    return h & (length-1);
}

解释：

h:为插入元素的hashcode

length:为map的容量大小

如果length为2的次幂  则length-1 转化为二进制必定是11111……的形式，二进制中为1的位数越多，分布就平均。

而且空间不浪费；如果length不是2的次幂，比如length为15，则length-1为14，对应的二进制为1110，在于h与操作，

最后一位都为0，而0001，0011，0101，1001，1011，0111，1101这几个位置永远都不能存放元素了，空间浪费相当大。

http://blog.youkuaiyun.com/fujiakai/article/details/51585767

在多线程下使用HashMap我们需要怎么做，几种方案：

• 在外部包装HashMap，实现同步机制
• 使用Map m = Collections.synchronizedMap(new HashMap(...));，这里就是对HashMap做了一次包装
• 使用java.util.HashTable，效率最低
• 使用java.util.concurrent.ConcurrentHashMap，相对安全，效率较高

Concurrent下的线程安全集合

ArrayBlockingQueue的实现机制是ReentrantLock和Condition来实现的。

ConcurrentHashMap支持高并发、高吞吐量的线程安全HashMap实现，其实现原理是锁分离机制，将数据分Segment管理。每个Segment拥有独立的锁。默认16个segment的数组，每个segment中实现就是hashMap了，通过hash定位segment。put操作是在segment层上加锁的，这样可以减少并发的冲突；读操作大多数情况下无锁操作（仅仅找到的hashentry对应的对象为null时，有锁操作）。

JDK1.8中放弃了Segment臃肿的设计，取而代之的是采用Node + CAS + Synchronized来保证并发安全进行实现。

详细可参考：ConcurrentHashMap总结

CopyOnWriteArrayList：传统的List在多线程同时读写的时候会抛出java.util.ConcurrentModificationException，而CopyOnWriteArrayList是使用CopyOnWrite（写时复制）技术解决了这个问题，这一般需要很大的开销，但是当遍历操作的数量大大超过可变操作的数量时，这种方法可能比其他替代方法更有效。

BlockingQueue

BlockingQueue接口定义了一种阻塞的FIFO queue，每一个BlockingQueue都有一个容量，让容量满时往BlockingQueue中添加数据时会造成阻塞，当容量为空时取元素操作会阻塞。

ArrayBlockingQueue是一个由数组支持的有界阻塞队列。在读写操作上都需要锁住整个容器，因此吞吐量与一般的实现是相似的，适合于实现“生产者消费者”模式。

 

基于链表的阻塞队列，同ArrayListBlockingQueue类似，其内部也维持着一个数据缓冲队列（该队列由一个链表构成），当生产者往队列中放入一个数据时，队列会从生产者手中获取数据，并缓存在队列内部，而生产者立即返回；只有当队列缓冲区达到最大值缓存容量时（LinkedBlockingQueue可以通过构造函数指定该值），才会阻塞生产者队列，直到消费者从队列中消费掉一份数据，生产者线程会被唤醒，反之对于消费者这端的处理也基于同样的原理。而LinkedBlockingQueue之所以能够高效的处理并发数据，还因为其对于生产者端和消费者端分别采用了独立的锁来控制数据同步，这也意味着在高并发的情况下生产者和消费者可以并行地操作队列中的数据，以此来提高整个队列的并发性能。

 

ArrayBlockingQueue和LinkedBlockingQueue的区别：

1. 队列中锁的实现不同

    ArrayBlockingQueue实现的队列中的锁是没有分离的，即生产和消费用的是同一个锁；

    LinkedBlockingQueue实现的队列中的锁是分离的，即生产用的是putLock，消费是takeLock

2. 在生产或消费时操作不同

    ArrayBlockingQueue实现的队列中在生产和消费的时候，是直接将枚举对象插入或移除的；

    LinkedBlockingQueue实现的队列中在生产和消费的时候，需要把枚举对象转换为Node<E>进行插入或移除，会影响性能

3. 队列大小初始化方式不同

    ArrayBlockingQueue实现的队列中必须指定队列的大小；

    LinkedBlockingQueue实现的队列中可以不指定队列的大小，但是默认是Integer.MAX_VALUE

详细可参考：深入剖析java并发之阻塞队列LinkedBlockingQueue与ArrayBlockingQueue

参考文档：

Concurrent下的线程安全集合

谈谈ConcurrentHashMap1.7和1.8的不同实现