集合概述
1.1 Java集合概述
1.2 List, Set, Map三者的区别
1.3 集合框架底层数据结构总结
1.4 如何选用集合？
1.5 为什么要使用集合?
1.6 Iterator迭代器
1.7 哪些集合是线程不安全的? 怎么解决呢？

Collection子接口之List
2.1 Arraylist和vector的区别
2.2 Arraylist和linkedlist区别
2.3 Arraylist的扩容机制

Collection子接口之Set
3.1 comparable和Comparator的区别
3.2 无序性和不可重复性的含义
3.3 比较HashSet、LinkedHashSet和TreeSet三者的异同

Map接口
4.1 HashMap和Hashtable的区别
4.2 HashMap和HashSet的区别
4.3 HashMap和TreeMap区别
4.4 HashSet如何检查重复
4.5 HashMap的底层实现
4.6 HashMap的长度为什么是2的幂次方
4.7 HashMap多线程导致死循环问题
4.8 HashMap常见的遍历方式
4.9 ConcurrentHashMap和Hashtable的区别
4.10 ConcurrentHashMap线程安全的具体实现方式

Collections工具类
5.1 排序操作
5.2 查找，替换操作
5.3 同步控制

其他重要问题
6.1 快速失败(fail-fast)
6.2 安全失败
6.3 Arrays.asList()避坑指南

1. 集合概述

1.1 Java集合概述

Java集合中除了Map结尾的类，其他类都实现了 Collection 接口。

并且，以 Map 结尾的类都实现了 Map 接口。

Java-Collections

1.2 List, Set, Map三者的区别

List: 有序可重复
Set: 无序不可重复
Map: 使用键值对（kye-value）存储, Key 是无序的、不可重复的，value 是无序的、可重复的，每个键最多映射到一个值。

1.3 集合框架底层数据结构总结

Collection接口下的集合:

1.3.1 List

ArrayList: Object[]数组
Vector: Object[]数组
LinkedList: 双向链表(JDK1.6之前为循环链表，JDK1.7取消了循环)

1.3.2 Set

HashSet: 无序，唯一，基于 HashMap 实现的，底层采用 HashMap 来保存元素
LinkedHashSet: LinkedHashSet 是 HashSet 的子类，并且其内部是通过 LinkedHashMap 来实现的。
TreeSet: 有序唯一，红黑树(自平衡的排序二叉树)

1.3.3 Map

HashMap: JDK1.8 之前 HashMap 由数组+链表组成的，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突而存在的（“拉链法”解决冲突）。JDK1.8 以后在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为 8）（将链表转换成红黑树前会判断，如果当前数组的长度小于 64，那么会选择先进行数组扩容，而不是转换为红黑树）时，将链表转化为红黑树，以减少搜索时间
LinkedHashMap: LinkedHashMap 继承自 HashMap，所以它的底层仍然是基于拉链式散列结构即由数组和链表或红黑树组成。另外，LinkedHashMap 在上面结构的基础上，增加了一条双向链表，使得上面的结构可以保持键值对的插入顺序。同时通过对链表进行相应的操作，实现了访问顺序相关逻辑。
Hashtable: 数组+链表组成的，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突而存在的
TreeMap: 红黑树（自平衡的排序二叉树）

集合概述总结

1.4 如何选用集合？

主要根据集合的特点来选用，比如我们需要根据键值获取到元素值时就选用 Map 接口下的集合，需要排序时选择 TreeMap,不需要排序时就选择 HashMap,需要保证线程安全就选用 ConcurrentHashMap。

当我们只需要存放元素值时，就选择实现Collection 接口的集合，需要保证元素唯一时选择实现 Set 接口的集合比如 TreeSet 或 HashSet，不需要就选择实现 List 接口的比如 ArrayList 或 LinkedList，然后再根据实现这些接口的集合的特点来选用。

1.5 为什么要使用集合?

当我们需要保存一组类型相同的数据的时候，我们应该是用一个容器来保存，这个容器就是数组，但是，使用数组存储对象具有一定的弊端，因为我们在实际开发中，存储的数据的类型是多种多样的，于是，就出现了“集合”，集合同样也是用来存储多个数据的。

数组的缺点是一旦声明之后，长度就不可变了；同时，声明数组时的数据类型也决定了该数组存储的数据的类型；而且，数组存储的数据是有序的、可重复的，特点单一。但是集合提高了数据存储的灵活性，Java 集合不仅可以用来存储不同类型不同数量的对象，还可以保存具有映射关系的数据

1.6 Iterator迭代器

1.6.1 迭代器Iterator是什么?

public interface Iterator {
    //集合中是否还有元素
    boolean hasNext();
    //获得集合中的下一个元素
    E next();
    ......
}

Iterator 对象称为迭代器（设计模式的一种），迭代器可以对集合进行遍历。迭代器把与迭代相关的方法抽取出来形成一个接口，然后在每个类的内部，定义自己迭代方式，这样做就规定了整个集合体系的遍历方式都是 hasNext()和next()方法，使用者不用管怎么实现的，会用即可。迭代器的定义为：提供一种方法访问一个容器对象中各个元素，而又不需要暴露该对象的内部细节。

1.6.2 迭代器Iterator有啥用?

