【JAVA】基础知识面试题梳理（三）

1、说一下集合的体系？

单列集合：

双列集合：

2、Collection 和 Collections的区别？

Collection：
各种集合的父接口，继承于它的接口主要有set 和list；
Conllecitons：
针对集合的工具类，提供一系列静态方法对各种集合的搜索，排序，线程安全化等操作。

3、List a=new ArrayList() 和 ArrayList a =new ArrayList()的区别？

List list = new ArrayList();这句创建了一个 ArrayList 的对象后把上溯到了 List。此时它是一个List对象了，有些ArrayList 有但是 List 没有的属性和方法，它就不能再用了。
ArrayList list=new ArrayList();创建一对象则保留了ArrayList 的所有属性。所以需要用到 ArrayList 独有的方法的时候不能用前者。
eg:

List list = new ArrayList();
ArrayList arrayList = new ArrayList();
list.trimToSize(); //错误，没有该方法。
arrayList.trimToSize(); //ArrayList里有该方法。

4、Enumeration和iterator接口的区别？

Enumeration接口作用与iterator接口相似，但只提供了遍历vector和HashTable类型集合元素的功能，不支持元素的移除操作。

Enumeration速度是iterator的2倍，同时占用更少的内存。但是，iterator远比enumeration安全，因为其他线程不能够修改正在被iterator遍历的集合里面的对象。同时，iterator允许调用者删除底层集合里面的元素。

5、ListIterator有什么特点，与iterator区别？

Iterator是ListIterator的父类接口
Iterator是单列集合（Collection）公共取出容器中元素的方式
ListIterator是List集合的特有取出元素方式
Iterator中具备的功能只有hashNext()，next()，remove()；
ListIterator中具备着对被遍历的元素进行增删查改的方法，可以对元素进行逆向遍历。

6、List和Set的区别？

List,Set都是继承自Collection接口。都是用来存储一组相同类型的元素的。
List特点：元素有放入顺序，元素可重复 。
有顺序，即先放入的元素排在前面。
Set特点：元素无放入顺序，元素不可重复。
无顺序，即先放入的元素不一定排在前面。不可重复，即相同元素在set中只会保留一份。所以，有些场景下，set可以用来去重。
Note：set在元素插入时是要有一定的方法来判断元素是否重复的。这个方法很重要，决定了set中可以保存哪些元素。

7、Set如何保证元素不重复？

在Java的Set体系中，根据实现方式不同主要分为两大类。HashSet和TreeSet。

1、TreeSet 是二叉树实现的,Treeset中的数据是自动排好序的，不允许放入null值
2、HashSet 是哈希表实现的,HashSet中的数据是无序的，可以放入null，但只能放入一个null，两者中的值都不能重复，就如数据库中唯一约束

在HashSet中，基本的操作都是有HashMap底层实现的，因为HashSet底层是用HashMap存储数据的。当向HashSet中添加元素的时候，首先计算元素的hashcode值，然后通过扰动计算和按位与的方式计算出这个元素的存储位置，如果这个位置位空，就将元素添加进去；如果不为空，则用equals方法比较元素是否相等，相等就不添加，否则找一个空位添加。

TreeSet的底层是TreeMap的keySet()，而TreeMap是基于红黑树实现的，红黑树是一种平衡二叉查找树，它能保证任何一个节点的左右子树的高度差不会超过较矮的那棵的一倍。

TreeMap是按key排序的，元素在插入TreeSet时compareTo()方法要被调用，所以TreeSet中的元素要实现Comparable接口。TreeSet作为一种Set，它不允许出现重复元素。TreeSet是用compareTo()来判断重复元素的。

8、HashSet实现原理？

1.基于HashMap实现的，默认构造函数是构建一个初始容量为16，负载因子为0.75 的HashMap。封装了一个 HashMap 对象来存储所有的集合元素，所有放入 HashSet 中的集合元素实际上由 HashMap 的 key 来保存，而 HashMap 的 value 则存储了一个 PRESENT，它是一个静态的 Object 对象。

