集合中list，set，map底层实现，扩容机制以及优缺点讲解
目录
1.集合分类
2.具体讲解
2.1 List集合
2.1.1 arrayList详细讲解
2.1.2 LinkedList详细讲解
2.1.3 vector详细讲解
2.1.4 stack详细讲解
2.2 Set集合
2.2.1 HashSet详细讲解:
2.2.2 TreeSet详细讲解:
2.3 Map集合
2.3.1 HashMap详细讲解
2.3.2 TreeMap详细讲解
2.3.3 HashTable 讲解
2.3.4 ConCurrentHashMap 讲解
1.集合分类：
集合：collection（最基本的集合接口）
集合可以分为单值和双值
单值
list:arrayList,LinkedList,vector,stack
set:HashSet,TreeSet
(set集合就是map集合的一部分: key)
双值的
map:Hashmap, treemap, hashtable
2.具体讲解
2.1 List集合
List集合： 有序（有元素的插入顺序），可重复的集合
2.1.1 arrayList详细讲解:
底层实现： 数组
如何实现的：
创建数组的时候 长度是0
第一次添加元素的时候 初始化数组的长度10
数组的扩容：
数组的元素个数超过10个的时候 开始 扩容的工作
grow（）：
//1.数组扩容的时候 每次1.5倍进行扩容的
//2.进行数组的复制的工作
int newCapacity = oldCapacity + (oldCapacity >> 1);
= 1.5*oldCapacity
数组的上限：
arrayList数组的上限：Integer_max(约21亿)-8
15亿------15*1.5=====22.亿
数组的上限 integer_maxvalue 21亿
arraylist的size的最大上限是integer_maxvalue
性能瓶颈：10亿左右
ArrayList的构造方法：
//构造方法中有参构造 无参构造
public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
this.elementData = EMPTY_ELEMENTDATA;
} else {
throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);
}
}
有参构造的使用场景：
如果使用无参构造，初始化数组的长度0
第一次添加元素的时候开始 长度10
以后的每次扩容 1.5倍进行扩容
1000
10 15 22 33 50 75 112 。。。。
数组扩容----数组的拷贝的过程 消耗资源的过程
使用有参构造 参数：代表的是我们数组初始化的长度
参数500---750----1000+
当arraylist中元素个数很多的时候 ,最好使用有参构造,减少底层数组的扩容的次数,提升性能
方法有：
add（E e）
remove(E e)
数组特点：
查询快 增删慢
因为数组是有索引的，通过下标直接访问
时间复杂度o(1)
2.1.2 LinkedList详细讲解:
底层实现： 线性链表
（1.5之前采用单向链表， 1.5之后采用双向链表）
链表：
线性链表：
单向链表：
只有一个方向的链表，上一个元素知道下一个元素，但是下一个元素不知道上一个元素的，访问的时候只能从一端开始
双向链表：
两个方向的链表，每一个元素，都知道自己的上一个元素和下一个元素是谁，可以从两个方向访问
环形链表：
首尾相连的链表
链表结构中的每一个元素 就叫做node 对象 Node
Node的结构：
private static class Node<E> {
E item;
Node<E> next;
Node<E> prev;
Node(Node<E> prev, E element, Node<E> next) {
this.item = element;
this.next = next;
this.prev = prev;
}
}
addFirst(E e)： 添加元素的时候 实际上是对Node的操作
扩容机制：
由于它的底层是用双向链表实现的，所以它对元素的增加、删除效率要比ArrayList好；
它是一个双向链表，没有初始化大小，也没有扩容的机制，就是一直在前面或者后面新增就好。
优点：
增删快 查询慢
查看底层代码可能会遇到transient关键字：
Java中transient关键字的作用:
简单地说，就是让某些被修饰的成员属性变量不被序列化，
这一看好像很好理解，就是不被序列化
2.1.3 vector详细讲解:
vector：线程同步数组 基本抛弃使用。
vector 和arrayList的区别
vector：线程安全的（（方法用了synchronized修饰）） 但是性能低
arrayList 线程不安全的 性能高
ArrayList:底层数据结构是数组，查询快，增删慢
LinkedList:底层数据结构是链表，查询慢，增删快
2.1.4 stack详细讲解:
stack：（相当于一个桶）
栈结构
先进后出的
2.2 Set集合
set集合：无序（没有插入顺序的）,不可重复的
set集合就是map集合的一部分（key部分）
2.2.1 HashSet详细讲解:
HashSet：HashMap中k-v中的k部分（可先查看底部map讲解）
底层结构：数组（初始容量16）+链表（单向的）+树（红黑树）
元素存储的时候 先对元素（key）取hash值
hash算法：就是生成一个唯一的散列的数
不存在一个绝对完美的hash算法可以做到 任意两个甚至多个key的hash值不同的
任何一个hash算法都会存在hash冲突的问题
hash冲突：
不同的key得到的hash值相同
Node[] tab; 数组 数组的初始化容量 16
Node p; 记录每一个元素的
int n, i; 记录数组的下标
数组扩容的节点：
数组进行扩容的阀值 ，数组的容量达到整个数组的0.75就会进行数组的扩容的操作 :每次扩容 扩大2倍 :
16*0.75=12
static final float DEFAULT_LOAD_FACTOR = 0.75f;
newCap = oldCap << 1 每次扩容 扩大2倍 32
hashset如何去重的：
hash值不同的两个元素 一定不是同一个元素
先判断hash值,后比较equals方法（地址）
2.2.2 TreeSet详细讲解:
TreeSet : TreeMap中k-v中的k部分（可先查看底部map讲解）
特点：有序（元素值是排序的） 不可重复的
底层结构：红黑树
排序方式：自然排序
如果是数值：值的大小 默认升序的
如果是字符串：字典顺序进行排序的
例如：
字符串数组：12 11 1 2 3 4 34 23 26
排序结果：1,11,12,2,23,26,3,34,4
要求：我们的set集合中存放的元素是有排序能力的（如果是自定义对象，需要实现compare比较器）
2.3 Map集合
以kv键值对的形式对元素进行存储
2.3.1 HashMap详细讲解:
底层结构：数组(16)+链表（单向链表）+树（红黑树）
默认的初始化容量（底层数组）1<<4 – 16
链表结构转换为树结构的最大阀值：8（1.8之后的）
树结构转换为链表结构的阀值：6
默认的最大容量：1<<30 2的30次方
加载因子：0.75 （存储到数组0.75后就会2倍扩容）
数组扩容的节点：
数组进行扩容的阀值 数组的容量达到整个数组的0.75就会进行数组的扩容的操作(每次扩容 ,扩大2倍) 16*0.75=12
static final float DEFAULT_LOAD_FACTOR = 0.75f;
newCap = oldCap << 1 // 每次扩容 扩大2倍 32
链表和树的转换：
因为是一个单向链表（8）所以查询的时候性能低，在1.8之后做了一个优化，当链表的深度超过8的时候就将链表转换为树结构
链表结构转换为树结构的最大阀值：8（1.8之后的）
树结构转换为链表结构的阀值：6
put添加的实现：
元素存储的时候 先对元素（key）取hash值。
对元素取hash值就会造成hash冲突 （hash碰撞）
hash算法：就是生成一个唯一的散列的数
不存在一个绝对完美的hash算法可以做到 任意两个甚至多个key的hash值不同的
任何一个hash算法都会存在hash冲突的问题
hash冲突：不同的key得到的hash值相同
Node<K,V>[] tab; 数组 数组的初始化容量 16
Node<K,V> p; 记录每一个元素的
int n, i; 记录数组的下标
数组扩容：
数组进行扩容的阀值 数组的容量达到整个数组的0.75就会进行数组的扩容的操作(每次扩容 ,扩大2倍) 16*0.75=12
static final float DEFAULT_LOAD_FACTOR = 0.75f;
newCap = oldCap << 1 // 每次扩容 扩大2倍 32
为什么要扩容2倍数？
原来数组下标中链表中存储了元素，原来模余16,现在如果两倍 就是模余32
可以把原来链表中的元素分担到新扩容的数组下标下
为什么出现了树转变为链表的阀值：
因为数组扩容，所以出现了树转链表结构的阀值：因为深度减少了
hashset如何去重的？
hash值不同的两个元素 一定不是同一个元素
先判断hash值 ，再用equals方法（地址）判断：
如果equals相同，值不进行存储,因为是set
2.3.2 TreeMap详细讲解:
与 2.2.2 TreeSet详细讲解 大致相同，不再讲解
2.3.3 HashTable 讲解:
hashTable 和hashMap比较:
hashtable：线程安全（就是加锁方法用了synchronized修饰），性能低，整个数组的线程加锁，所以出现了concurrenthashMap
不允许有null的键和值
hashmap 线程非安全的 性能高
允许有null的键和值
2.3.4 ConCurrentHashMap 讲解:
concurrenthashMap: 既可以做到线程安全 又可以保证性能
采用：分段线程锁+读写锁
从数据的操作，锁的分类：
读锁：共享锁 所有的线程可以共用这把锁
写锁：排他锁 同一时间只能允许一个线程操作
会对hashMAP底层的数组进行分段加锁， 通过具体的操作，决定加的是读锁还是写锁