Iterator 主要是用来遍历集合用的，它的特点是更加安全，因为它可以确保，在当前遍历的集合元素被更改的时候，就会抛出 ConcurrentModificationException 异常。

1.6.3 如何使用?

示例: 迭代器遍历HashMap

    public static void main(String[] args) {
        Map map = new HashMap();
        map.put(1, "Java");
        map.put(2, "C++");
        map.put(3, "PHP");

        /**
         * hm.entrySet() is used to retrieve
         * all the key-value pairs called TreeMapTest.Entries and stores internally into a set.
         *
         * hm.entrySet().iterator() returns a iterator which acts as a cursor
         * and points at the first element of the set and moves on till the end.
         */
        Iterator> iterator = map.entrySet().iterator();
        while (iterator.hasNext()){
            Map.Entry entry =  iterator.next();
            System.out.println(entry.getKey() + " "+ entry.getValue());

        }
    }

1.7 哪些集合是线程不安全的? 怎么解决呢？

Arraylist ,LinkedList,Hashmap,HashSet,TreeSet,TreeMap，PriorityQueue 都不是线程安全的。解决办法很简单，可以使用线程安全的集合来代替。

java.util.concurrent 包中提供了很多并发容器：

ConcurrentHashMap: 可以看作是线程安全的 HashMap
CopyOnWriteArrayList:可以看作是线程安全的 ArrayList，在读多写少的场合性能非常好，远远好于 Vector.
ConcurrentLinkedQueue:高效的并发队列，使用链表实现。可以看做一个线程安全的 LinkedList，这是一个非阻塞队列。
BlockingQueue: 这是一个接口，JDK 内部通过链表、数组等方式实现了这个接口。表示阻塞队列，非常适合用于作为数据共享的通道。
ConcurrentSkipListMap :跳表的实现。这是一个Map，使用跳表的数据结构进行快速查找。

2. Collection子接口之List

2.1 Arraylist和vector的区别

ArrayList 是 List 的主要实现类，底层使用 Object[]存储，适用于频繁的查找工作，线程不安全；
Vector 是 List 的古老实现类，底层使用 Object[]存储，线程安全的。

2.2 Arraylist和linkedlist区别

区别主要和底层使用的数据结构相关。

是否保证线程安全： ArrayList 和 LinkedList 都是不同步的，也就是不保证线程安全；
底层数据结构： Arraylist 底层使用的是 Object 数组；LinkedList 底层使用的是双向链表数据结构（JDK1.6 之前为循环链表，JDK1.7 取消了循环。）
插入和删除是否受元素位置的影响： ① ArrayList 采用数组存储，所以插入和删除元素的时间复杂度受元素位置的影响。比如：执行add(E e)方法的时候， ArrayList 会默认在将指定的元素追加到此列表的末尾，这种情况时间复杂度就是 O(1)。但是如果要在指定位置 i 插入和删除元素的话（add(int index, E element)）时间复杂度就为 O(n-i)。因为在进行上述操作的时候集合中第 i 和第 i 个元素之后的(n-i)个元素都要执行向后位/向前移一位的操作。 ② LinkedList 采用链表存储，所以对于add(E e)方法的插入，删除元素时间复杂度不受元素位置的影响，近似 O(1)，如果是要在指定位置i插入和删除元素的话（(add(int index, E element)）时间复杂度近似为o(n))因为需要先移动到指定位置再插入。
是否支持快速随机访问： LinkedList 不支持高效的随机元素访问，而 ArrayList 支持。快速随机访问就是通过元素的序号快速获取元素对象(对应于get(int index)方法)。
内存空间占用： ArrayList 的空间浪费主要体现在在 list 列表的结尾会预留一定的容量空间，而 LinkedList 的空间花费则体现在它的每一个元素都需要消耗比 ArrayList 更多的空间（因为要存放直接后继和直接前驱以及数据）。

List之间的比较

2.2.1 双向链表和双向循环链表

双向链表：包含两个指针，一个 prev 指向前一个节点，一个 next 指向后一个节点。

双向循环链表：最后一个节点的 next 指向 head，而 head 的 prev 指向最后一个节点，构成一个环。

2.2.2 补充内容:RandomAccess 接口

public interface RandomAccess {
}

RandomAccess 接口算是一个标识，标识实现这个接口的类具有随机访问功能。

