卑微小吴励志写博客第2天

卑微小吴坚持博客第二天，今天想写写关于集合的一些知识，集合在java面试中是必问的一块内容。
话不多说先上图， Collection和Map的继承体系

1、Collection和Map的继承体系

2、ArrayList和LinkList的区别

ArrayList（数组结构）：
优点：get和set调用花费常数时间，也就是查询的速度快；
缺点：新项的插入和现有项的删除代价昂贵，也就是添加删除的速度慢
LinkedList（链表结构）：
优点：新项的插入和和现有项的删除开销很小，即添加和删除的速度快
缺点：对get和set的调用花费昂贵，不适合做查询

2.1 是否保证线程安全

ArrayList 和 LinkedList 都是不同步的，也就是不保证线程安全

2.2 底层数据结构

Arraylist 底层使用的是Object数组；LinkedList 底层使用的是双向循环链表数据结构

2.3 插入和删除是否受元素位置的影响

ArrayList 采用数组存储，所以插入和删除元素的时间复杂度受元素位置的影响。比如：执行add(E e)方法的时候， ArrayList 会默认在将指定的元素追加到此列表的末尾，这种情况时间复杂度就是O(1)。但是如果要在指定位置 i 插入和删除元素的话（add(int index, E element)）时间复杂度就为 O(n-i)。因为在进行上述操作的时候集合中第 i 和第 i 个元素之后的(n-i)个元素都要执行向后位/向前移一位的操作。
LinkedList 采用链表存储，所以插入，删除元素时间复杂度不受元素位置的影响，都是近似 O（1）而数组为近似 O（n）。

2.4 是否支持快速随机访问

LinkedList 不支持高效的随机元素访问，而ArrayList 实现了RandmoAccess 接口，所以有随机访问功能。快速随机访问就是通过元素的序号快速获取元素对象(对应于 get(int index) 方法)。

2.5 内存空间占用

ArrayList的空间浪费主要体现在在list列表的结尾会预留一定的容量空间，而LinkedList的空间花费则体现在它的每一个元素都需要消耗比ArrayList更多的空间（因为要存放直接后继和直接前驱以及数据）。

3、HashMap底层原理

HashMap实际上是一个“链表散列”的数据结构，即数组和链表的结合体。这是jdk8之前的实现方式，但是在JDK8后对HashMap进行了底层优化,改为了由数组+链表+红黑树实现,主要的目的是提高查找效率。

HashMap的主结构类似于一个数组,添加值时通过key确定储存位置。
每个位置是一个Entry的数据结构,该结构可组成链表.当发生冲突时,相同hash值的键值对会组成链表。这种数组+链表的组合形式大部分情况下都能有不错的性能效果,Java6、7就是这样设计的。
然而,在极端情况下,一组（比如经过精心设计的）键值对都发生了冲突，这时的哈希结构就会退化成一个链表，使HashMap性能急剧下降。
所以在Java8中,HashMap的结构实现变为数组+链表+红黑树。

可以看出,HashMap底层就是一个数组结构。
数组中的每一项又是一个链表，当新建一个HashMap时,就会初始化一个数组.
简单地说，HashMap 在底层将 key-value 当成一个整体进行处理，这个整体就是一个 Entry 对象。HashMap 底层采用一个 Entry[] 数组来保存所有的 key-value 对，当需要存储一个 Entry 对象时，会根据hash算法来决定其在数组中的存储位置，在根据equals方法决定其在该数组位置上的链表中的存储位置；当需要取出一个Entry时，也会根据hash算法找到其在数组中的存储位置，再根据equals方法从该位置上的链表中取出该Entry。

4、HashMap的put()和get()原理

4.1 java7及以前：

get()方法
首先判断输入的key是否为空,如果为空,从hashmap数组下标为0的位置获取值返回。如果不为空,根据key的值,从hashmap数组中获取对应的entry对象,判断这个对象是否为空,为空返回null,不为空返回对应的value值, 获取value的方法中key为空和不为空时的方法里都先判断数组中的元素是否为0 ,如果不为0,才继续查找
put()方法
调用put方法的时候首先判断hashmap数组是否为空数组,
如果为空,进行初始化,判断key的值是否是null,如果是null,把对应的value值存进数组中下标为0的位置,计算key的hash值,并计算出下标,遍历下标对应的链表,匹配hash值和key的值,如果存在,则覆盖,返回旧值，如果不存在,新添加一个,返回null
最后判断数组大小，是否扩容

