面试——基础篇

但盼风雨来能留你在此

已于 2022-10-15 15:16:51 修改

阅读量347

点赞数

分类专栏：面试文章标签：面试

于 2021-10-17 10:09:21 首次发布

本文链接：https://blog.csdn.net/weixin_56697114/article/details/120663661

版权

面试专栏收录该内容

7 篇文章 0 订阅

订阅专栏

1、ArrayList的扩容规则

ArrayList() 会使用长度为零的数组
ArrayList(int initialCapacity) 会使用指定容量的数组
public ArrayList(Collection<? extends E> c) 会使用 c 的大小作为数组容量
add(Object o) 首次扩容为 10，再次扩容为上次容量的 1.5 倍
addAll(Collection c) 没有元素时，扩容为 Math.max(10, 实际元素个数)，有元素时为 Math.max(原容量 1.5 倍, 实际元素个数)

2、Iterator

Fail-Fast 与 Fail-Safe

ArrayList 是 fail-fast 的典型代表，遍历的同时不能修改，尽快失败
CopyOnWriteArrayList 是 fail-safe 的典型代表，遍历的同时可以修改，原理是读写分离

3、LinkList

**LinkedList**

基于双向链表，无需连续内存
随机访问慢（要沿着链表遍历）
头尾插入删除性能高
占用内存多

**ArrayList**

基于数组，需要连续内存
随机访问快（指根据下标访问）
尾部插入、删除性能可以，其它部分插入、删除都会移动数据，因此性能会低
可以利用 cpu 缓存，局部性原理

4、HashMap

1、基本数据结构

1.7—— 数组 + 链表
1.8—— 数组 + （链表 | 红黑树）

key会进行两次hash计算，二次hash与容量取模(mod %)获得桶下标，桶下标一样会以链表的方式存储。实现快速查询

2、扩容、树化与阈值

当大量元素在同一个桶下标时，查询效率变低

方法一：扩容（除非原始hash都一样，就不受扩容影响）

方法二：树化

条件：

链表长度超过树化域（固定为8，>8）
数组容量 >=64，如果<64首先会尝试扩容方法

红黑树用来避免 DoS 攻击，防止链表超长时性能下降，树化应当是偶然情况，是保底策略

* hash 表的查找，更新的时间复杂度是 $O(1)$，而红黑树的查找，更新的时间复杂度是 $O(log_2⁡n )$，TreeNode 占用空间也比普通 Node 的大，如非必要，尽量还是使用链表
* hash 值如果足够随机，则在 hash 表内按泊松分布，在负载因子 0.75 的情况下，长度超过 8 的链表出现概率是 0.00000006，树化阈值选择 8 就是为了让树化几率足够小

**退化规则**

* 情况1：在扩容时如果拆分树时，树元素个数 <= 6 则会退化链表
* 情况2：remove 树节点时，若 root、root.left、root.right、root.left.left 有一个为 null ，也会退化为链表

3、细节

1、索引计算

首先，计算对象的 hashCode()，再进行调用 HashMap 的 hash() 方法进行二次哈希，二次 hash() 是为了综合高位数据，让哈希分布更为均匀，最后 & (capacity – 1) 得到索引

2、数组容量为何是 2 的 n 次幂

计算索引时效率更高：如果是 2 的 n 次幂可以使用位与运算代替取模
扩容时重新计算索引效率更高： hash & oldCap == 0 的元素留在原来位置，否则新位置 = 旧位置 + oldCap

二次 hash 是为了配合，容量是 2 的 n 次幂，这一设计前提，如果 hash 表的容量不是 2 的 n 次幂，则不必二次 hash容量是 2 的 n 次幂，这一设计计算索引效率更好，但 hash 的分散性就不好，需要二次 hash 来作为补偿，没有采用这一设计的典型例子是 Hashtable。

4、put与扩容

1、put流程

1. HashMap 是懒惰创建数组的，首次使用才创建数组
2. 计算索引（桶下标）
3. 如果桶下标还没人占用，创建 Node 占位返回
4. 如果桶下标已经有人占用

已经是 TreeNode 走红黑树的添加或更新逻辑
是普通 Node，走链表的添加或更新逻辑，如果链表长度超过树化阈值，走树化逻辑

5. 返回前检查容量是否超过阈值，一旦超过进行扩容

1.7 与 1.8 的区别：

链表插入节点时，1.7 是头插法，1.8 是尾插法：
1.7 是大于等于阈值且没有空位时才扩容，而 1.8 是大于阈值就扩容
1.8 在扩容计算 Node 索引时，会优化

扩容（加载）因子为何默认是 0.75f：16*0.75=12

在空间占用与查询时间之间取得较好的权衡
大于这个值，空间节省了，但链表就会比较长影响性能
小于这个值，冲突减少了，但扩容就会更频繁，空间占用也更多

5、并发问题

1、扩容死链（1.7 会存在）

e 和 next 都是局部变量，用来指向当前节点和下一个节点

