常见集合框架：HashMap、HashTable、ConcurrentHashMap、ArrayList、Vocter、LinkedList、HashSet、TreeSet之间区别

集合框架

​ 这里进行快速的常用常见(面试)，的集合框架快速的介绍和了解，如下是集合框架的关系图，和一张简单的关系图，用于快速的了解集合框架的结构。本文并不是详细的介绍，知识进行常被问到的简单介绍

Iteraor接口 （迭代器）

(迭代器接口)用于遍历集合中元素的接口，主要包含三种方法：

boolean hasNext()
E next()
void remove()

也就是说如果实现Iterator接口，那么在遍历集合中元素的时候，只能往后遍历，被遍历过的元素不会再遍历到，通常无序集合实现的都是这个接口，比如HashSet，HashMap；
而实现了ListIterator接口的集合，可以双向遍历，既可以通过next()访问下一个元素，又可以通过previous()访问前一个元素，比如List。

Iterator和Iterable的区别：
1). Iterator是迭代器接口，而Iterable是为了只要实现该接口就可以使用foreach进行迭代。

2). Iterable中封装了Iterator接口，只要实现了Iterable接口的类，就可以使用Iterator迭代器了。

3). 集合Collection、List、Set都是Iterable的实现类，所以他们及其他们的子类都可以使用foreach进行迭代。

4). Iterator中核心的方法next()、hasnext()、remove()都是依赖当前位置，如果这些集合直接实现Iterator，则必须包括当前迭代位置的指针。当集合在方法间进行传递的时候，由于当前位置不可知，所以next()之后的值，也不可知。而实现Iterable则不然，每次调用都返回一个从头开始的迭代器，各个迭代器之间互不影响。

一、HashMap，Hashtable，和ConcurrentHashMap

ConcurrentHashMap

JDK1.7 中的 ConcurrentHashMap 是由 Segment (内部类)数组结构和 HashEntry(内部类) 数组结构组成 每个Segment都可以进行一个锁的添加，是分段锁 Segment是ConcurrentHashMap的内部类继承了ReentrantLock(重用锁)所以每个Seagment可以进行上锁 。ConcurrentHashMap继承了AbstractMap<K,V> 实现了ConcurrentMap<K,V>

Segment 是 ConcurrentHashMap 的一个内部类，主要的组成如下：

Segment 继承了 ReentrantLock，所以 Segment 是一种可重入锁，扮演锁的角色。Segment 默认为 16，也就是并发度为 16。

存放元素的 HashEntry，也是一个静态内部类，主要的组成如下

再来看下JDK1.8

在数据结构上， JDK1.8 中的ConcurrentHashMap 选择了与 HashMap 相同的Node数组+链表+红黑树结构；抛弃了原有的 Segment 分段锁，采用CAS + synchronized实现更加细粒度的锁。

将锁的级别控制在了更细粒度的哈希桶数组元素级别，也就是说只需要锁住这个链表头节点（红黑树的根节点），就不会影响其他的哈希桶数组元素的读写，大大提高了并发度。

JDK1.8 中为什么使用内置锁 synchronized替换 可重入锁 ReentrantLock？★★★★★

在 JDK1.6 中，对 synchronized 锁的实现引入了大量的优化，并且 synchronized 有多种锁状态，会从无锁 -> 偏向锁 -> 轻量级锁 -> 重量级锁一步步转换。
减少内存开销 。假设使用可重入锁来获得同步支持，那么每个节点都需要通过继承 AQS 来获得同步支持。但并不是每个节点都需要获得同步支持的，只有链表的头节点（红黑树的根节点）需要同步，这无疑带来了巨大内存浪费。

HashMap

HashMap jdk1.7 数组加链表 jdk1.8 数据加链表加红黑树小于8链表 大于就是红黑数

存储结构：哈希表（数组+链表+红黑树）
使用key可使hashcode和equals作为重复

原码分析总结：

1. HashMap刚创建时，table是null，节省空间，当添加第一个元素时，table容量调整为16
2. 当元素个数大于阈值（16*0.75 = 12）时，会进行扩容，扩容后的大小为原来的两倍，目的是减少调整元素的个数
3. jdk1.8 当每个链表长度 >8 ，并且数组元素个数 ≥64时，会调整成红黑树，目的是提高效率
4. jdk1.8 当链表长度 <6 时 调整成链表
5. jdk1.8 以前，链表时头插入，之后为尾插入