4.2 java8

get()方法
对输入的key的值计算hash值,
首先判断hashmap中的数组是否为空和数组的长度是否为0,如果为空和为0,则直接放回null
如果不为空和0,计算key对应的数组下标,判断对应位置上的第一个node是否满足条件,如果满足条件,直接返回
如果不满足条件,判断当前node是否是最后一个,如果是,说明不存在key,则返回null
如果不是最后一个,判断是否是红黑树,如果是红黑树,则使用红黑树的方式获取对应的key,
如果不是红黑树,遍历链表是否有满足条件的,如果有,直接放回,否则返回null
put()方法
首先计算key的hash值,获取hashmap中的数组和数组长度,如果数组为空,初始化计算key的下标
数组对应下标的位置是否为空,如果为空,则先添加一个,放在这个下标位置,然后判断数组内元素是否大于阈值,如果大于,则进行扩容
如果数组对应下标不为空,则先获取对应链表的第一个值,判断hash和key是否相同,如果相同,新value替换旧value,返回旧value
如果第一个值key不相同,判断当前链表是否是红黑树,如果是红黑树,调用红黑树链表put的方法。如果也不是红黑树,遍历链表,判断当前node是否是最后一个,如果是,说明链表中没有新添加的key,则在最后面新添加一个,然后判断是否超过阈值(8-1),如果超过,则转换成红黑树。
如果不是最后一个,说明在中间已经存在key了, 把新值赋值给旧值,并返回旧值,判断是否需要扩容.。

给个例子：

hashmap.put(“lisi”,22); 添加键值对时
根据键的哈希码，经过哈希函数计算得出hash值
根据hash值计算数组下标 i=4
访问数组元素table[i]，如果该元素为null，就创建一个节点保存到table[i]中
hashmap.put(“chen”,20); 添加键值对时
根据键的哈希码，经过哈希函数计算得出hash值
根据hash值计算数组下标 i=0
访问数组元素table[i]，如果该元素为null，就创建一个节点保存到table[i]中
hashmap.put(“wu”,36); 添加键值对时
根据键的哈希码，经过哈希函数计算得出hash值
根据hash值计算数组下标 i=0
访问数组元素table[i]，如果该元素不为null，就遍历table[i]链表中所有的节点，如果所有节点的key与当前key不同，就创建一个节插入到链表的尾部
hashmap.put(“chen”,22); 添加键值对时
根据键的哈希码，经过哈希函数计算得出hash值
根据hash值计算数组下标 i=0
访问数组元素table[i]，如果该元素不为null，就遍历table[i]链表中所有的节点，如果所有节点的key与当前键equals()相等，就使用新的value值替换节点中的值

HashMap 的resize过程是什么样的（扩容）？
HashMap在put的时候会先检查当前数组的length,如果插入新的值的时候使得length > 0.75f * size（f 为加载因子，可以在创建hashMap时指定）的话，会将数组进行扩容为当前容量的2倍。扩容之后必定要将原有hashMap 中的值拷贝到新容量的hashMap 里面，HashMap 默认的容量为16，加载因子为0.75，也就是说当HashMap 中Entry的个数超过 16 * 0.75 = 12时, 会将容量扩充为 16 * 2 = 32，然后重新计算元素在数组中的位置，这是一个非常耗时的操作，所以我们在使用HashMap的时候如果能预先知道Map中元素的大小，预设其大小能够提升其性能。

         //HashMap数组扩容void resize ( int newCapacity){Entry[] oldTable = table;int oldCapacity = oldTable.length;//如果当前的数组长度已经达到最大值，则不在进行调整if (oldCapacity == MAXIMUM_CAPACITY) {threshold = Integer.MAX_VALUE;return;}//根据传入参数的长度定义新的数组Entry[] newTable = new Entry[newCapacity];//按照新的规则，将旧数组中的元素转移到新数组中transfer(newTable);table = newTable;//更新临界值threshold = (int) (newCapacity * loadFactor);}//旧数组中元素往新数组中迁移void transfer (Entry[]newTable){//旧数组Entry[] src = table;//新数组长度int newCapacity = newTable.length;//遍历旧数组for (int j = 0; j < src.length; j++) {Entry e = src[j];if (e != null) {src[j] = null;do {Entry next = e.next;int i = indexFor(e.hash, newCapacity);//放在新数组中的index位置e.next = newTable[i];//实现链表结构，新加入的放在链头，之前的的数据放在链尾newTable[i] = e;e = next;} while (e != null);}}}}