2.当我们试图把某个类的对象当成 HashMap的 key，或试图将这个类的对象放入 HashSet 中保存时，重写该类的equals(Object obj)方法和 hashCode() 方法，而且这两个方法的返回值必须保持一致：当该类的两个的 hashCode() 返回值相同时，它们通过 equals() 方法比较也应该返回 true。
通常来说，所有参与计算 hashCode() 返回值的关键属性，都应该用于作为 equals() 比较的标准。

3.HashSet的其他操作都是基于HashMap的。

9、TreeMap和TreeSet在排序时如何比较元素？

TreeSet要求存放的对象所属的类必须是实现Comparable接口，该接口提供了比较元素的compareTo方法，当插入元素时会调该方法比较元素的大小.TreeMap要求存放的键值对映射的键必须实现Comparable接口，从而根据键对元素进行排序。

10、Collection工具类中的sort方法如何比较元素？

Collections工具类的sort方法有两种重载的形式，
第一种要求传入的待排序容器中存放的对象比较实现Comparable接口以实现元素的比较，
第二种不强制性的要求容器中的元素必须可比较但是要求第二个参数,参数是Comparator接口的子类型（需要重写compare方法实现元素的比较）相当一个临时定义的排序规则，其实就是通过接口注入比较元素大小的算法，也是对回调模式的应用。

11、HashMap和HashTable有什么区别？

HashMap允许键和值是null，而Hashtable不允许键或者值是null。

Hashtable是同步的，而HashMap不是。因此，HashMap更适合于单线程环境，而Hashtable适合于多线程环境。

HashMap提供了可供应用迭代的键的集合，因此，HashMap是快速失败的。另一方面，Hashtable提供了对键的列举(Enumeration)。

由于Hashtable继承自Dictionary类。而这个类已经基本上废弃了，所以一般认为Hashtable是一个遗留的类。

12、Java中HashMap的key值要是为类对象，则该类需要满足什么条件？HashMap的特性？HashMap的存储结构？

条件：
需要重写equals()和hashCode()方法。
特性：
1.HashMap存储键值对实现快速存取，允许为null。key值不可重复，若key值重复则覆盖
2.非同步，线程不安全
3.底层是hash表，不保证有序(比如插入的顺序)
存储结构：
1.7版本：数组+链表
1.8版本：数组+链表+红黑树

13、HashMap在JDK1.7和JDK1.8中有哪些不同？

14、HashMap扩容机制？

何时进行扩容？

HashMap使用的是懒加载，构造完HashMap对象后，只要不进行put 方法插入元素之前，HashMap并不会去初始化或者扩容table。
当首次调用put方法时，HashMap会发现table为空然后调用resize方法进行初始化，当添加完元素后，如果HashMap发现size（元素总数）大于threshold（阈值），则会调用resize方法进行扩容。

扩容过程：

若threshold（阈值）不为空，table的首次初始化大小为阈值，否则初始化为缺省值大小16
默认的负载因子大小为0.75，当一个map填满了75%的bucket时候（即达到了默认负载因子0.75），就会扩容，扩容后的table大小变为原来的两倍（扩容后自动计算每个键值对位置，且长度必须为16或者2的整数次幂）

若不是16或者2的幂次，位运算的结果不够均匀分布，显然不符合Hash算法均匀分布的原则。

反观长度16或者其他2的幂，Length-1的值是所有二进制位全为1，这种情况下，index的结果等同于HashCode后几位的值。只要输入的HashCode本身分布均匀，Hash算法的结果就是均匀的。

假设扩容前的table大小为2的N次方，元素的table索引为其hash值的后N位确定扩容后的table大小即为2的N+1次方，则其中元素的table索引为其hash值的后N+1位确定，比原来多了一位重新调整map的大小，并将原来的对象放入新的bucket数组中。这个过程叫作rehashing

因此，table中的元素只有两种情况：
元素hash值第N+1位为0：不需要进行位置调整
元素hash值第N+1位为1：将当前位置移动到 原索引+未扩容前的数组长度 的位置
扩容或初始化完成后，resize方法返回新的table