在 binarySearch（) 方法中，它要判断传入的 list 是否 RamdomAccess 的实例，如果是，调用indexedBinarySearch()方法，如果不是，那么调用iteratorBinarySearch()方法。

    public static  int binarySearch(List> list, T key) {
        if (list instanceof RandomAccess || list.size()

 
 ArrayList 实现了 RandomAccess 接口， 而 LinkedList 没有实现。 这可能与底层数据结构相关， ArrayList 底层是数组，而 LinkedList 底层是链表。数组天然支持随机访问，时间复杂度为 O(1)，所以称为快速随机访问。链表需要遍历到特定位置才能访问特定位置的元素，时间复杂度为 O(n)，所以不支持快速随机访问。，ArrayList 实现了 RandomAccess 接口，就表明了他具有快速随机访问功能。 
 2.3 Arraylist的扩容机制 
 2.3.1 ArrayList的构造函数 
    /**
     * 默认初始容量大小
     */
    private static final int DEFAULT_CAPACITY = 10;
    

    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    /**
     *默认构造函数，使用初始容量10构造一个空列表(无参数构造)
     */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
    
    /**
     * 带初始容量参数的构造函数。（用户自己指定容量）
     */
    public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {//初始容量大于0
            //创建initialCapacity大小的数组
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {//初始容量等于0
            //创建空数组
            this.elementData = EMPTY_ELEMENTDATA;
        } else {//初始容量小于0，抛出异常
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }


   /**
    *构造包含指定collection元素的列表，这些元素利用该集合的迭代器按顺序返回
    *如果指定的集合为null，throws NullPointerException。 
    */
     public ArrayList(Collection c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // replace with empty array.
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }
 
 以无参数构造方法创建 ArrayList 时，实际上初始化赋值的是一个空数组。当真正对数组进行添加元素操作时，才真正分配容量。即向数组中添加第一个元素时，数组容量扩为10。 
 2.3.2 ArrayList扩容机制的工作过程 
 以ArrayList为例 
  
  add方法 
  
     /**
     * 将指定的元素追加到此列表的末尾。 
     */
    public boolean add(E e) {
   //添加元素之前，先调用ensureCapacityInternal方法
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        //这里看到ArrayList添加元素的实质就相当于为数组赋值
        elementData[size++] = e;
        return true;
    }
 
  
  ensureCapacityInternal()方法
 add 方法 首先调用了ensureCapacityInternal(size + 1) 
  
    //得到最小扩容量
    private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
              // 获取默认的容量和传入参数的较大值
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }
 
 当 要 add 进第1个元素时，minCapacity为1，在Math.max()方法比较后，minCapacity 为10。 
  
  ensureExplicitCapacity() 方法
 ensureCapacityInternal() 方法就一定会经过（执行）这个方法 
  
   //判断是否需要扩容
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            //调用grow方法进行扩容，调用此方法代表已经开始扩容了
            grow(minCapacity);
    }
 
 基本的工作过程: 
  
  当我们要 add 进第1个元素到 ArrayList 时，elementData.length 为0 （因为还是一个空的 list），因为执行了 ensureCapacityInternal() 方法 ，所以 minCapacity 此时为10。此时，minCapacity - elementData.length > 0 成立，所以会进入 grow(minCapacity) 方法。 
  当add第2个元素时，minCapacity 为2，此时e lementData.length(容量)在添加第一个元素后扩容成 10 了。此时，minCapacity - elementData.length > 0 不成立，所以不会进入 （执行）grow(minCapacity) 方法。 
  添加第3、4···到第10个元素时，依然不会执行grow方法，数组容量都为10。 
  
 直到添加第11个元素，minCapacity(为11)比elementData.length（为10）要大。进入grow方法进行扩容。 
  
  grow()方法 
  
     /**
     * 要分配的最大数组大小
     */
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    /**
     * ArrayList扩容的核心方法。
     */
    private void grow(int minCapacity) {
        // oldCapacity为旧容量，newCapacity为新容量
        int oldCapacity = elementData.length;
        //将oldCapacity 右移一位，其效果相当于oldCapacity /2，
        //我们知道位运算的速度远远快于整除运算，整句运算式的结果就是将新容量更新为旧容量的1.5倍，
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        //然后检查新容量是否大于最小需要容量，若还是小于最小需要容量，那么就把最小需要容量当作数组的新容量，
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
       // 如果新容量大于 MAX_ARRAY_SIZE,进入(执行) `hugeCapacity()` 方法来比较 minCapacity 和 MAX_ARRAY_SIZE，
       //如果minCapacity大于最大容量，则新容量则为`Integer.MAX_VALUE`，否则，新容量大小则为 MAX_ARRAY_SIZE 即为 `Integer.MAX_VALUE - 8`。
        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);
    }
 
 int newCapacity = oldCapacity + (oldCapacity >> 1), 所以 ArrayList 每次扩容之后容量都会变为原来的 1.5 倍左右（oldCapacity为偶数就是1.5倍，否则是1.5倍左右）。 
 grow()方法工作过程: 
  
  当add第1个元素时，oldCapacity 为0，经比较后第一个if判断成立，newCapacity = minCapacity(为10)。但是第二个if判断不会成立，即newCapacity 不比 MAX_ARRAY_SIZE大，则不会进入 hugeCapacity 方法。数组容量为10，add方法中 return true,size增为1。 
  当add第11个元素进入grow方法时，newCapacity为15，比minCapacity（为11）大，第一个if判断不成立。新容量没有大于数组最大size，不会进入hugeCapacity方法。数组容量扩为15，add方法中return true,size增为11。 
  以此类推······ 
  
  
  hugeCapacity() 方法
 如果新容量大于 MAX_ARRAY_SIZE,进入(执行) hugeCapacity() 方法来比较 minCapacity 和 MAX_ARRAY_SIZE，如果minCapacity大于最大容量，则新容量则为Integer.MAX_VALUE，否则，新容量大小则为 MAX_ARRAY_SIZE 即为 Integer.MAX_VALUE - 8。 
  
     private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        //对minCapacity和MAX_ARRAY_SIZE进行比较
        //若minCapacity大，将Integer.MAX_VALUE作为新数组的大小
        //若MAX_ARRAY_SIZE大，将MAX_ARRAY_SIZE作为新数组的大小
        //MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }
 
  
   
     
    
   
  
    ArrayList扩容机制 
   
  
 2.3.3 System.arraycopy() 和 Arrays.copyOf()方法 
  
  System.arraycopy()方法
 arraycopy() 需要目标数组，将原数组拷贝到你自己定义的数组里或者原数组，而且可以选择拷贝的起点和长度以及放入新数组中的位置 .
 示例： 
  
     //结果: 0 1 99 2 3 0 0 0 0 0 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] a = new int[10];
        a[0] = 0;
        a[1] = 1;
        a[2] = 2;
        a[3] = 3;
        /**
         * 第一个参数就是源数组，第二个参数是要复制的源数组中的起始位置，
         * 第三个参数是目标数组，第四个参数是要复制到的目标数组的起始位置，
         * 第五个参数是要复制的元素的长度。
         */
        System.arraycopy(a, 2, a, 3, 3);
        a[2]=99;
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
    }
 
  
  Arrays.copyOf()方法
 copyOf() 是系统自动在内部新建一个数组，并返回该数组。copyOf() 是系统自动在内部新建一个数组，并返回该数组。copyOf() 内部实际调用了 System.arraycopy() 方法。 
  
     //结果: 10
    public static void main(String[] args) {
        int[] a = new int[3];
        a[0] = 0;
        a[1] = 1;
        a[2] = 2;
        int[] b = Arrays.copyOf(a, 10);
        System.out.println("b.length: "+b.length);
    }
 
 2.3.4 ensureCapcity方法 
 在add大量元素之前用 ensureCapacity 方法，以减少增量重新分配的次数。
 然而我的测试结果并没有发现这个有什么用 = = 待办... 
 3. Collection子接口之Set 
 3.1 comparable和Comparator的区别 
  
  comparable 接口实际上是出自java.lang包 它有一个 compareTo(Object obj)方法用来排序 
  comparator接口实际上是出自 java.util 包它有一个compare(Object obj1, Object obj2)方法用来排序 
  
 3.1.1 Comparator 定制排序 
 package javaBasic.container;