这是1.7中的代码，1.8中引入了红黑树的概念，代码会相对复杂一些。

5、HashMap在扩容的时候为什么容量都是原来的2倍，即容量为2^n

HashMap 在计算数组中key的位置时，使用的算法为：

/* * Returns index for hash code h. */
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); }

即对key的hashcode 与当前数组容量 -1 进行与操作我们假设有一个容量为分别为15 和 16 的hashMap ，有两个key的hashcode 分别为4和5，进行indexFor操作之后：

H & (length -1) hash & table.length-1 4 & (15 - 1) 0100 & 1110 = 0100 5 & （ 15 -1 ） 0101 & 1110 = 0100
4 & (16 - 1) 0100 & 1111 = 0100 5 & （ 16 -1 ） 0101 & 1111 = 0101

我们能够看到在容量为16时进行indexFor操作之后获得相同结果的几率要比容量为15时的几率要小，这样能够减少出现hash冲突的几率，从而提高查询效率。2 ^ n是一个非常神奇的数字。

6、ArrayList、HashSet、HashMap 是线程安全的吗？如果不是我想要线程安全的集合怎么办？

每个方法都没有加锁，显然都是线程不安全的。话又说过来,如果他们安全了也就没第二问了。在集合中 Vector 和 HashTable 倒是线程安全的。打开源码会发现其实就是把各自核心方法添加上了synchronized 关键字。
Collections 工具类提供了相关的 API，可以让上面那 3 个不安全的集合变为安全的。

1. //        Collections.synchronizedCollection(c)
2. //       Collections.synchronizedList(list)
3. //       Collections.synchronizedMap(m)
4. //       Collections.synchronizedSet(s)

上面几个函数都有对应的返回值类型，传入什么类型返回什么类型。打开源码其实实现原理非常简单，就是将集合的核心方法添加上了 synchronized 关键字。
常用的三个结合都是现成不安全的，只有vector和hashtable是线程安全的。线程安全就在方法上加上了synchronize。可以用Collections中的方法添加上synchronized关键字。

7、ConcurrentHashMap 的工作原理及代码实现

HashTable里使用的是synchronized关键字，这其实是对对象加锁，锁住的都是对象整体，当Hashtable的大小增加到一定的时候，性能会急剧下降，因为迭代时需要被锁定很长的时间。
ConcurrentHashMap算是对上述问题的优化，其构造函数如下，默认传入的是16，0.75，16。

ConcurrentHashMap引入了分割(Segment)，上面代码中的最后一行其实就可以理解为把一个大的Map拆分成N个小的HashTable。
在put方法中，会根据hash(paramK.hashCode())来决定具体存放进哪个Segment，如果查看Segment的put操作，我们会发现内部使用的同步机制是基于lock操作的，这样就可以对Map的一部分（Segment）进行上锁，这样影响的只是将要放入同一个Segment的元素的put操作，保证同步的时候，锁住的不是整个Map（HashTable就是这么做的）。相对于HashTable提高了多线程环境下的性能，因此HashTable已经被淘汰了。
ConcurrentHashMap其实就是对hashtable优化了，是现成安全的。它将一个map拆分为N个小的hashtable，不是只会锁住一个小块，不是全部都锁住，提高了性能。简单说就是线程安全，效率优化了。