15、并发集合和普通集合区别？

并发集合常见的有 ConcurrentHashMap、ConcurrentLinkedQueue、ConcurrentLinkedDeque 等。并发集合位于 java.util.concurrent 包下,是 jdk1.5 之后才有的。
在 java 中有普通集合、同步（线程安全）的集合、并发集合。
普通集合通常性能最高，但是不保证多线程的安全性和并发的可靠性。
线程安全集合仅仅是给集合添加了 synchronized 同步锁，严重牺牲了性能，而且对并发的效率就更低了，并发集合则通过复杂的策略不仅保证了多线程的安全又提高的并发时的效率。

16、HashMap的put()和get()原理？

put()原理：
1.根据key获取对应hash值：int hash = hash（key.hash.hashcode（））
2.根据hash值和数组长度确定对应数组引int i = indexFor(hash, table.length);
简单理解就是i = hash值%模以 数组长度（其实是按位与运算）。如果不同的key都映射到了数组的同一位置处，就将其放入单链表中。且新来的是放在头节点。

get()原理：
通过hash获得对应数组位置，遍历该数组所在链表（key.equals（））

17、HashMap是线程安全的吗？为什么？在并发时会导致什么问题？

不是，因为没加锁。

hashmap在接近临界点时，若此时两个或者多个线程进行put操作，都会进行resize（扩容）和ReHash（为key重新计算所在位置），而ReHash在并发的情况下可能会形成链表环。在执行get的时候，会触发死循环，引起CPU的100%问题。
注：jdk8已经修复hashmap这个问题了，jdk8中扩容时保持了原来链表中的顺序。但是HashMap仍是非并发安全，在并发下，还是要使用ConcurrentHashMap。

18、HashMap如何判断有环形表？

创建两个指针A和B（在java里就是两个对象引用），同时指向这个链表的头节点。然后开始一个大循环，在循环体中，让指针A每次向下移动一个节点，让指针B每次向下移动两个节点，然后比较两个指针指向的节点是否相同。如果相同，则判断出链表有环，如果不同，则继续下一次循环。
通俗易懂一点：在一个环形跑道上，两个运动员在同一地点起跑，一个运动员速度快，一个运动员速度慢。当两人跑了一段时间，速度快的运动员必然会从速度慢的运动员身后再次追上并超过，原因很简单，因为跑道是环形的。

19、介绍一下ConcurrentHashMap？

hashmap是由entry数组组成，而ConcurrentHashMap则是Segment数组组成。
Segment本身就相当于一个HashMap。
同HashMap一样，Segment包含一个HashEntry数组，数组中的每一个HashEntry既是一个键值对，也是一个链表的头节点。
单一的Segment结构如下：

Segment对象在ConcurrentHashMap集合中有2的N次方个，共同保存在一个名为segments的数组当中。

可以说，ConcurrentHashMap是一个二级哈希表。在一个总的哈希表下面，有若干个子哈希表。（这样类比理解多个hashmap组成一个cmap）

20、ConcurrentHashMap的put()和get()原理？

put()原理：

1.为输入的Key做Hash运算，得到hash值。

2.通过hash值，定位到对应的Segment对象

3.获取可重入锁

4.再次通过hash值，定位到Segment当中数组的具体位置。

5.插入或覆盖HashEntry对象。

6.释放锁。

get()原理：

1.为输入的Key做Hash运算，得到hash值。

2.通过hash值，定位到对应的Segment对象

3.再次通过hash值，定位到Segment当中数组的具体位置。
由此可见，和hashmap相比，ConcurrentHashMap在读写的时候都需要进行二次定位。先定位到Segment，再定位到Segment内的具体数组下标。

21、为什么ConcurrentHashMap和hashtable都是线程安全的，但是前者性能更高呢？

因为前者是用的分段锁，根据hash值锁住对应Segment对象，当hash值不同时，使其能实现并行插入，效率更高，而hashtable则会锁住整个map。