import java.util.ArrayList;
import java.util.Collections;

public class Comparator {

    /**
     * 原始数组:
     * [-1, 3, 3, -5, 7, 4, -9, -7]
     * Collections.reverse(arrayList):
     * [-7, -9, 4, 7, -5, 3, 3, -1]
     * Collections.sort(arrayList):
     * [-9, -7, -5, -1, 3, 3, 4, 7]
     * Collections.sort(arrayList):
     * [7, 4, 3, 3, -1, -5, -7, -9]
     *
     * @param args
     */
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        arrayList.add(-1);
        arrayList.add(3);
        arrayList.add(3);
        arrayList.add(-5);
        arrayList.add(7);
        arrayList.add(4);
        arrayList.add(-9);
        arrayList.add(-7);
        System.out.println("原始数组:");
        System.out.println(arrayList);
        // void reverse(List list)：反转
        Collections.reverse(arrayList);
        System.out.println("Collections.reverse(arrayList):");
        System.out.println(arrayList);

        //Collections是处理容器的，void sort(List list),按自然排序的升序排序
        Collections.sort(arrayList);
        System.out.println("Collections.sort(arrayList):");
        System.out.println(arrayList);

        //定制排序的用法
        Collections.sort(arrayList, new java.util.Comparator() {
            /**
             * o1 o2 每次取一个数值，一次比较两个数据，
             * 然后配合compareTo()实现两个数字排序，
             *
             * 原理: 调用了compare方法，当方法的返回值大于0的时候就将数组的前一个数和后一个数做交换。
             * 以升序为例来讲解，升序的话compare方法就 return o1 - o2，
             * 那么就是 return dest[j-1] - dest[j]。
             *
             * 当 dest[j-1] > dest[j] 时，就进行交换。当 dest[j-1] <= dest[j] 时位置不变，
             * 从而达到数组升序。
             * @param o1
             * @param o2
             * @return
             */
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2.compareTo(o1);
            }
        });

        //Collections.sort(arrayList);
        System.out.println("Collections.sort(arrayList):");
        System.out.println(arrayList);
    }

}
 
 3.1.2 重写 compareTo 方法实现按年龄来排序 
 package javaBasic.container;

import java.util.Set;
import java.util.TreeMap;

/**
 * 重写compareTo方法实现按年龄来排序
 */
// person对象没有实现Comparable接口，所以必须实现，这样才不会出错，才可以使treemap中的数据按顺序排列
// 前面一个例子的String类已经默认实现了Comparable接口，详细可以查看String类的API文档，另外其他
// 像Integer类等都已经实现了Comparable接口，所以不需要另外实现了
public class Person implements Comparable{

    private String name;
    private int age;

    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    /**
     * T重写compareTo方法实现按年龄排序
     * @param o
     * @return
     */
    @Override
    public int compareTo(Person o) {
        if (this.age > o.getAge()) {
            return 1;
        }
        if (this.age < o.getAge()) {
            return -1;
        }
        return 0;
    }