线程1（绿色）的临时变量 e 和 next 刚引用了这俩节点，还未来得及移动节点，发生了线程切换，由线程2（蓝色）完成扩容和迁移

线程2 扩容完成，由于头插法，链表顺序颠倒。但线程1 的临时变量 e 和 next 还引用了这俩节点，还要再来一遍迁移

第一次循环

循环接着线程切换前运行，注意此时 e 指向的是节点 a，next 指向的是节点 b
e 头插 a 节点，注意图中画了两份 a 节点，但事实上只有一个（为了不让箭头特别乱画了两份）
当循环结束是 e 会指向 next 也就是 b 节点

第二次循环

next 指向了节点 a
e 头插节点 b
当循环结束时，e 指向 next 也就是节点 a

第三次循环

next 指向了 null
e 头插节点 a，**a 的 next 指向了 b**（之前 a.next 一直是 null），b 的 next 指向 a，死链已成
当循环结束时，e 指向 next 也就是 null，因此第四次循环时会正常退出

2、数据错乱（1.7，1.8 都会存在）

6、key的设计

HashMap 的 key 可以为 null，但 Map 的其他实现则不然
作为 key 的对象，必须实现 hashCode 和 equals，并且 key 的内容不能修改（不可变）
key 的 hashCode 应该有良好的散列性

String 对象的 hashCode() 设计

目标是达到较为均匀的散列效果，每个字符串的 hashCode 足够独特
字符串中的每个字符都可以表现为一个数字，称为 $S_i$，其中 i 的范围是 0 ~ n - 1
散列公式为： $S_0 ∗ 31 ^ {(n-1)} + S_1 ∗ 31 ^ {(n-2)} + … S_i ∗ 31 ^{(n-1-i)} + …S_{(n-1)} ∗ 31 ^ 0$
31 代入公式有较好的散列特性，并且 31 * h 可以被优化为

即 $32 ∗ h - h $
即 $2 ^ 5 ∗ h - h$
即 $h ≪5 - h$

6、设计模式

掌握五种单例模式的实现方式
理解为何 DCL 实现时要使用 volatile 修饰静态变量
了解 jdk 中用到单例的场景

// 1. 饿汉式
public class Singleton1 implements Serializable {
    //1.私有构造
    private Singleton1() {
        //防止反射破坏单例
        if (INSTANCE != null) {
            throw new RuntimeException("单例对象不能重复创建");
        }
        System.out.println("private Singleton1()");
    }

    //2.静态的成员变量
    private static final Singleton1 INSTANCE = new Singleton1();

    //3.公共的静态方法
    public static Singleton1 getInstance() {
        return INSTANCE;
    }

    //作用：调用该方法，进行类的初始化
    public static void otherMethod() {
        System.out.println("otherMethod()");
    }

    //重写该方法，防止反序列化破坏单例
    public Object readResolve() {
        return INSTANCE;
    }

    //Unsafe 破坏单例尚未解决
}

package pattern;

// 2. 枚举饿汉式
//不能防止 Unsafe，其他没问题
public enum Singleton2 {
    INSTANCE;

    private Singleton2() {
        System.out.println("private Singleton2()");
    }

    @Override
    public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

    public static Singleton2 getInstance() {
        return INSTANCE;
    }

    public static void otherMethod() {
        System.out.println("otherMethod()");
    }
}

package pattern;

import java.io.Serializable;

// 3. 懒汉式单例
public class Singleton3 implements Serializable {
    private Singleton3() {
        System.out.println("private Singleton3()");
    }

    private static Singleton3 INSTANCE = null;

    // 加 synchronized，使线程安全
    public static synchronized Singleton3 getInstance() {
        if (INSTANCE == null) {
            INSTANCE = new Singleton3();
        }
        return INSTANCE;
    }

    public static void otherMethod() {
        System.out.println("otherMethod()");
    }

}

package pattern;

import java.io.Serializable;

// 对第 3.优化
// 4. 懒汉式单例 - DCL（双检锁）
public class Singleton4 implements Serializable {
    private Singleton4() {
        System.out.println("private Singleton4()");
    }

    //volatile：保证共享变量的可见性和有序性
    private static volatile Singleton4 INSTANCE = null;

    public static Singleton4 getInstance() {
        if (INSTANCE == null) {
            synchronized (Singleton4.class) {
                if (INSTANCE == null) {
                    INSTANCE = new Singleton4();
                }
            }
        }
        return INSTANCE;
    }

    public static void otherMethod() {
        System.out.println("otherMethod()");
    }
}

package pattern;

import java.io.Serializable;

// 5. 懒汉式单例 - 内部类（推荐）
public class Singleton5 implements Serializable {
    private Singleton5() {
        System.out.println("private Singleton5()");
    }

    private static class Holder {
        static Singleton5 INSTANCE = new Singleton5();
    }

    public static Singleton5 getInstance() {
        return Holder.INSTANCE;
    }

    public static void otherMethod() {
        System.out.println("otherMethod()");
    }
}

jdk中单例的体现

RunTime 饿汉式、System 双检锁、Collections 懒汉式、Comparators 枚举饿汉式