八股文-java基础
参考资料：
JavaGuide面试指南
黑马java八股文视频教程
一、ArrayList
1.简单介绍ArrayList
ArrayList底层使用Object数组，即动态数组
transient Object[] elementData;
2.ArrayList扩容规则
- ArrayList() 会使用长度为零的数组
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = new Object[0];
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
- ArrayList(int initialCapacity) 会使用指定容量的数组
public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {
this.elementData = new Object[initialCapacity];
} else {
if (initialCapacity != 0) {
throw new IllegalArgumentException("Illegal Capacity: " + initialCapacity);
}
this.elementData = EMPTY_ELEMENTDATA;
}
}
- public ArrayList(Collection<? extends E> c) 会使用 c 的大小作为数组容量
public ArrayList(Collection<? extends E> c) {
Object[] a = c.toArray();
if ((this.size = a.length) != 0) {
if (c.getClass() == ArrayList.class) {
this.elementData = a;
} else {
this.elementData = Arrays.copyOf(a, this.size, Object[].class);
}
} else {
this.elementData = EMPTY_ELEMENTDATA;
}
}
-
add(Object o) 首次扩容为 10，再次扩容为上次容量的 1.5 倍
-
addAll(Collection c) 没有元素时，扩容为 Math.max(10, 实际元素个数)，有元素时为 Math.max(原容量 1.5 倍, 实际元素个数)
private Object[] grow(int minCapacity) {
return this.elementData = Arrays.copyOf(this.elementData, this.newCapacity(minCapacity));
}
private Object[] grow() {
return this.grow(this.size + 1);
}
private int newCapacity(int minCapacity) {
//minCapacity为至少需要扩容的大小
int oldCapacity = this.elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity <= 0) {
if (this.elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
//首次初始化时，初始化足够大的内存，最小为10
return Math.max(10, minCapacity);
} else if (minCapacity < 0) {
throw new OutOfMemoryError();
} else {
//若扩容1.5倍不够，则扩容minCapacity
return minCapacity;
}
} else {
return newCapacity - 2147483639 <= 0 ? newCapacity : hugeCapacity(minCapacity);
}
}
在newCapacity方法中可以看到，所谓的1.5倍的计算方法是
int newCapacity = oldCapacity + (oldCapacity >> 1);
- 若以无参构造的形式初始化ArrayList，只有在第一次add元素时才会扩容。
3.与LinkedList的区别
首先从底层数据结构的角度来回答：
- LinkedList基于双向链表，不需要连续内存；ArrayList基于数组，需要连续内存；
- LinkedList随机访问慢，因为要沿着链表遍历；ArrayList随机访问快，因为可以直接访问下标；
- LinkedList头尾删除效率高，ArrayList尾部插入和删除效率高，甚至略高于LinkedList，但是头部插入删除效率低，因为需要移动后面的所有元素。两者其他位置的插入删除效率都一般。
- LinkedList占用内存比ArrayList高，因为每个结点还要存储前驱和后继等额外信息；
其他方面：
5. 两者都不保证线程安全；
6. ArrayList由于底层数组内存空间连续，可以利用cpu缓存（局部性原理），效率更高。
二、HashMap
1.基本数据结构
JDK1.8 之前： 数组+链表
JDK1.8 之后： 数组+链表或者红黑树
2.树化与退化
a.为什么要树化
- 红黑树用来避免 DoS 攻击，防止链表超长时性能下降，树化应当是偶然情况，是保底策略
- hash 表的查找，更新的时间复杂度是 O ( 1 ) O(1) O(1)，而红黑树的查找，更新的时间复杂度是 O ( l o g 2 n ) O(log_2n ) O(log2n)，TreeNode 占用空间也比普通 Node 的大，如非必要，尽量还是使用链表
- hash 值如果足够随机，则在 hash 表内按泊松分布，在负载因子 0.75 的情况下，长度超过 8 的链表出现概率是 0.00000006，树化阈值选择 8 就是为了让树化几率足够小
b.树化规则
- 当链表长度超过树化阈值 8 时，先尝试扩容来减少链表长度，如果数组容量已经 >=64，才会进行树化
c.退化规则
- 情况1：在扩容时如果拆分树时，树元素个数 <= 6 则会退化链表
- 情况2：remove 树节点时，若 root、root.left、root.right、root.left.left 有一个为 null ，也会退化为链表
3.索引计算
JDK1.8 之前：
- 首先，计算对象的 hashCode()
- 再进行调用 HashMap 的 hash() 方法进行二次哈希，二次 hash() 是为了综合高位数据，让哈希分布更为均匀
- 最后 & (capacity – 1) 得到索引
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 之后：
static final int hash(Object key) {
int h;
return key == null ? 0 : (h = key.hashCode()) ^ h >>> 16;
}
4.数组容量为什么是2的n次幂
- 计算索引时效率更高：如果是 2 的 n 次幂可以使用位与运算代替取模，取余(%)操作中如果除数是 2 的幂次则等价于与其除数减一的与(&)操作
- 扩容时重新计算索引效率更高： hash & oldCap == 0 的元素留在原来位置 ，否则新位置 = 旧位置 + oldCap
5.put操作流程
- HashMap 是懒惰创建数组的，首次使用才创建数组
- 计算索引（桶下标）
- 如果桶下标还没人占用，创建 Node 占位返回
- 如果桶下标已经有人占用
- 已经是 TreeNode 走红黑树的添加或更新逻辑
- 是普通 Node，走链表的添加或更新逻辑，如果链表长度超过树化阈值，走树化逻辑
- 返回前检查容量是否超过阈值，一旦超过进行扩容
6.jdk1.7和1.8有什么区别
-
链表插入节点时，1.7 是头插法，1.8 是尾插法
-
1.7 是大于等于阈值且没有空位时才扩容，而 1.8 是大于阈值就扩容
-
1.8 在扩容计算 Node 索引时，会优化
7.扩容因子为什么是0.75
- 在空间占用与查询时间之间取得较好的权衡
- 大于这个值，空间节省了，但链表就会比较长影响性能
- 小于这个值，冲突减少了，但扩容就会更频繁，空间占用也更多
8.HashMap 和 Hashtable 的区别
-
线程是否安全： HashMap 是非线程安全的，Hashtable 是线程安全的,因为 Hashtable 内部的方法基本都经过synchronized 修饰。
-
效率： 因为线程安全的问题，HashMap 要比 Hashtable 效率高一点。另外，Hashtable 基本被淘汰，不要在代码中使用它；
-
对 Null key 和 Null value 的支持： HashMap 可以存储 null 的 key 和 value，但 null 作为键只能有一个，null 作为值可以有多个；Hashtable 不允许有 null 键和 null 值，否则会抛出NullPointerException。
-
初始容量大小和每次扩充容量大小的不同 ：
① 创建时如果不指定容量初始值，Hashtable 默认的初始大小为 11，之后每次扩充，容量变为原来的 2n+1。HashMap 默认的初始化大小为 16。之后每次扩充，容量变为原来的 2 倍。
② 创建时如果给定了容量初始值，那么 Hashtable 会直接使用你给定的大小，而 HashMap 会将其扩充为 2 的幂次方大小。 -
底层数据结构： JDK1.8 以后的 HashMap 在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为 8）时，将链表转化为红黑树（将链表转换成红黑树前会判断，如果当前数组的长度小于 64，那么会选择先进行数组扩容，而不是转换为红黑树），以减少搜索时间。Hashtable 没有这样的机制。
9.HashSet 如何检查重复
HashSet的底层就是基于HashMap做的，大多数方法都是对map方法的调用
public boolean contains(Object o) {
return this.map.containsKey(o);
}
public boolean add(E e) {
return this.map.put(e, PRESENT) == null;
}
三、ConcurrentHashMap
1.HashMap的并发问题
a.扩容死链（jdk1.7）
HashMap在扩容转移链表的的时候使用了两个指针e，next分别指向当前结点和下一个结点。假设当前线程的指针正指向这两个结点，现在突然插进来一个线程，同样进行了扩容操作，由于采用的是头插法且使用的是原来的结点对象，所以链表顺序发生了反转，此时原来的线程e和next仍然指向反转之前的两个结点，继续扩容就会产生环。
详细图文解释
b.数据错乱（1.7和1.8都会有）
在下方代码注释处，线程已经拿到了头结点和hash桶，若此时cpu挂起，重新进入执行前，这个hash桶已经被其他线程更改过，那么在该线程重入后，他将持有一个过期的桶和头结点，并且覆盖之前其他线程的记录，造成了数据丢失。
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
// 线程已经拿到了头结点和hash桶
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
2.Hashtable 对比 ConcurrentHashMap
- Hashtable 与 ConcurrentHashMap 都是线程安全的 Map 集合
- Hashtable 并发度低，整个 Hashtable 对应一把锁，同一时刻，只能有一个线程操作它
- ConcurrentHashMap 并发度高，整个 ConcurrentHashMap 对应多把锁，只要线程访问的是不同锁，那么不会冲突
3.jdk1.7版本的ConcurrentHashMap
- 数据结构：
Segment(大数组) + HashEntry(小数组) + 链表，每个 Segment 对应一把锁，如果多个线程访问不同的 Segment，则不会冲突 - 并发度：Segment 数组大小即并发度，决定了同一时刻最多能有多少个线程并发访问。Segment 数组不能扩容，意味着并发度在 ConcurrentHashMap 创建时就固定了，默认支持16个并发
- 扩容：每个小数组的扩容相对独立，小数组在超过扩容因子时会触发扩容，每次扩容翻倍
- Segment[0] 原型：首次创建其它小数组时，会以此原型为依据，数组长度，扩容因子都会以原型为准
4.jkd1.8版本的ConcurrentHashMap
- 数据结构：
Node 数组 + 链表或红黑树，数组的每个头节点作为锁，如果多个线程访问的头节点不同，则不会冲突。首次生成头节点时如果发生竞争，利用 cas 而非 syncronized，进一步提升性能 - 并发度：Node 数组有多大，并发度就有多大，与 1.7 不同，Node 数组可以扩容
- 扩容条件：Node 数组满 3/4 时就会扩容
- 扩容单位：以链表为单位从后向前迁移链表，迁移完成的将旧数组头节点替换为 ForwardingNode
- 扩容时并发 get
- 根据是否为 ForwardingNode 来决定是在新数组查找还是在旧数组查找，不会阻塞
- 如果链表长度超过 1，则需要对节点进行复制（创建新节点），怕的是节点迁移后 next 指针改变
- 如果链表最后几个元素扩容后索引不变，则节点无需复制
- 扩容时并发 put
- 如果 put 的线程与扩容线程操作的链表是同一个，put 线程会阻塞
- 如果 put 的线程操作的链表还未迁移完成，即头节点不是 ForwardingNode，则可以并发执行
- 如果 put 的线程操作的链表已经迁移完成，即头结点是 ForwardingNode，则可以协助扩容
- 与 1.7 相比是懒惰初始化
- capacity 代表预估的元素个数，capacity / factory 来计算出初始数组大小，需要贴近 2 n 2^n 2n
- loadFactor 只在计算初始数组大小时被使用，之后扩容固定为 3/4
- 超过树化阈值时的扩容问题，如果容量已经是 64，直接树化，否则在原来容量基础上做 3 轮扩容
四、String类型
String、StringBuffer、Stringbuilder有什么区别
- 可变性：String是不可变的
private final char value[];
- 线程安全性：String 中的对象是不可变的，也就可以理解为常量，线程安全。StringBuffer 对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。StringBuilder 并没有对方法进行加同步锁，所以是非线程安全的。
- 性能：每次对 String 类型进行改变的时候，都会生成一个新的 String 对象，然后将指针指向新的 String 对象。StringBuffer 每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象并改变对象引用。相同情况下使用 StringBuilder 相比使用 StringBuffer 仅能获得 10%~15% 左右的性能提升，但却要冒多线程不安全的风险。
五、单例模式
单例模式具有以下特点：
- 单例类只能有一个实例。
- 单例类必须自己创建自己的唯一实例。
- 单例类必须给所有其他对象提供这一实例。
1.饿汉式单例
饿汉式单例类：在类初始化时，已经自行实例化
public class Singleton1{
private static final Singleton1 INSTANCE = new Singleton1();
public static Singleton1 getInstance() {
return INSTANCE;
}
}
2.懒汉式单例
懒汉式单例类：在第一次调用的时候实例化自己
public class Singleton2{
private static Singleton2 INSTANCE = null;
public static synchronized Singleton2 getInstance() {
if (INSTANCE == null) {
INSTANCE = new Singleton2();
}
return INSTANCE;
}
public static void otherMethod() {
System.out.println("otherMethod()");
}
}
上面代码每次在调用getInstance都会加锁，实际上只有在第一次实例化的时候才需要加锁，做出以下改进。
3.双检索懒汉式
public class Singleton3{
private static volatile Singleton3 INSTANCE = null; // 可见性，有序性
public static Singleton3 getInstance() {
if (INSTANCE == null) {
synchronized (Singleton3.class) {
if (INSTANCE == null) {
INSTANCE = new Singleton3();
}
}
}
return INSTANCE;
}
}
为何必须加 volatile：
INSTANCE = new Singleton4()不是原子的，分成 3 步：创建对象、调用构造、给静态变量赋值，其中后两步可能被指令重排序优化，变成先赋值、再调用构造- 如果线程1 先执行了赋值，线程2 执行到第一个
INSTANCE == null时发现 INSTANCE 已经不为 null，此时就会返回一个未完全构造的对象
4.静态内部类
public class Singleton {
private static class LazyHolder {
private static final Singleton INSTANCE = new Singleton();
}
private Singleton (){}
public static final Singleton getInstance() {
return LazyHolder.INSTANCE;
}
}
这种方式既解决了线程安全问题，也避免了由于同步操作而增大的性能消耗。
14万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