    /**
     * 输出结果为:
     * 5-小红
     * 10-王五
     * 20-李四
     * 30-张三
     * 
     * @param args
     */
    public static void main(String[] args) {
        TreeMap pdata = new TreeMap();
        pdata.put(new Person("张三", 30), "zhangsan");
        pdata.put(new Person("李四", 20), "lisi");
        pdata.put(new Person("王五", 10), "wangwu");
        pdata.put(new Person("小红", 5), "xiaohong");
        // 得到key的值的同时得到key所对应的值
        Set keys = pdata.keySet();
        for (Person key : keys) {
            System.out.println(key.getAge() + "-" + key.getName());

        }
    }
}
 
 3.2 无序性和不可重复性的含义 
  
  无序性: 存储的数据在底层数组中并非按照数组索引的顺序添加 ，而是根据数据的哈希值决定的。 
  不可重复性: 指添加的元素按照 equals()判断时 ，返回 是false才可以添加进去。需要同时重写 equals()方法和 HashCode()方法。 
  
 3.3 比较HashSet、LinkedHashSet和TreeSet三者的异同 
 HashSet 是 Set 接口的主要实现类 ，HashSet 的底层是 HashMap，线程不安全的，可以存储 null 值； 
 LinkedHashSet 是 HashSet 的子类，能够按照添加的顺序遍历； 
 TreeSet 底层使用红黑树，能够按照添加元素的顺序进行遍历，排序的方式有自然排序和定制排序。 
 4. Map接口 
 4.1 HashMap和Hashtable的区别 
  
   线程是否安全： HashMap 是非线程安全的，HashTable 是线程安全的,因为 HashTable 内部的方法基本都经过synchronized 修饰。 
   效率： 因为线程安全的问题，HashMap 要比 HashTable 效率高一点。另外，HashTable 基本被淘汰，不要在代码中使用它； 
   对 Null key 和 Null value 的支持： HashMap 可以存储 null 的 key 和 value，但 null 作为键只能有一个，null 作为值可以有多个；HashTable 不允许有 null 键和 null 值，否则会抛出 NullPointerException。 
   初始容量大小和每次扩充容量大小的不同： ① 创建时如果不指定容量初始值，Hashtable 默认的初始大小为 11，之后每次扩充，容量变为原来的 2n+1。HashMap 默认的初始化大小为 16。之后每次扩充，容量变为原来的 2 倍。② 创建时如果给定了容量初始值，那么 Hashtable 会直接使用你给定的大小，而 HashMap 会将其扩充为 2 的幂次方大小（HashMap 中的tableSizeFor()方法保证，下面给出了源代码）。也就是说 HashMap 总是使用 2 的幂作为哈希表的大小。 
   底层数据结构： JDK1.8 以后的 HashMap 在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为 8）（将链表转换成红黑树前会判断，如果当前数组的长度小于 64，那么会选择先进行数组扩容，而不是转换为红黑树）时，将链表转化为红黑树，以减少搜索时间。Hashtable 没有这样的机制。 
  
 HashMap中带有初始容量的构造函数: 
     public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
        this.loadFactor = loadFactor;
        this.threshold = tableSizeFor(initialCapacity);
    }
     public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }
 
 下面这个方法保证了 HashMap 总是使用 2 的幂作为哈希表的大小。 
     /**
     * Returns a power of two size for the given target capacity.
     */
    static final int tableSizeFor(int cap) {
        int n = cap - 1;
        n |= n >>> 1;
        n |= n >>> 2;
        n |= n >>> 4;
        n |= n >>> 8;
        n |= n >>> 16;
        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
    }
 
 4.2 HashMap和HashSet的区别 
 HashSet 底层就是基于 HashMap 实现的。 
 
 
  
   
     
    
   
  
    HashMap和HashSet的区别 
   
  
  
   
     
    
   
  
    HashMap特征 
   
  
 4.3 HashMap和TreeMap区别 
 TreeMap 和HashMap 都继承自AbstractMap ，但是需要注意的是TreeMap它还实现了NavigableMap接口和SortedMap 接口。 
  
   
     
    
   
  
    HashMap和TreeMap区别 
   
  
 实现 NavigableMap 接口让 TreeMap 有了对集合内元素的搜索的能力。 
 实现SortMap接口让 TreeMap 有了对集合中的元素根据键排序的能力。默认是按 key 的升序排序，不过我们也可以指定排序的比较器。示例代码如下： 
 package javaBasic.container.TreeMapTest;

import java.util.Comparator;
import java.util.TreeMap;


public class Person {
    private Integer age;

    public Person(Integer age) {
        this.age = age;
    }

    public Integer getAge() {
        return age;
    }