并行插入：当cmap需要put元素的时候，并不是对整个map进行加锁，而是先通过hashcode来知道他要放在那一个分段（Segment对象）中，然后对这个分段进行加锁，所以当多线程put的时候，只要不是放在同一个分段中，就实现了真正的并行的插入。
分段锁设计解决的问题：

目的是细化锁的粒度，当操作不需要更新整个数组的时候，就仅仅针对数组中的一部分行加锁操作。

22、ConcurrentHashMap为何不支持null键和null值？

HashMap是支持null键和null值，而ConcurrentHashMap却不支持
查看源码如下：
HashMap:

1    static   final   int   hash(Object   key) {
2        int   h;
3        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
4    }

ConcurrentHashMap:

1    /** Implementation for put and putIfAbsent */
2    final   V   putVal  (K   key, V   value, boolean   onlyIfAbsent) {
3        if (key == null || value == null)   throw   new   NullPointerException();
4        int   hash = spread(key.hashCode());
5        int   binCount = 0;
6        ......
7    }

原因：通过get(k)获取对应的value时，如果获取到的是null，此时无法判断它是put（k,v）的时候value为null，还是这个key从来没有做过映射（即没有找到这个key）。而HashMap是非并发的，可以通过contains(key)来做这个判断。而支持并发的Map在调用m.contains（key）和m.get(key),m可能已经不同了。

23、HashMap1.7和1.8的区别？

1.为了加快查询效率，java8的HashMap引入了红黑树结构，当数组长度大于默认阈值64时，且当某一链表的元素>8时，该链表就会转成红黑树结构，查询效率更高。
2.优化扩容方法，在扩容时保持了原来链表中的顺序，避免出现死循环

**红黑树:**一种自平衡二叉树，拥有优秀的查询和插入/删除性能，广泛应用于关联数组。对比AVL树，AVL要求每个结点的左右子树的高度之差的绝对值（平衡因子）最多为1，而红黑树通过适当的放低该条件（红黑树限制从根到叶子的最长的可能路径不多于最短的可能路径的两倍长，结果是这个树大致上是平衡的），以此来减少插入/删除时的平衡调整耗时，从而获取更好的性能，而这虽然会导致红黑树的查询会比AVL稍慢，但相比插入/删除时获取的时间，这个付出在大多数情况下显然是值得的。

24、ConcurrentHashMap1.7和1.8的区别？

1.8的实现已经抛弃了Segment分段锁机制，利用Node数组+CAS+Synchronized来保证并发更新的安全，底层采用数组+链表+红黑树的存储结构。

CAS：
CAS，全称Compare And Swap（比较与交换），解决多线程并行情况下使用锁造成性能损耗的一种机制。java.util.concurrent包中大量使用了CAS原理。
JDK1.8 中的CAS:
Unsafe类，在sun.misc包下，不属于Java标准。Unsafe类提供一系列增加Java语言能力的操作，如内存管理、操作类/对象/变量、多线程同步等。其中与CAS相关的方法有以下几个：

1//var1为CAS操作的对象，offset为var1某个属性的地址偏移值，expected为期望值，var2为要设置的值，利用JNI来完成CPU指令的操作
2public   final   native   boolean   compareAndSwapObject(Object   var1, long   offset, Object   expected, Object   var2);
3public   final   native   boolean   compareAndSwapInt(Object   var1, long   offset, int   expected, int   var2);
4public   final   native   boolean   compareAndSwapLong(Object   var1, long   offset, long   expected, long   var2);

CAS缺点：

ABA问题。当第一个线程执行CAS操作，尚未修改为新值之前，内存中的值已经被其他线程连续修改了两次，使得变量值经历 A->B->A 的过程。
解决方案：添加版本号作为标识，每次修改变量值时，对应增加版本号；做CAS操作前需要校验版本号。JDK1.5之后，新增AtomicStampedReference类来处理这种情况。

循环时间长开销大。如果有很多个线程并发，CAS自旋可能会长时间不成功，会增大CPU的执行开销。

只能对一个变量进原子操作。JDK1.5之后，新增AtomicReference类来处理这种情况，可以将多个变量放到一个对象中。