线程安全，运行效率慢；不允许null作为key或是value
hashtable的子类，要求key和value都是string，通常用于配置文件的读取
实现了SortedMap接口（是map的子接口），可以对key自动排序
概念：集合工具类，定义了除了存取以外的集合常用方法
直接二分查找int i = Collections.binarySearch(list, x); 成功返回索引
其他方法 ： copy复制、reverse反转、shuffle打乱

一、hashmap进行put一个数值

1、判断数组是否为空，为空进行初始化;
2、不为空，计算 k 的 hash 值，通过(n - 1) & hash计算应当存放在数组中的下标 index;
3、查看 table[index] 是否存在数据，没有数据就构造一个Node节点存放在 table[index] 中；
4、存在数据，说明发生了hash冲突(存在二个节点key的hash值一样), 继续判断key是否相等，相等，5、用新的value替换原数据(onlyIfAbsent为false)；
6、如果不相等，判断当前节点类型是不是树型节点，如果是树型节点，创造树型节点插入红黑树中；(如果当前节点是树型节点证明当前已经是红黑树了)
7、如果不是树型节点，创建普通Node加入链表中；判断链表长度是否大于 8并且数组长度大于64， 大于的话链表转换为红黑树；
8、插入完成之后判断当前节点数是否大于阈值，如果大于开始扩容为原数组的二倍。

HashTable

实际就是一个加锁的hashMap 是通过往可能会发生多线程问题的方法数据上加深synchronized

二、ArrayList，Voctor，LinkedList

​ 首先聊聊List和Set的区别、Set具有和Conllection完全一样的接口 没有额外功能

​ 双方都继承Collection接口、List特点 元素有序可重复 set相反无序不重复

​ Set和List对比:Set：检索元素效率低下，删除和插入效率高，插入和删除不会引起元素位置改变。

ArrayLIst

​ 可以理解为数组集合、本质就是一个数组 不过它可变 有个扩容机制 一开始初始的容量为0 当有数据添加的时候就会变成10 当数据超过临界点的时候就会扩容1.5倍 内部有迭代器

​ 扩容为当前size 加 当前 size>>1 就是1.5倍当前size

Voctor

​ 与ArrayList类似、不过它加了synchronized 所有是线程安全的 但实际使用不多 内部有个枚举器可以进行迭代遍历

LinkedList

​ 它呢是个链表的List 双向链表 除了有迭代器(iterator)可以进行迭代 还有个更强的List迭代器、可以双向迭代 实际操作和普通迭代器差不多

三、HashSet和TreeSet

​ 和ArrayList不同 HashSet和TreeSet实现Set接口 是无序无下标不重复的集合

HashSet

存储结构：哈希表（数组+链表+红黑树）
存储过程（重复依据）
    根据hashCode计算保存的位置，如果位置为空，直接保存，若不为空，进行第二步
    再执行equals方法，如果equals为true，则认为是重复，否则形成链表
特点
    基于HashCode计算元素存放位置
        利用31这个质数，减少散列冲突
            31提高执行效率 31 * i = (i << 5) - i 转为移位操作
        当存入元素的哈希码相同时，会调用equals进行确认，如果结果为true，则拒绝后者存入

TreeSet

特点

• 基于排列顺序实现元素不重复
• 实现SortedSet接口，对集合元素自动排序
• 元素对象的类型必须实现Comparable接口，指定排序规则
• 通过CompareTo方法确定是否为重复元素

TreeSet它底层是一个红黑树

基于排序顺序实现元素不重复。

实现了SortedSet接口，对集合元素自动排序。

元素对象的类型必须实现Comparable接口 指定排序规则 或者用Comparator

//1、实现Comparable接口进行重写compareTo方法实现排序和去重 返回值为0代表重复
public class Person implements Comparable<Person> {
    @Override
    public int compareTo(Person o) {
        int n1 = this.name.compareTo(o.getName());
        int n2 = this.age - o.getAge();
        return n1 != 0 ? n1:n2;
    }
}

//2、集合用逸名内部类实现Comparator接口重写compare方法实现去重和排序
TreeSet<Person> treeSet = new TreeSet<>(new Comparator<Person>() {
    @Override
    public int compare(Person o1, Person o2) {
        int n1 = o1.getAge() - o2.getAge();
        int n2 = o1.getName().compareTo(o2.getName());
        return n2 != 0?n1:n2;
    }
});

通过CompareTo方法确定是否为重复元素