    /**
     * 输出结果:
     * person1
     * person4
     * person2
     * person3
     * 测试搜索功能（找年龄大于16的人）:
     * person2
     * person3
     *
     * 可以看出，TreeMap 中的元素已经是按照 Person 的 age 字段的升序来排列了。
     * 
     * 相比于HashMap来说 TreeMap 主要多了对集合中的元素根据键排序的能力以及对集合内元素的搜索的能力。
     * @param args
     */
    public static void main(String[] args) {
        TreeMap treeMap = new TreeMap<>(new Comparator() {
            @Override
            public int compare(Person o1, Person o2) {
                int num = o1.getAge() - o2.getAge();
                return Integer.compare(num,0);
            }
        });

        
        treeMap.put(new Person(3), "person1");
        treeMap.put(new Person(18), "person2");
        treeMap.put(new Person(35), "person3");
        treeMap.put(new Person(16), "person4");
        treeMap.entrySet().stream().forEach(personStringEntry -> {
            System.out.println(personStringEntry.getValue());
        });

        System.out.println("测试搜索功能（找年龄大于16的人）: ");

        treeMap.entrySet().stream().filter(e -> e.getKey().getAge()>16).forEach(personStringEntry -> {
            System.out.println(personStringEntry.getValue());
        });


    }
}

 
 相比于HashMap来说 TreeMap 主要多了对集合中的元素根据键排序的能力以及对集合内元素的搜索的能力。 
 4.4 HashSet如何检查重复 
 当把对象加入HashSet时，HashSet 会先计算对象的hashcode值来判断对象加入的位置，同时也会与其他加入的对象的 hashcode 值作比较，如果没有相符的 hashcode，HashSet 会假设对象没有重复出现。但是如果发现有相同 hashcode 值的对象，这时会调用equals()方法来检查 hashcode 相等的对象是否真的相同。如果两者相同，HashSet 就不会让加入操作成功。 
 hashCode()与 equals()的相关规定： 
  
  如果两个对象相等，则 hashcode 一定也是相同的 
  两个对象相等,对两个 equals 方法返回 true 
  两个对象有相同的 hashcode 值，它们也不一定是相等的 
  综上，equals 方法被覆盖过，则 hashCode 方法也必须被覆盖 
  hashCode()的默认行为是对堆上的对象产生独特值。如果没有重写 hashCode()，则该 class 的两个对象无论如何都不会相等（即使这两个对象指向相同的数据）。 
  
 ==与 equals 的区别 
 对于基本类型来说，== 比较的是值是否相等； 
 对于引用类型来说，== 比较的是两个引用是否指向同一个对象地址（两者在内存中存放的地址（堆内存地址）是否指向同一个地方）； 
 对于引用类型（包括包装类型）来说，equals 如果没有被重写，对比它们的地址是否相等；如果 equals()方法被重写（例如 String），则比较的是地址里的内容。 
 4.5 HashMap的底层实现 
 4.5.1 JDK1.8之前 
 JDK1.8 之前 HashMap 底层是 数组和链表 结合在一起使用也就是 链表散列。HashMap 通过 key 的 hashCode 经过扰动函数处理过后得到 hash 值，然后通过 (n - 1) & hash 判断当前元素存放的位置（这里的 n 指的是数组的长度），如果当前位置存在元素的话，就判断该元素与要存入的元素的 hash 值以及 key 是否相同，如果相同的话，直接覆盖，不相同就通过拉链法解决冲突。 
 所谓扰动函数指的就是 HashMap 的 hash 方法。使用 hash 方法也就是扰动函数是为了防止一些实现比较差的 hashCode() 方法 换句话说使用扰动函数之后可以减少碰撞。 
 JDK 1.8 HashMap 的 hash 方法源码: 
     static final int hash(Object key) {
      int h;
      // key.hashCode()：返回散列值也就是hashcode
      // ^ ：按位异或
      // >>>:无符号右移，忽略符号位，空位都以0补齐
      return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
  }
 
 JDK1.7 的 HashMap 的 hash 方法源码 
 static int hash(int h) {
    // This function ensures that hashCodes that differ only by
    // constant multiples at each bit position have a bounded
    // number of collisions (approximately 8 at default load factor).

    h ^= (h >>> 20) ^ (h >>> 12);
    return h ^ (h >>> 7) ^ (h >>> 4);
}
 
 相比于 JDK1.8 的 hash 方法 ，JDK 1.7 的 hash 方法的性能会稍差一点点，因为毕竟扰动了 4 次。 
  
   
     
    
   
  
    拉链法解决冲突 
   
  
 4.5.2 JDK1.8之后 
 JDK1.8 之后在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为 8）（将链表转换成红黑树前会判断，如果当前数组的长度小于 64，那么会选择先进行数组扩容，而不是转换为红黑树）时，将链表转化为红黑树，以减少搜索时间。 
  
   
     
    
   
  
    JDK1.8 之后的 HashMap 
   
  
 TreeMap、TreeSet 以及 JDK1.8 之后的 HashMap 底层都用到了红黑树。红黑树就是为了解决二叉查找树的缺陷，因为二叉查找树在某些情况下会退化成一个线性结构。 
 4.6 HashMap的长度为什么是2的幂次方 
 为了能让 HashMap 存取高效，尽量较少碰撞，也就是要尽量把数据分配均匀。我们上面也讲到了过了，Hash 值的范围值-2147483648 到 2147483647，前后加起来大概 40 亿的映射空间，只要哈希函数映射得比较均匀松散，一般应用是很难出现碰撞的。但问题是一个 40 亿长度的数组，内存是放不下的。所以这个散列值是不能直接拿来用的。用之前还要先做对数组的长度取模运算，得到的余数才能用来要存放的位置也就是对应的数组下标。这个数组下标的计算方法是“ (n - 1) & hash”。（n 代表数组长度）。 
 这个算法的设计原理：
 为了让hash值的范围映射到数组的长度，首先可能会想到采用%取余的操作来实现。但是，重点来了：“取余(%)操作中如果除数是 2 的幂次则等价于与其除数减一的与(&)操作（也就是说 hash%length==hash&(length-1)的前提是 length 是 2 的 n 次方；）。” 并且 采用二进制位操作 &，相对于%能够提高运算效率，这就解释了 HashMap 的长度为什么是 2 的幂次方。 
  
   
     
    
   
  
    HashMap的底层实现以及长度 
   
  
 4.7 HashMap多线程导致死循环问题 
 主要原因在于并发下的 Rehash 会造成元素之间会形成一个循环链表。不过，jdk 1.8 后解决了这个问题，但是还是不建议在多线程下使用 HashMap,因为多线程下使用 HashMap 还是会存在其他问题比如数据丢失。并发环境下推荐使用 ConcurrentHashMap 。 
 4.8 HashMap常见的遍历方式 
  
   
     
    
   
  
    HashMap常见的遍历方式 
   
  
 4.9 ConcurrentHashMap和Hashtable的区别 
 ConcurrentHashMap 和 Hashtable 的区别主要体现在实现线程安全的方式上不同。 
  
   底层数据结构： JDK1.7 的 ConcurrentHashMap 底层采用 分段的数组+链表 实现，JDK1.8 采用的数据结构跟 HashMap1.8 的结构一样，数组+链表/红黑二叉树。Hashtable 和 JDK1.8 之前的 HashMap 的底层数据结构类似都是采用 数组+链表 的形式，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突而存在的； 
   实现线程安全的方式： ① 在 JDK1.7 的时候，ConcurrentHashMap（分段锁） 对整个桶数组进行了分割分段(Segment)，每一把锁只锁容器其中一部分数据，多线程访问容器里不同数据段的数据，就不会存在锁竞争，提高并发访问率。 到了 JDK1.8 的时候已经摒弃了 Segment 的概念，而是直接用 Node 数组+链表+红黑树的数据结构来实现，并发控制使用 synchronized 和 CAS 来操作。（JDK1.6 以后 对 synchronized 锁做了很多优化） 整个看起来就像是优化过且线程安全的 HashMap，虽然在 JDK1.8 中还能看到 Segment 的数据结构，但是已经简化了属性，只是为了兼容旧版本；② Hashtable(同一把锁) :使用 synchronized 来保证线程安全，效率非常低下。当一个线程访问同步方法时，其他线程也访问同步方法，可能会进入阻塞或轮询状态，如使用 put 添加元素，另一个线程不能使用 put 添加元素，也不能使用 get，竞争会越来越激烈效率越低。 
  
 两者的对比图: 
 HashTable: 
  
   
     
    
   
  
    HashTable全表锁 
   
  
 JDK1.7 的 ConcurrentHashMap： 
  
   
     
    
   
  
    ConcurrentHashMap分段锁 
   
  
 JDK1.8 的 ConcurrentHashMap： 
  
   
     
    
   
  
    java8 concurrenthashmap 
   
  
 JDK1.8 的 ConcurrentHashMap 不在是 Segment 数组 + HashEntry 数组 + 链表，而是 Node 数组 + 链表 / 红黑树。不过，Node 只能用于链表的情况，红黑树的情况需要使用 TreeNode。当冲突链表达到一定长度时，链表会转换成红黑树。 
 4.10 ConcurrentHashMap线程安全的具体实现方式 
 4.10.1 jdk1.7 
 ConcurrentHashMap 是由 Segment 数组结构和 HashEntry 数组结构组成。 
 Segment 实现了 ReentrantLock,所以 Segment 是一种可重入锁，扮演锁的角色。HashEntry 用于存储键值对数据。 
 一个 ConcurrentHashMap 里包含一个 Segment 数组。Segment 的结构和 HashMap 类似，是一种数组和链表结构，一个 Segment 包含一个 HashEntry 数组，每个 HashEntry 是一个链表结构的元素，每个 Segment 守护着一个 HashEntry 数组里的元素，当对 HashEntry 数组的数据进行修改时，必须首先获得对应的 Segment 的锁。 
 4.10.2 jdk1.8 
 ConcurrentHashMap 取消了 Segment 分段锁，采用 CAS 和 synchronized 来保证并发安全。数据结构跟 HashMap1.8 的结构类似，数组+链表/红黑二叉树。Java 8 在链表长度超过一定阈值（8）时将链表（寻址时间复杂度为 O(N)）转换为红黑树（寻址时间复杂度为 O(log(N))） 
 synchronized 只锁定当前链表或红黑二叉树的首节点，这样只要 hash 不冲突，就不会产生并发，效率又提升 N 倍。 
 5. Collections工具类 
 Collections工具类常用方法: 
  
  排序 
  查找，替换操作 
  同步控制 
  
 5.1 排序操作 
 void reverse(List list)//反转
