2019-05-07 20:04:47 +08:00
<!-- TOC -->
- [剖析面试最常见问题之Java基础知识 ](#剖析面试最常见问题之java基础知识 )
- [说说List,Set,Map三者的区别？ ](#说说listsetmap三者的区别 )
- [Arraylist 与 LinkedList 区别? ](#arraylist-与-linkedlist-区别 )
- [**补充内容:RandomAccess接口** ](#补充内容randomaccess接口 )
- [补充内容:双向链表和双向循环链表 ](#补充内容双向链表和双向循环链表 )
- [ArrayList 与 Vector 区别呢?为什么要用Arraylist取代Vector呢？ ](#arraylist-与-vector-区别呢为什么要用arraylist取代vector呢 )
- [说一说 ArrayList 的扩容机制吧 ](#说一说-arraylist-的扩容机制吧 )
- [HashMap 和 Hashtable 的区别 ](#hashmap-和-hashtable-的区别 )
- [HashMap 和 HashSet区别 ](#hashmap-和-hashset区别 )
- [HashSet如何检查重复 ](#hashset如何检查重复 )
- [HashMap的底层实现 ](#hashmap的底层实现 )
- [JDK1.8之前 ](#jdk18之前 )
- [JDK1.8之后 ](#jdk18之后 )
- [HashMap 的长度为什么是2的幂次方 ](#hashmap-的长度为什么是2的幂次方 )
- [HashMap 多线程操作导致死循环问题 ](#hashmap-多线程操作导致死循环问题 )
- [ConcurrentHashMap 和 Hashtable 的区别 ](#concurrenthashmap-和-hashtable-的区别 )
- [ConcurrentHashMap线程安全的具体实现方式/底层具体实现 ](#concurrenthashmap线程安全的具体实现方式底层具体实现 )
- [JDK1.7（上面有示意图） ](#jdk17上面有示意图 )
- [JDK1.8 （上面有示意图） ](#jdk18-上面有示意图 )
- [comparable 和 Comparator的区别 ](#comparable-和-comparator的区别 )
- [Comparator定制排序 ](#comparator定制排序 )
- [重写compareTo方法实现按年龄来排序 ](#重写compareto方法实现按年龄来排序 )
- [集合框架底层数据结构总结 ](#集合框架底层数据结构总结 )
- [Collection ](#collection )
- [1. List ](#1-list )
- [2. Set ](#2-set )
- [Map ](#map )
- [如何选用集合? ](#如何选用集合 )
- [集合的选用 ](#集合的选用 )
<!-- /TOC -->
# 剖析面试最常见问题之Java基础知识
## 说说List,Set,Map三者的区别？
- **List(对付顺序的好帮手)： （ ） ，
- **Set(注重独一无二的性质):** 不允许重复的集合。不会有多个元素引用相同的对象。
- **Map(用Key来搜索的专家):** 使用键值对存储。Map会维护与Key有关联的值。两个Key可以引用相同的对象， ， ，
## Arraylist 与 LinkedList 区别?
- **1. 是否保证线程安全：** ArrayList 和 LinkedList 都是不同步的，也就是不保证线程安全；
- **2. 底层数据结构：** Arraylist 底层使用的是Object数组； （ ，
- **3. 插入和删除是否受元素位置的影响：** ① **ArrayList 采用数组存储，所以插入和删除元素的时间复杂度受元素位置的影响。** 比如：执行`add(E e) `方法的时候， ArrayList 会默认在将指定的元素追加到此列表的末尾， add(int index, E element) `）时间复杂度就为 O(n-i)。因为在进行上述操作的时候集合中第 i 和第 i 个元素之后的(n-i)个元素都要执行向后位/向前移一位的操作。 ② **LinkedList 采用链表存储，所以插入，删除元素时间复杂度不受元素位置的影响，都是近似 O（ ） （ ）
- **4. 是否支持快速随机访问：** LinkedList 不支持高效的随机元素访问，而 ArrayList 支持。快速随机访问就是通过元素的序号快速获取元素对象(对应于`get(int index) `方法)。
- **5. 内存空间占用：** ArrayList的空 间浪费主要体现在在list列表的结尾会预留一定的容量空间， （ ）
### **补充内容:RandomAccess接口**
```
public interface RandomAccess {
}
```
查看源码我们发现实际上 RandomAccess 接口中什么都没有定义。所以，在我看来 RandomAccess 接口不过是一个标识罢了。标识什么？ 标识实现这个接口的类具有随机访问功能。
在binarySearch（ ） ， ， ， （ ） ， ， （ ）
```
public static < T >
int binarySearch(List< ? extends Comparable< ? super T>> list, T key) {
if (list instanceof RandomAccess || list.size()< BINARYSEARCH_THRESHOLD )
return Collections.indexedBinarySearch(list, key);
else
return Collections.iteratorBinarySearch(list, key);
}
```
ArrayList 实现了 RandomAccess 接口， 而 LinkedList 没有实现。为什么呢？ ！ （ ） ， ， （ ） ， ，
**下面再总结一下 list 的遍历方式选择：**
- 实现了RandomAccess接口的list， ，
2019-05-26 23:41:46 +08:00
- 未实现RandomAccess接口的list， （ ） ， ，
2019-05-07 20:04:47 +08:00
### 补充内容:双向链表和双向循环链表
**双向链表：** 包含两个指针， ，
**双向循环链表：** 最后一个节点的 next 指向head， ，
## ArrayList 与 Vector 区别呢?为什么要用Arraylist取代Vector呢？
Vector类的所有方法都是同步的。可以由两个线程安全地访问一个Vector对象、但是一个线程访问Vector的话代码要在同步操作上耗费大量的时间。
Arraylist不是同步的，
## 说一说 ArrayList 的扩容机制吧
详见笔主的这篇文章:[通过源码一步一步分析ArrayList 扩容机制](ArrayList-Grow.md)
## HashMap 和 Hashtable 的区别
1. **线程是否安全：** HashMap 是非线程安全的， ；
2. **效率：** 因为线程安全的问题， ，
3. **对Null key 和Null value的支持： HashMap 中， ，
4. **初始容量大小和每次扩充容量大小的不同 ： ①创建时如果不指定容量初始值， ， ， ， ， （
5. **底层数据结构：** JDK1.8 以后的 HashMap 在解决哈希冲突时有了较大的变化， （ ） ， ，
**HasMap 中带有初始容量的构造函数：**
```java
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的幂作为哈希表的大小。
```java
/**
* 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;
}
```
## HashMap 和 HashSet区别
如果你看过 HashSet 源码的话就应该知道： （ `clone() ` 、`writeObject()`、`readObject()`是 HashSet 自己不得不实现之外，其他方法都是直接调用 HashMap 中的方法。
| HashMap | HashSet |
| :------------------------------: | :----------------------------------------------------------: |
| 实现了Map接口 | 实现Set接口 |
| 存储键值对 | 仅存储对象 |
| 调用 `put（ ） 向map中添加元素 | 调用 `add（ ） 方法向Set中添加元素 |
| HashMap使用键（ ） ， ，
## HashSet如何检查重复
当你把对象加入HashSet时， ， ， ， ， （ ） ， （ ）
**hashCode（ ） （ ） ：
1. 如果两个对象相等，
2. 两个对象相等,对两个equals方法返回true
3. 两个对象有相同的hashcode值，
4. 综上， ，
5. hashCode()的默认行为是对堆上的对象产生独特值。如果没有重写hashCode()， （ ）
**==与equals的区别**
1. ==是判断两个变量或实例是不是指向同一个内存空间 equals是判断两个变量或实例所指向的内存空间的值是不是相同
2. ==是指对内存地址进行比较 equals()是对字符串的内容进行比较
3. ==指引用是否相同 equals()指的是值是否相同
## HashMap的底层实现
### JDK1.8之前
JDK1.8 之前 HashMap 底层是 **数组和链表** 结合在一起使用也就是 **链表散列** 。**HashMap 通过 key 的 hashCode 经过扰动函数处理过后得到 hash 值，然后通过 (n - 1) & hash 判断当前元素存放的位置（这里的 n 指的是数组的长度），如果当前位置存在元素的话，就判断该元素与要存入的元素的 hash 值以及 key 是否相同，如果相同的话，直接覆盖，不相同就通过拉链法解决冲突。**
**所谓扰动函数指的就是 HashMap 的 hash 方法。使用 hash 方法也就是扰动函数是为了防止一些实现比较差的 hashCode() 方法 换句话说使用扰动函数之后可以减少碰撞。**
**JDK 1.8 HashMap 的 hash 方法源码:**
JDK 1.8 的 hash方法 相比于 JDK 1.7 hash 方法更加简化，但是原理不变。
```
static final int hash(Object key) {
int h;
// key.hashCode()：
// ^ ：按位异或
// >>>:无符号右移， ，
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 方法 ，
所谓 ** “拉链法”** 就是：将链表和数组相结合。也就是说创建一个链表数组，数组中每一格就是一个链表。若遇到哈希冲突，则将冲突的值加到链表中即可。
[](https://camo.githubusercontent.com/eec1c575aa5ff57906dd9c9130ec7a82e212c96a/68747470733a2f2f757365722d676f6c642d63646e2e786974752e696f2f323031382f332f32302f313632343064626363333033643837323f773d33343826683d34323726663d706e6726733d3130393931)
### JDK1.8之后
相比于之前的版本， JDK1.8之后在解决哈希冲突时有了较大的变化， （ ） ， ，
[](https://camo.githubusercontent.com/20de7e465cac279842851258ec4d1ec1c4d3d7d1/687474703a2f2f6d792d626c6f672d746f2d7573652e6f73732d636e2d6265696a696e672e616c6979756e63732e636f6d2f31382d382d32322f36373233333736342e6a7067)
> TreeMap、TreeSet以及JDK1.8之后的HashMap底层都用到了红黑树。红黑树就是为了解决二叉查找树的缺陷，
**推荐阅读：**
- 《Java 8系列之重新认识HashMap》 ： < https: // zhuanlan . zhihu . com / p / 21673805 >
## HashMap 的长度为什么是2的幂次方
为了能让 HashMap 存取高效， ， ， ， ， ， ， ， `(n - 1) & hash` ”。（ ）
**这个算法应该如何设计呢？**
我们首先可能会想到采用%取余的操作来实现。但是，重点来了：**“取余(%)操作中如果除数是2的幂次则等价于与其除数减一的与(& )操作（也就是说 hash%length==hash& (length-1)的前提是 length 是2的 n 次方；）。”** 并且 **采用二进制位操作 &，相对于%能够提高运算效率，这就解释了 HashMap 的长度为什么是2的幂次方。**
## HashMap 多线程操作导致死循环问题
主要原因在于 并发下的Rehash 会造成元素之间会形成一个循环链表。不过，
详情请查看：< https: / / coolshell . cn / articles / 9606 . html >
## ConcurrentHashMap 和 Hashtable 的区别
ConcurrentHashMap 和 Hashtable 的区别主要体现在实现线程安全的方式上不同。
- **底层数据结构：** JDK1.7的 ConcurrentHashMap 底层采用 **分段的数组+链表** 实现， **数组+链表** 的形式，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突而存在的；
- **实现线程安全的方式（重要）：** ① **在JDK1.7的时候， （ ） 对整个桶数组进行了分割分段(Segment)，每一把锁只锁容器其中一部分数据，多线程访问容器里不同数据段的数据，就不会存在锁竞争，提高并发访问率。 **到了 JDK1.8 的时候已经摒弃了Segment的概念， （ ） 整个看起来就像是优化过且线程安全的 HashMap， **Hashtable(同一把锁)** :使用 synchronized 来保证线程安全，效率非常低下。当一个线程访问同步方法时，其他线程也访问同步方法，可能会进入阻塞或轮询状态，如使用 put 添加元素，另一个线程不能使用 put 添加元素，也不能使用 get，
**两者的对比图：**
图片来源：< http: / / www . cnblogs . com / chengxiao / p / 6842045 . html >
HashTable: [](https://camo.githubusercontent.com/b8e66016373bb109e923205857aeee9689baac9e/687474703a2f2f6d792d626c6f672d746f2d7573652e6f73732d636e2d6265696a696e672e616c6979756e63732e636f6d2f31382d382d32322f35303635363638312e6a7067)
**JDK1.7的ConcurrentHashMap： ](https://camo.githubusercontent.com/443af05b6be6ed09e50c78a1dca39bf75acb106d/687474703a2f2f6d792d626c6f672d746f2d7573652e6f73732d636e2d6265696a696e672e616c6979756e63732e636f6d2f31382d382d32322f33333132303438382e6a7067)**JDK1.8的ConcurrentHashMap（ ](https://camo.githubusercontent.com/2d779bf515db75b5bf364c4f23c31268330a865e/687474703a2f2f6d792d626c6f672d746f2d7573652e6f73732d636e2d6265696a696e672e616c6979756e63732e636f6d2f31382d382d32322f39373733393232302e6a7067)
## ConcurrentHashMap线程安全的具体实现方式/底层具体实现
### JDK1.7（上面有示意图）
首先将数据分为一段一段的存储，然后给每一段数据配一把锁，当一个线程占用锁访问其中一个段数据时，其他段的数据也能被其他线程访问。
**ConcurrentHashMap 是由 Segment 数组结构和 HashEntry 数组结构组成**。
Segment 实现了 ReentrantLock,所以 Segment 是一种可重入锁，
```
static class Segment< K , V > extends ReentrantLock implements Serializable {
}
```
一个 ConcurrentHashMap 里包含一个 Segment 数组。Segment 的结构和HashMap类似， ， ，
### JDK1.8 （上面有示意图）
ConcurrentHashMap取消了Segment分段锁， （ ） （ ） （ ）
synchronized只锁定当前链表或红黑二叉树的首节点， ， ，
## comparable 和 Comparator的区别
- comparable接口实际上是出自java.lang包 它有一个 `compareTo(Object obj)` 方法用来排序
- comparator接口实际上是出自 java.util 包它有一个`compare(Object obj1, Object obj2)`方法用来排序
一般我们需要对一个集合使用自定义排序时，我们就要重写`compareTo()`方法或`compare()`方法， ， ， ， `Collections.sort()` .
### Comparator定制排序
```java
ArrayList< Integer > arrayList = new ArrayList< Integer > ();
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);
// void sort(List list),按自然排序的升序排序
Collections.sort(arrayList);
System.out.println("Collections.sort(arrayList):");
System.out.println(arrayList);
// 定制排序的用法
Collections.sort(arrayList, new Comparator< Integer > () {
@Override
public int compare(Integer o1, Integer o2) {
return o2.compareTo(o1);
}
});
System.out.println("定制排序后：");
System.out.println(arrayList);
```
Output:
```
原始数组:
[-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]
定制排序后：
[7, 4, 3, 3, -1, -5, -7, -9]
```
### 重写compareTo方法实现按年龄来排序
```java
// person对象没有实现Comparable接口， ， ，
// 前面一个例子的String类已经默认实现了Comparable接口， ，
// 像Integer类等都已经实现了Comparable接口，
public class Person implements Comparable< Person > {
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;
}
/**
* TODO重写compareTo方法实现按年龄来排序
*/
@Override
public int compareTo(Person o) {
// TODO Auto-generated method stub
if (this.age > o.getAge()) {
return 1;
} else if (this.age < o.getAge ( ) ) {
return -1;
}
return age;
}
}
```
```java
public static void main(String[] args) {
TreeMap< Person , String > pdata = new TreeMap< Person , String > ();
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< Person > keys = pdata.keySet();
for (Person key : keys) {
System.out.println(key.getAge() + "-" + key.getName());
}
}
```
Output：
```
5-小红
10-王五
20-李四
30-张三
```
## 集合框架底层数据结构总结
### Collection
#### 1. List
- **Arraylist：
- **Vector：
- **LinkedList： ，
#### 2. Set
- **HashSet（ ， ）
- **LinkedHashSet： ，
- **TreeSet（ ， ） ：
### Map
- **HashMap： ， ， （ ） ， （ ） ， ，
- **LinkedHashMap： ， ， （
- **Hashtable：
- **TreeMap：
## 如何选用集合?
## 集合的选用
2019-05-26 23:41:46 +08:00
主要根据集合的特点来选用， ， ， ， ， ，