void shuffle(List list)//随机排序
void sort(List list)//按自然排序的升序排序
void sort(List list, Comparator c)//定制排序，由Comparator控制排序逻辑
void swap(List list, int i , int j)//交换两个索引位置的元素
void rotate(List list, int distance)//旋转。当distance为正数时，将list后distance个元素整体移到前面。当distance为负数时，将 list的前distance个元素整体移到后面
 
 5.2 查找，替换操作 
 int binarySearch(List list, Object key)//对List进行二分查找，返回索引，注意List必须是有序的
int max(Collection coll)//根据元素的自然顺序，返回最大的元素。 类比int min(Collection coll)
int max(Collection coll, Comparator c)//根据定制排序，返回最大元素，排序规则由Comparatator类控制。类比int min(Collection coll, Comparator c)
void fill(List list, Object obj)//用指定的元素代替指定list中的所有元素。
int frequency(Collection c, Object o)//统计元素出现次数
int indexOfSubList(List list, List target)//统计target在list中第一次出现的索引，找不到则返回-1，类比int lastIndexOfSubList(List source, list target).
boolean replaceAll(List list, Object oldVal, Object newVal)// 用新元素替换旧元素
 
 5.3 同步控制 
 Collections 提供了多个synchronizedXxx()方法·，该方法可以将指定集合包装成线程同步的集合，从而解决多线程并发访问集合时的线程安全问题。 
 我们知道 HashSet，TreeSet，ArrayList,LinkedList,HashMap,TreeMap 都是线程不安全的。Collections 提供了多个静态方法可以把他们包装成线程同步的集合。 
 最好不要用下面这些方法，效率非常低，需要线程安全的集合类型时请考虑使用 JUC 包下的并发集合。 
 方法如下: 
 synchronizedCollection(Collection  c) //返回指定 collection 支持的同步（线程安全的）collection。
synchronizedList(List list)//返回指定列表支持的同步（线程安全的）List。
synchronizedMap(Map m) //返回由指定映射支持的同步（线程安全的）Map。
synchronizedSet(Set s) //返回指定 set 支持的同步（线程安全的）set。
 
 6. 其他重要问题 
 6.1 快速失败(fail-fast) 
 快速失败(fail-fast) 是 Java 集合的一种错误检测机制。在使用迭代器对集合进行遍历的时候，我们在多线程下操作非安全失败(fail-safe)的集合类可能就会触发 fail-fast 机制，导致抛出 ConcurrentModificationException 异常。 另外，在单线程下，如果在遍历过程中对集合对象的内容进行了修改的话也会触发 fail-fast 机制。 
 举个例子：多线程下，如果线程 1 正在对集合进行遍历，此时线程 2 对集合进行修改（增加、删除、修改），或者线程 1 在遍历过程中对集合进行修改，都会导致线程 1 抛出 ConcurrentModificationException 异常。 
 原因：
 每当迭代器使用 hashNext()/next()遍历下一个元素之前，都会检测 modCount 变量是否为 expectedModCount 值，是的话就返回遍历；否则抛出异常，终止遍历。 
 如果我们在集合被遍历期间对其进行修改的话，就会改变 modCount 的值，进而导致 modCount != expectedModCount ，进而抛出 ConcurrentModificationException 异常。 
 通过 Iterator 的方法修改集合的话会修改到 expectedModCount 的值，所以不会抛出异常。 
 6.2 安全失败（fail-safe） 
 采用安全失败机制的集合容器，在遍历时不是直接在集合内容上访问的，而是先复制原有集合内容，在拷贝的集合上进行遍历。所以，在遍历过程中对原集合所作的修改并不能被迭代器检测到，故不会抛 ConcurrentModificationException 异常。 
  
   
     
    
   
  
    fail-fast & fail safe 
   
  
 6.3 Arrays.asList()避坑指南 
 6.3.1 简介 
 Arrays.asList()会被用来将数组转换成List集合 
 String[] myArray = { "Apple", "Banana", "Orange" }；
List myList = Arrays.asList(myArray);
//上面两个语句等价于下面一条语句
List myList = Arrays.asList("Apple","Banana", "Orange");
 
 JDK源码对这个方法的说明: 
 /**
 *返回由指定数组支持的固定大小的列表。此方法作为基于数组和基于集合的API之间的桥梁，与           Collection.toArray()结合使用。返回的List是可序列化并实现RandomAccess接口。
 */
public static  List asList(T... a) {
    return new ArrayList<>(a);
}
 
 6.3.2 Alibaba开发手册对其的描述 
 Arrays.asList()将数组转换为集合后,底层其实还是数组. 
  
   
     
    
   
  
    《阿里巴巴 Java 开发手册》对于这个方法的描述 
   
  
 6.3.3 使用时的注意事项总结 
  
  传递的数组必须是对象数组，而不是基本类型。 
  
 int[] myArray = { 1, 2, 3 };
List myList = Arrays.asList(myArray);
System.out.println(myList.size());//1
System.out.println(myList.get(0));//数组地址值
System.out.println(myList.get(1));//报错：ArrayIndexOutOfBoundsException
int [] array=(int[]) myList.get(0);
System.out.println(array[0]);//1
 
 当传入一个原生数据类型数组时，Arrays.asList() 的真正得到的参数就不是数组中的元素，而是数组对象本身！此时 List 的唯一元素就是这个数组。 
  
   使用集合的修改方法:add()、remove()、clear()会抛出异常。
 Arrays.asList() 方法返回的并不是 java.util.ArrayList ，而是 java.util.Arrays 的一个内部类,这个内部类并没有实现集合的修改方法或者说并没有重写这些方法。 
  
 List myList = Arrays.asList(1, 2, 3);
System.out.println(myList.getClass());//class java.util.Arrays$ArrayList
 
 Reference: https://github.com/Snailclimb/JavaGuide/blob/master/docs/java/collection/Java%E9%9B%86%E5%90%88%E6%A1%86%E6%9E%B6%E5%B8%B8%E8%A7%81%E9%9D%A2%E8%AF%95%E9%A2%98.md