100万字java面试题大全

第⼀章：Java基础

1.1、面向对象的三个基本特征？

继承： 让某个类型的对象获得另⼀个类型的对象的属性和⽅法。继承就是⼦类继承⽗类的特征和⾏为 ，使得⼦类对象 ( 实例) 具有⽗类的实例域和⽅法 ，或⼦类从⽗类继承⽅法 ，使得⼦类具有⽗类相同的⾏为。

封装： 隐藏部分对象的属性和实现细节 ，对数据的访问只能通过外公开的接⼝ 。通过这种⽅式 ，对象 对内部数据提供了不同级别的保护 ，以防⽌程序中⽆关的部分意外的改变或错误的使⽤了对象的私有 部分。

多态：对于同⼀个⾏为 ，不同的⼦类对象具有不同的表现形式。

            多态存在的3个条件：继承，重写，父类引用指向子类对象

举个简单的例⼦： 英雄联盟⾥⾯我们按下 Q 键这个动作：

• 对于亚索 ，就是斩钢闪

• 对于提莫 ，就是致盲吹箭

• 对于剑圣 ，就是阿尔法突袭

同⼀个事件发⽣在不同的对象上会产⽣不同的结果。

下⾯再举个简单的例⼦帮助⼤家理解 ，这个例⼦可能不是完全准确 ，但是依然是可以帮助我们理解的。

    public class Animal { / 动物
        public void sleep() {
            System.out.println("躺着睡");
        }
    }
    class Horse extends Animal { / ⻢ 是⼀种动物
        public void sleep() {
            System.out.println("站着睡");
        }
    }
    class Cat extends Animal { / 猫 是⼀种动物
        private int age;
        public int getAge() {
            return age + 1;
    }
    @Override
    public void sleep() {
        System.out.println("四脚朝天的睡");
        }
    }

在这个例⼦中：

House 和 Cat 都是 Animal ，所以他们都继承了Animal ， 同时也从 Animal 继承了 sleep 这个⾏为。

在 Cat ⾥ ，将 age 属性定义为 private ，外界⽆法直接访问 ，要获取 Cat 的 age 信息只能通过 getAge ⽅法 ，从⽽对外隐藏了 age 属性 ，这个就叫做封装。 当然 ，这边 age 只是个例⼦ ，实际使⽤中可能是 ⼀个复杂很多的对象。但是针对 sleep 这个⾏为 ， House 和Cat 进⾏了重写 ，有了不同的表现形式 ( 实现)， 这个我们称为 多态。

1.2、访问修饰符public ，private ，protected ，以及不写 (default) 时的区别？

类的成员不写访问修饰符默认为default ，默认对于同⼀个包的其他类相当于公开 ( public)，对于不是同⼀个包的其他类相当于私有 ( private) 。

受保护 ( protected) 对⼦类相当于公开 ，对于不是同⼀个包没有⽗⼦关系的类相当于私有。

Java中 ，外部类的修饰符只能是public或默认 ，类的成员 (包括内部类) 的修饰符可以是以上四种。

1.3、下⾯两个代码块能正常编译和执⾏吗？

// 代码块1
short s1 = 1; s1 = s1 + 1;
// 代码块2
short s1 = 1; s1 += 1;

代码块1编译报错 ，错误原因是：不兼容的类型: 从int转换到short可能会有损失”。

代码块2正常编译和执⾏。

我们将代码块2进⾏编译，字节码如下：

public class com.joonwhee.open.demo.Convert {
    public com.joonwhee.open.demo.Convert();
        Code:
            0: aload_0
            1: invokespecial #1 // Method java/lang/Object."<init>":()V
            4: return
    public static void main(java.lang.String[]);
            Code:
                0: iconst_1 // 将int类型值1⼊（操作数）栈
                1: istore_1 // 将栈顶int类型值保存到局部变量1中
                2: iload_1 // 从局部变量1中装载int类型值⼊栈
                3: iconst_1 // 将int类型值1⼊栈
                4: iadd // 将栈顶两int类型数相加，结果⼊栈
                5: i2s // 将栈顶int类型值截断成short类型值，后带符号扩展成int类型值⼊栈。
                6: istore_1 // 将栈顶int类型值保存到局部变量1中
                7: return
    }

可以看到字节码中包含了 i2s 指令，该指令⽤于将 int 转成 short。i2s 是 int to short 的缩写。 其实，s1 += 1 相当于 s1 = (short)(s1 + 1)，有兴趣的可以⾃⼰编译下这两⾏代码的字节码，你会发现 是⼀摸⼀样的。

1.4、基础考察 ，指出下题的输出结果

public static void main(String[] args) {
    Integer a = 128, b = 128, c = 127, d = 127;
    System.out.println(a == b);
    System.out.println(c == d);
}

答案是：false，true。 执⾏ Integer a = 128，相当于执⾏：Integer a = Integer.valueOf(128)，基本类型⾃动转换为包装类 的过程称为⾃动装箱（autoboxing）。

public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

在 Integer 中引⼊了 IntegerCache 来缓存⼀定范围的值，IntegerCache 默认情况下范围 为：-128~127。 本题中的 127 命中了 IntegerCache，所以 c 和 d 是相同对象，⽽ 128 则没有命中，所以 a 和 b 是不同对象。但是这个缓存范围时可以修改的，可能有些⼈不知道。可以通过JVM启动参数： -XX:AutoBoxCacheMax= 来修改上限值，如下图所⽰：

1.5、⽤最有效率的⽅法计算2乘以8？

2 << 3。(左移 相当于乘以2的⼏次幂 n << m 相当于n乘2的m次幂)

进阶：通常情况下，可以认为位运算是性能最⾼的。但是，其实编译器现在已经“⾮常聪明了”，很多指令编译器都能⾃⼰做优化。所以在实际实⽤中，我们⽆需特意去追求实⽤位运算，这样不仅会导 致代码可读性很差，⽽且某些⾃作聪明的优化反⽽会误导编译器，使得编译器⽆法进⾏更好的优化。

1.6、&和&&的区别？

&&：逻辑与运算符。当运算符左右两边的表达式都为 true，才返回 true。同时具有短路性，如果第 ⼀个表达式为 false，则直接返回 false。

static boolean f1() { System.out.println( "function f1 called." );         return true;
}
static boolean f2() { System.out.println( "function f2 called." );         return false; }
    if ( false && f1() ) {} // f1不会被调⽤
    if ( true || f2() ){} // f2不会被调⽤

&：逻辑与运算符、按位与运算符。

以开关开灯论： 有这样两个开关，0为开关关闭，1为开关打开。 与运算进⾏的是这样的算法： 0&0=0,0&1=0,1&0=0,1&1=1 在与运算中两个开关是串联的，如果我们要开灯，需要两个开关都打开灯才会打开。 理解为A 与B都打开，则开灯，所以是1&1=1,任意⼀个开关没打开，都不开灯，所以其他运算都是0。 按位与运算符：⽤于⼆进制的计算，只有对应的两个⼆进位均为1时，结果位才为1 ，否则为0。 逻辑与运算符：& 在⽤于逻辑与时，和 && 的区别是不具有短路性。所在通常使⽤逻辑与运算符都会 使⽤ &&，⽽ & 更多的适⽤于位运算

1.7、String 是 Java 基本数据类型吗？

答：不是。

Java 中的基本数据类型只有8个：byte、short、int、long、float、double、char、 boolean；除了基本类型（primitive type），剩下的都是引⽤类型（reference type）。 基本数据类型：数据直接存储在栈上 引⽤数据类型区别：数据存储在堆上，栈上只存储引⽤地址。

1.8、String 类可以继承吗？

不⾏。String 类使⽤ final 修饰，⽆法被继承。

1.9、String和StringBuilder、StringBuffer的区别？

String：String 的值被创建后不能修改，任何对 String 的修改都会引发新的 String 对象的⽣成。

StringBuffer：跟 String 类似，但是值可以被修改，使⽤ synchronized 来保证线程安全。

StringBuilder：StringBuffer 的⾮线程安全版本，没有使⽤ synchronized，具有更⾼的性能，推荐 优先使⽤

1.10、String s = new String(“xyz”) 创建了⼏个字符串对象？

⼀个或两个。

如果字符串常量池已经有“xyz”，则是⼀个；否则，两个。

当字符串常量池没有 “xyz”，此时会创建如下两个对象：

            1. ⼀个是字符串字⾯量 "xyz" 所对应的、驻留（intern）在⼀个全局共享的字符串常量池中的实例，此时该实例也是在堆中，字符串常量池只放引⽤。
            2.另⼀个是通过 new String() 创建并初始化的，内容与"xyz"相同的实例，也是在堆中

两个对象，一个是静态存储区的”xyz”,一个是用new创建在堆上的对象。

String类：表示不可改变的字符串，当前对象创建完毕之后，该对象的内容（字符序列）是不能改变的，一旦内容改变就是一个新的对象。

String对象的创建：
1）：直接赋一个字面量： String str1 = “ABCD”;
2）：通过构造器构造：String str = new String(“ABCD”);
————————————————
版权声明：本文为CSDN博主「成长的小牛233」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/dreamzuora/article/details/79464081

1.11、String s = “xyz” 和 String s = new String(“xyz”) 区别？

两个语句都会先去字符串常量池中检查是否已经存在 “xyz”，如果有则直接使⽤，如果没有则会在 常量池中创建 “xyz” 对象。

另外，String s = new String(“xyz”) 还会通过 new String() 在堆⾥创建⼀个内容与 “xyz” 相同的对象 实例。 所以前者其实理解为被后者的所包含。

1.12、== 和 equals 的区别是什么？

==：运算符，⽤于⽐较基础类型变量和引⽤类型变量。

对于基础类型变量，⽐较的变量保存的值是否相同，类型不⼀定要相同。

对于引⽤类型变量，⽐较的是两个对象的地址是否相同。

    short s1 = 1; long l1 = 1;
    // 结果：true。类型不同，但是值相同
    System.out.println(s1 == l1);

    Integer i1 = new Integer(1);
    Integer i2 = new Integer(1);
    // 结果：false。通过new创建，在内存中指向两个不同的对象
    System.out.println(i1 == i2);

equals：Object 类中定义的⽅法，通常⽤于⽐较两个对象的值是否相等。 equals 在 Object ⽅法中其实等同于 ==，但是在实际的使⽤中，equals 通常被重写⽤于⽐较两个对 象的值是否相同。

Integer i1 = new Integer(1);
Integer i2 = new Integer(1);
// 结果：true。两个不同的对象，但是具有相同的值
System.out.println(i1.equals(i2));
// Integer的equals重写⽅法
public boolean equals(Object obj) {
if (obj instanceof Integer) {
// ⽐较对象中保存的值是否相同
return value == ((Integer)obj).intValue();
}
return false;
}

1.13、两个对象的 hashCode() 相同，则 equals() 也⼀定为 true，对吗？

不对。hashCode() 和 equals() 之间的关系如下：

当有 a.equals(b) == true 时，则 a.hashCode() == b.hashCode() 必然成⽴，

反过来，当 a.hashCode() == b.hashCode() 时，a.equals(b) 不⼀定为 true

1.14、什么是反射？

反射是指在运⾏状态中，对于任意⼀个类都能够知道这个类所有的属性和⽅法；并且对于任意⼀个对 象，都能够调⽤它的任意⼀个⽅法；这种动态获取信息以及动态调⽤对象⽅法的功能称为反射机制。

反射涉及到四个核⼼类：

• java.lang.Class.java：类对象；

• java.lang.reflect.Constructor.java：类的构造器对象；

•java.lang.reflect.Method.java：类的⽅法对象；

• java.lang.reflect.Field.java：类的属性对象；

反射有什么⽤？

• 操作因访问权限限制的属性和⽅法；

• 实现⾃定义注解；

• 动态加载第三⽅jar包；

• 按需加载类，节省编译和初始化APK的时间；

反射⼯作原理

当我们编写完⼀个Java项⽬之后，每个java⽂件都会被编译成⼀个.class⽂件，这些Class对象承载了 这个类的所有信息，包括⽗类、接⼝、构造函数、⽅法、属性等，这些class⽂件在程序运⾏时会被 ClassLoader加载到虚拟机中。当⼀个类被加载以后，Java虚拟机就会在内存中⾃动产⽣⼀个Class对 象。我们通过new的形式创建对象实际上就是通过这些Class来创建，只是这个过程对于我们是不透 明的⽽已。

反射的⼯作原理就是借助Class.java、Constructor.java、Method.java、Field.java这四个类在程序 运⾏时动态访问和修改任何类的⾏为及状态。

1.15、深拷⻉和浅拷⻉区别是什么？

数据分为基本数据类型和引⽤数据类型。基本数据类型：数据直接存储在栈中；引⽤数据类型：存储 在栈中的是对象的引⽤地址，真实的对象数据存放在堆内存⾥。

            浅拷⻉：对于基础数据类型：直接复制数据值；对于引⽤数据类型：只是复制了对象的引⽤地址，新 旧对象指向同⼀个内存地址，修改其中⼀个对象的值，另⼀个对象的值随之改变。
           深拷⻉：对于基础数据类型：直接复制数据值；对于引⽤数据类型：开辟新的内存空间，在新的内存 空间⾥复制⼀个⼀模⼀样的对象，新⽼对象不共享内存，修改其中⼀个对象的值，不会影响另⼀个对 象。

深拷⻉相⽐于浅拷⻉速度较慢并且花销较⼤。 举个例⼦这就好⽐两兄弟⼤家买⾐服可以⼀⼈⼀套，然后房⼦⼤家住在⼀套房⼦⾥（浅拷⻉），当两 个⼈成家⽴业了，房⼦分开了⼀⼈⼀套互不影响（深拷⻉）

1.16、并发和并⾏有什么区别？

并发：两个或多个事件在同⼀时间间隔发⽣。

并⾏：两个或者多个事件在同⼀时刻发⽣。

并⾏是真正意义上，同⼀时刻做多件事情，⽽并发在同⼀时刻只会做⼀件事件，只是可以将时间切 碎，交替做多件事情。

并⾏在多处理器系统中存在，⽽并发可以在单处理器和多处理器系统中都存在，并发能够在单处理器 系统中存在是因为并发是并⾏的假象，并⾏要求程序能够同时执⾏多个操作，⽽并发只是要求程序假 装同时执⾏多个操作（每个⼩时间⽚执⾏⼀个操作，多个操作快速切换执⾏）。

当系统有⼀个以上 CPU 时，则线程的操作有可能⾮并发。当⼀个 CPU 执⾏⼀个线程时，另⼀个 CPU 可以执⾏另⼀个线程，两个线程互不抢占 CPU 资源，可以同时进⾏，这种⽅式我们称之为并⾏ （Parallel）。

并发编程的⽬标是充分的利⽤处理器的每⼀个核，以达到最⾼的处理性能

1.17、当⼀个对象被当作参数传递到⼀个⽅法后，此⽅法可改变这个对象 的属性，并可返回变化后的结果，那么这⾥到底是值传递还是引⽤传递？

值传递。Java 中只有值传递，对于对象参数，值的内容是对象的引⽤。

1.18、重载（Overload）和重写（Override）的区别？

⽅法的重载和重写都是实现多态的⽅式，区别在于前者实现的是编译时的多态性，⽽后者实现的是运 ⾏时的多态性。

重载：⼀个类中有多个同名的⽅法，但是具有有不同的参数列表（参数类型不同、参数个数不同或者 ⼆者都不同）。

重写：发⽣在⼦类与⽗类之间，⼦类对⽗类的⽅法进⾏重写，参数都不能改变，返回值类型可以不相 同，但是必须是⽗类返回值的派⽣类。即外壳不变，核⼼重写！重写的好处在于⼦类可以根据需要,定义特定于⾃⼰的⾏为。

1.19、构造器是否可被重写？

Constructor 不能被 override（重写），但是可以 overload（重载），所以你可以看到⼀个类中有多 个构造函数的情况

1.20、为什么不能根据返回类型来区分重载？

如果我们有两个⽅法如下，当我们调⽤：test(1) 时，编译器⽆法确认要调⽤的是哪个?

// ⽅法1
int test(int a);
// ⽅法2
long test(int a);

⽅法的返回值只是作为⽅法运⾏之后的⼀个“状态”，但是并不是所有调⽤都关注返回值，所以不能 将返回值作为重载的唯⼀区分条件。

1.21、Java 静态变量和成员变量的区别

public class Demo {
/**
* 静态变量：⼜称类变量，static修饰
*/
public static String STATIC_VARIABLE = "静态变量";
/**
* 实例变量：⼜称成员变量，没有static修饰
*/
public String INSTANCE_VARIABLE = "实例变量";
}

成员变量存在于堆内存中。静态变量存在于⽅法区中

成员变量与对象共存亡，随着对象创建⽽存在，随着对象被回收⽽释放。静态变量与类共存亡，随着 类的加载⽽存在，随着类的消失⽽消失。

成员变量所属于对象，所以也称为实例变量。静态变量所属于类，所以也称为类变量。

成员变量只能被对象所调⽤ 。静态变量可以被对象调⽤，也可以被类名调⽤

1.22、是否可以从⼀个静态（static）⽅法内部发出对⾮静态（nonstatic）⽅法的调⽤？

区分两种情况，发出调⽤时是否显⽰创建了对象实例。

1）没有显⽰创建对象实例：不可以发起调⽤，⾮静态⽅法只能被对象所调⽤，静态⽅法可以通过对 象调⽤，也可以通过类名调⽤，所以静态⽅法被调⽤时，可能还没有创建任何实例对象。因此通过静 态⽅法内部发出对⾮静态⽅法的调⽤，此时可能⽆法知道⾮静态⽅法属于哪个对象

public class Demo {
    public static void staticMethod() {
        // 直接调⽤⾮静态⽅法：编译报错
        instanceMethod();
}
public void instanceMethod() {
        System.out.println("⾮静态⽅法");
    }
}

2）显⽰创建对象实例：可以发起调⽤，在静态⽅法中显⽰的创建对象实例，则可以正常的调⽤。

public class Demo {
    public static void staticMethod() {
        // 先创建实例对象，再调⽤⾮静态⽅法：成功执⾏
        Demo demo = new Demo();
        demo.instanceMethod();
    }
    public void instanceMethod() {
        System.out.println("⾮静态⽅法");
    }
}

1.23、初始化考察，请指出下⾯程序的运⾏结果。

public class InitialTest {
    public static void main(String[] args) {
        A ab = new B();
        ab = new B();
    }
}
class A {
    static { // ⽗类静态代码块
        System.out.print("A");
}
public A() { // ⽗类构造器
        System.out.print("a");
    }
}
class B extends A {
    static { // ⼦类静态代码块
        System.out.print("B");
}
public B() { // ⼦类构造器
        System.out.print("b");
    }
}

执⾏结果：ABabab，两个考察点：

1）静态变量只会初始化（执⾏）⼀次。

2）当有⽗类时，完整的初始化顺序为：⽗类静态变量（静态代码块）->⼦类静态变量（静态代码 块）->⽗类⾮静态变量（⾮静态代码块）->⽗类构造器 ->⼦类⾮静态变量（⾮静态代码块）->⼦类构 造器 。

1.24、抽象类（abstract class）和接⼝（interface）有什么区别

1）抽象类只能单继承，接⼝可以多实现。

2）抽象类可以有构造⽅法，接⼝中不能有构造⽅法。

3）抽象类中可以有成员变量，接⼝中没有成员变量，只能有常量（默认就是 public static final）

4）抽象类中可以包含⾮抽象的⽅法，在 Java 7 之前接⼝中的所有⽅法都是抽象的，在 Java 8 之 后，接⼝⽀持⾮抽象⽅法：default ⽅法、静态⽅法等。Java 9 ⽀持私有⽅法、私有静态⽅法。

5）抽象类中的抽象⽅法类型可以是任意修饰符，Java 8 之前接⼝中的⽅法只能是 public 类型，Java 9 ⽀持 private 类型。

设计思想的区别：

接⼝是⾃上⽽下的抽象过程，接⼝规范了某些⾏为，是对某⼀⾏为的抽象。我需要这个⾏为，我就去 实现某个接⼝，但是具体这个⾏为怎么实现，完全由⾃⼰决定。

抽象类是⾃下⽽上的抽象过程，抽象类提供了通⽤实现，是对某⼀类事物的抽象。我们在写实现类的 时候，发现某些实现类具有⼏乎相同的实现，因此我们将这些相同的实现抽取出来成为抽象类，然后 如果有⼀些差异点，则可以提供抽象⽅法来⽀持⾃定义实现。

⽹上看到有个说法，挺形象的： 普通类像亲爹 ，他有啥都是你的。 抽象类像叔伯，有⼀部分会给你，还能指导你做事的⽅法。 接⼝像⼲爹，可以给你指引⽅法，但是做成啥样得你⾃⼰努⼒实现

1.25、Java 中的 final 关键字有哪些⽤法？

修饰类：该类不能再派⽣出新的⼦类，不能作为⽗类被继承。因此，⼀个类不能同时被声明为 abstract 和 final。

修饰⽅法：该⽅法不能被⼦类重写。

修饰变量：该变量必须在声明时给定初值，⽽在以后只能读取，不可修改。 如果变量是对象，则指的 是引⽤不可修改，但是对象的属性还是可以修改的

public class FinalDemo {
    // 不可再修改该变量的值
    public static final int FINAL_VARIABLE = 0;
    // 不可再修改该变量的引⽤，但是可以直接修改属性值
    public static final User USER = new User();
    public static void main(String[] args) {
        // 输出：User(id=0, name=null, age=0)
        System.out.println(USER);
        // 直接修改属性值
        USER.setName("test");
        // 输出：User(id=0, name=test, age=0)
        System.out.println(USER);
    }
}

1.26、阐述 final、finally、finalize 的区别。

其实是三个完全不相关的东西，只是⻓的有点像。

final : 最终的。

finally：finally 是对 Java 异常处理机制的最佳补充，通常配合 try、catch 使⽤，⽤于存放那些⽆论 是否出现异常都⼀定会执⾏的代码。在实际使⽤中，通常⽤于释放锁、数据库连接等资源，把资源释放⽅法放到 finally 中，可以⼤⼤降低程序出错的⼏率。

finalize：Object 中的⽅法，在垃圾收集器将对象从内存中清除出去之前做必要的清理⼯作。 finalize()⽅法仅作为了解即可，在 Java 9 中该⽅法已经被标记为废弃，并添加新的 java.lang.ref.Cleaner，提供了更灵活和有效的⽅法来释放资源。这也侧⾯说明了，这个⽅法的设计 是失败的，因此更加不能去使⽤它。

1.27、try、catch、finally 考察，请指出下⾯程序的运⾏结果（1）

public class TryDemo {
    public static void main(String[] args) {
        System.out.println(test());
    }
    public static int test() {
        try {
            return 1;
        } catch (Exception e) {
            return 2;
    } finally {
        System.out.print("3");
        }
    }
}

执⾏结果：31。

相信很多同学应该都做对了，try、catch。finally 的基础⽤法，在 return 前会先执⾏ finally 语句 块，所以是先输出 finally ⾥的 3，再输出 return 的 1

1.28、try、catch、finally 考察，请指出下⾯程序的运⾏结果（2）

public class TryDemo {
    public static void main(String[] args) {
        System.out.println(test1());
    }
    public static int test1() {
        try {
            return 2;
        } finally {
            return 3;
        }
    }
}

执⾏结果：3。

这题有点意思，但也不难，try 返回前先执⾏ finally，结果 finally ⾥不按套路出牌，直接 return 了， ⾃然也就⾛不到 try ⾥⾯的 return 了

finally ⾥⾯使⽤ return 仅存在于⾯试题中，实际开发中千万不要这么⽤

1.29、try、catch、finally 考察3，请指出下⾯程序的运⾏结果（3）

public class TryDemo {
    public static void main(String[] args) {
        System.out.println(test1());
    }
    public static int test1() {
        int i = 0;
        try {
            i = 2;
            return i;
        } finally {
            i = 3;
        }
    }
}

执⾏结果：2。

这边估计有不少同学会以为结果应该是 3，因为我们知道在 return 前会执⾏ finally，⽽ i 在 finally 中 被修改为 3 了，那最终返回 i 不是应该为 3 吗？

这边的根本原因是，在执⾏ finally 之前，JVM 会先将 i 的结果暂存起来，然后 finally 执⾏完毕后， 会返回之前暂存的结果，⽽不是返回 i，所以即使这边 i 已经被修改为 3，最终返回的还是之前暂存起 来的结果 2。

这边其实根据字节码可以很容易看出来，在进⼊ finally 之前，JVM 会使⽤ iload、istore 两个指令， 将结果暂存，在最终返回时在通过 iload、ireturn 指令返回暂存的结果。

1.30、Error 和 Exception 有什么区别？

Error 和 Exception 都是 Throwable 的⼦类，⽤于表⽰程序出现了不正常的情况。区别在于： Error 表⽰系统级的错误和程序不必处理的异常，是恢复不是不可能但很困难的情况下的⼀种严重问 题，⽐如内存溢出，不可能指望程序能处理这样的情况

Exception 表⽰需要捕捉或者需要程序进⾏处理的异常，是⼀种设计或实现问题，也就是说，它表⽰ 如果程序运⾏正常，从不会发⽣的情况。

1.31、JDK1.8之后有哪些新特性？

1）接⼝默认⽅法：Java 8 允许我们给接⼝添加⼀个⾮抽象的⽅法实现，只需要使⽤ default 关键字 即可。

从Java 8开始，引⼊了接⼝默认⽅法，这样的好处也是很明显的，⾸先解决了 Java8 以前版本接⼝兼 容性问题，同时对于我们以后的程序开发，也可以在接⼝⼦类中直接使⽤接⼝默认⽅法，⽽不再需要 在各个⼦类中各⾃实现响应接⼝⽅法。

public interface IMathOperation {
    /**
    * 定义接⼝默认⽅法 ⽀持⽅法形参
    */
    default void print(){
        System.out.println("这是数值运算基本接⼝。。。");
    }
    /**
    * 定义静态默认⽅法
    */
    static void version(){
        System.out.println("这是1.0版简易计算器");
    }
}

public class MathOperationImpl implements IMathOperation {
    @Override
    public int add(int a, int b) {
        // ⼦类中可以直接调⽤⽗类接⼝默认⽅法
        IMathOperation.super.print();
        // 调⽤⽗类静态默认⽅法
        IMathOperation.version();
        return a+b;
    }
}

2）Lambda 表达式和函数式接⼝：Lambda 表达式本质上是⼀段匿名内部类，也可以是⼀段可以传 递的代码。Lambda 允许把函数作为⼀个⽅法的参数（函数作为参数传递到⽅法中），使⽤ Lambda 表达式使代码更加简洁，但是也不要滥⽤，否则会有可读性等问题，《Effective Java》作者 Josh Bloch 建议使⽤ Lambda 表达式最好不要超过3⾏。

匿名内部类

@Test
public void test1(){
    Comparator<Integer> com = new Comparator<Integer>() {
        @Override
        public int compare(Integer o1, Integer o2) {
            return Integer.compare(o1, o2);
        }
    };
    TreeSet<Integer> treeSet = new TreeSet<>(com);
}

Lambda 表达式

Comparator<Integer> com = (x, y) -> Integer.compare(x, y)

函数式接⼝

Lambda表达式需要函数式接⼝的⽀持，所以，我们有必要来说说什么是函数式接⼝。 只包含⼀个抽象⽅法的接⼝，称为函数式接⼝。 可以通过 Lambda 表达式来创建该接⼝的对 象。（若 Lambda表达式抛出⼀个受检异常，那么该异常需要在⽬标接⼝的抽象⽅法上进⾏声明）。 可以在任意函数式接⼝上使⽤ @FunctionalInterface 注解，这样做可以检查它是否是⼀个函数式接 ⼝，同时 javadoc 也会包含⼀条声明，说明这个接⼝是⼀个函数式接⼝

@FunctionalInterface
public interface MyFunc <T> {
    public T getValue(T t);
}
public String handlerString(MyFunc<String> myFunc, String str){
    return myFunc.getValue(str);
}
@Test
public void test6(){
    String str = handlerString((s) -> s.toUpperCase(), "binghe");
    System.out.println(str);//输出结果BINGHE
}

3）Stream API：⽤函数式编程⽅式在集合类上进⾏复杂操作的⼯具，配合Lambda表达式可以⽅便 的对集合进⾏处理。Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进⾏的操作，可以 执⾏⾮常复杂的查找、过滤和映射数据等操作。使⽤Stream API 对集合数据进⾏操作，就类似于使 ⽤ SQL 执⾏的数据库查询。也可以使⽤ Stream API 来并⾏执⾏操作。简⽽⾔之，Stream API 提供了 ⼀种⾼效且易于使⽤的处理数据的⽅式

List<Teacher> teacherList = new ArrayList<>();
teacherList.add(new Teacher("张磊",22,"zl"));
teacherList.add(new Teacher("李鹏",36,"lp"));
teacherList.add(new Teacher("刘敏",50,"lm"));
teacherList.add(new Teacher("宋亚楠",62,"syn"));
teacherList.add(new Teacher("彩彬",18,"cb"));
//filter 过滤
List<Teacher> list = teacherList.stream().filter(x -> x.getAge() > 30).collect
(Collectors.toList());
//joining拼接 所有⽼师姓名拼接成字符串
String nameJoin = teacherList.stream().map(Teacher::getName).collect(Collector
s.joining(","));
//排序
List sortList = teacherList.stream().sorted(Comparator.comparing(Teacher::getAg
e).reversed()).collect(Collectors.toList());
System.out.println(nameJoin);
System.out.println(list);
System.out.println("按年龄降序: "+sortList)
    /*输出结果
    *[Teacher(name=李鹏, age=36, nikeName=lp), Teacher(name=刘敏,         age=50,
    nikeName=lm), Teacher(name=宋亚楠, *age=62, nikeName=syn)]
    *张磊,李鹏,刘敏,宋亚楠,彩彬
    *按年龄降序: [Teacher(name=宋亚楠, age=62, nikeName=syn),             Teacher(name=刘敏,
    age=50, nikeName=lm), *Teacher(name=李鹏, age=36, nikeName=lp),         Teacher(name=
    张磊, age=22, nikeName=zl), Teacher(name=彩彬, age=18,                 nikeName=cb)]
    */

4）⽅法引⽤：⽅法引⽤提供了⾮常有⽤的语法，可以直接引⽤已有Java类或对象（实例）的⽅法或构造器。与lambda联合使⽤，⽅法引⽤可以使语⾔的构造更紧凑简洁，减少冗余代码。

⽅法引⽤就是操作符“::”将⽅法名和对象或类的名字分隔开来

。 如下三种使⽤情况：

                              • 对象::实例⽅法
                              • 类::静态⽅法
                              • 类::实例⽅法

(x) -> System.out.println(x);//等同于 System.out::println
BinaryOperator<Double> bo = (x, y) -> Math.pow(x, y);//等同于 BinaryOperator<Dou
ble> bo = Math::pow;

5）⽇期时间API：Java 8 引⼊了新的⽇期时间API改进了⽇期时间的管理。在Java 8之前，所有关于 时间和⽇期的API都存在各种使⽤⽅⾯的缺陷，主要有：

    Java的java.util.Date和java.util.Calendar类易⽤性差，不⽀持时区，⽽且他们都不是线程安全 的；
    ⽤于格式化⽇期的类DateFormat被放在java.text包中，它是⼀个抽象类，所以我们需要实例化 ⼀个SimpleDateFormat对象来处理⽇期格式化，并且DateFormat也是⾮线程安全，这意味着 如果你在多线程程序中调⽤同⼀个DateFormat对象，会得到意想不到的结果。

   对⽇期的计算⽅式繁琐，⽽且容易出错，因为⽉份是从0开始的，从Calendar中获取的⽉份 需要加⼀才能表⽰当前⽉份。 i. 由于以上这些问题，出现了⼀些三⽅的⽇期处理框架，例如Joda-Time，date4j等开源项⽬。但是， Java需要⼀套标准的⽤于处理时间和⽇期的框架，于是Java 8中引⼊了新的⽇期API。新的⽇期API是 JSR-310规范的实现，Joda-Time框架的作者正是JSR-310的规范的倡导者，所以能从Java 8的⽇期 API中看到很多Joda-Time的特性。 Java 8的⽇期和时间类包含LocalDate 、 LocalTime 、 Instant 、 Duration 以及 Period ，这些类都包含在 java.time 包中，下⾯我们看看这些类的⽤法

6）Optional 类：著名的 NullPointerException 是引起系统失败最常⻅的原因。很久以前 Google Guava 项⽬引⼊了 Optional 作为解决空指针异常的⼀种⽅式，不赞成代码被 null 检查的代码污染， 期望程序员写整洁的代码。受Google Guava的⿎励，Optional 现在是Java 8库的⼀部分。

7）新⼯具：新的编译⼯具，如：Nashorn引擎 jjs、 类依赖分析器 jdeps。

1.32、Java的多态表现在哪里

多态要有动态绑定,否则就不是多态,⽅法重载也不是多态(因为⽅法重载是编译期决定好的,没有后期也 就是运⾏期的动态绑定) 当满⾜这三个条件 1.有继承 2. 有重写 3. 要有⽗类引⽤指向⼦类对象

1.33、接⼝有什么用

1、重要性：在Java语⾔中， abstract class 和interface 是⽀持抽象类定义的两种机制。正是由于这 两种机制的存在，才赋予了Java强⼤的 ⾯向对象能⼒。

2、简单、规范性：如果⼀个项⽬⽐较庞⼤，那么就需要⼀个能理清所有业务的架构师来定义⼀些主 要的接⼝，这些接⼝不仅告诉开发⼈员你需要实现那些业务，⽽且也将命名规范限制住了（防⽌⼀些 开发⼈员随便命名导致别的程序员⽆法看明⽩）。

3、维护、拓展性：⽐如你要做⼀个画板程序，其中⾥⾯有⼀个⾯板类，主要负责绘画功能，然后你 就这样定义了这个类。

可是在不久将来，你突然发现这个类满⾜不了你了，然后你⼜要重新设计这个类，更糟糕是你可能要 放弃这个类，那么其他地⽅可能有引⽤他，这样修改起来很⿇烦。

如果你⼀开始定义⼀个接⼝，把绘制功能放在接⼝⾥，然后定义类时实现这个接⼝，然后你只要⽤这 个接⼝去引⽤实现它的类就⾏了，以后要换的话只不过是引⽤另⼀个类⽽已，这样就达到维护、拓展 的⽅便性。

4、安全、严密性：接⼝是实现软件松耦合的重要⼿段，它描叙了系统对外的所有服务，⽽不涉及任何具体的实现细节。这样就⽐较安全、严密⼀些（⼀般软件服务商考虑的⽐较多）

1.34、说说http,https协议

HTTPS（Secure Hypertext Transfer Protocol）安全超⽂本传输协议：

它是⼀个安全通信通道，它基于HTTP开发，⽤于在客⼾计算机和服务器之间交换信息，它使⽤安全套接字层(SSL)进⾏信息交换，简单来说它是HTTP的安全版。

它是由Netscape开发并内置于其浏览器中，⽤于对数据进⾏压缩和解压操作，并返回⽹络上传送回 的结果。HTTPS实际上应⽤了Netscape的安全全套接字层（SSL）作为HTTP应⽤层的⼦层.（HTTPS使⽤端⼝443，⽽不是像HTTP那样使⽤端⼝80来和TCP/IP进⾏通信。）SSL使⽤40 位关键字作为RC4流加密算法，这对于商业信息的加密是合适的。

HTTPS和SSL⽀持使⽤X.509数字认证，如果需要的话⽤⼾可以确认发送者是谁。总的来说，HTTPS 协议是由SSL+HTTP协议构建的可进⾏加密传输、⾝份认证的⽹络协议要⽐http协议安全。

在URL前加https://前缀表明是⽤SSL加密的，你的电脑与服务器之间收发的信息传输将更加安全。 Web服务器启⽤SSL需要获得⼀个服务器证书并将该证书与要使⽤SSL的服务器绑定。

HTTPS和HTTP的区别：

https协议需要到ca申请证书，⼀般免费证书很少，需要交费。

http是超⽂本传输协议，信息是明⽂传输，https 则是具有安全性的ssl加密传输协议。

http和https使⽤的是完全不同的连接⽅式⽤的端⼝也不⼀样,前者是80,后者是443。

http的连接很简单,是⽆状态的。

HTTPS协议是由SSL+HTTP协议构建的可进⾏加密传输、⾝份认证的⽹络协议 要⽐http协议安全。

HTTPS解决的问题：

1 . 信任主机的问题

采⽤https 的server 必须从CA 申请⼀个⽤于证明服务器⽤途类型的证书. 该证书只有⽤于对应的 server 的时候,客⼾端才信任此主机. 所以⽬前所有的银⾏系统⽹站,关键部分应⽤都是https 的.

客⼾通过信任该证书,从⽽信任了该主机. 其实这样做效率很低,但是银⾏更侧重安全. 这⼀点对我们 没有任何意义,我们的server ,采⽤的证书不管⾃⼰issue 还是从公众的地⽅issue, 客⼾端都是⾃⼰⼈, 所以我们也就肯定信任该server.

2 . 通讯过程中的数据的泄密和被窜改

1. ⼀般意义上的https, 就是 server 有⼀个证书.
2. 主要⽬的是保证server 就是他声称的server. 这个跟第⼀点⼀样. b) 服务端和客⼾端之间的所有通讯,都是加密的.
3. 具体讲,是客⼾端产⽣⼀个对称的密钥,通过server 的证书来交换密钥. ⼀般意义上的握⼿过程.
4. 所有的信息往来就都是加密的. 第三⽅即使截获,也没有任何意义.因为他没有密钥. 当然窜改也 就没有什么意义了.

2). 少许对客⼾端有要求的情况下,会要求客⼾端也必须有⼀个证书.

a) 这⾥客⼾端证书,其实就类似表⽰个⼈信息的时候,除了⽤⼾名/密码, 还有⼀个CA 认证过的⾝份. 应为个⼈证书⼀般来说别⼈⽆法模拟的,所有这样能够更深的确认⾃⼰的⾝份.

b) ⽬前少数个⼈银⾏的专业版是这种做法,具体证书可能是拿U盘作为⼀个备份的载体.

3 .HTTPS ⼀定是繁琐的. a) 本来简单的http协议,⼀个get⼀个response. 由于https 要还密钥和确认加密算法的需要.单握⼿就需要6/7 个往返.

i. 任何应⽤中,过多的round trip 肯定影响性能.

b) 接下来才是具体的http协议,每⼀次响应或者请求, 都要求客⼾端和服务端对会话的内容做加密/解 密.

i. 尽管对称加密/解密效率⽐较⾼,可是仍然要消耗过多的CPU,为此有专⻔的SSL 芯⽚. 如果CPU性能⽐较低的话,肯定会降低性能,从⽽不能为serve 更多的请求.

ii. 加密后数据量的影响. 所以，才会出现那么多的安全认证提⽰

1.35、tcp/ip协议簇

TCP/IP协议簇是Internet的基础，也是当今最流⾏的组⽹形式。TCP/IP是⼀组协议的代名词，包括许多别的协议，组成了TCP/IP协议簇。

其中⽐较重要的有SLIP协议、PPP协议、IP协议、ICMP协议、ARP协议、TCP协议、UDP协议、FTP 协议、DNS协议、SMTP协议等。TCP/IP协议并不完全符合OSI的七层参考模型。

传统的开放式系统互连参考模型，是⼀种通信协议的7层抽象的参考模型，其中每⼀层执⾏某⼀特定 任务。该模型的⽬的是使各种硬件在相同的层次上相互通信。

⽽TCP/IP通讯协议采⽤了4层的层级结构，每⼀层都呼叫它的下⼀层所提供的⽹络来完成⾃⼰的需求

SLIP协议编辑

SLIP提供在串⾏通信线路上封装IP分组的简单⽅法，使远程⽤⼾通过电话线和MODEM能⽅便地接⼊ TCP/IP⽹络。SLIP是⼀种简单的组帧⽅式，但使⽤时还存在⼀些问题。

⾸先，SLIP不⽀持在连接过程中的动态IP地址分配，通信双⽅必须事先告知对⽅IP地址，这给没有固 定IP地址的个⼈⽤⼾上INTERNET⽹带来了很⼤的不便。

其次，SLIP帧中⽆校验字段，因此链路层上⽆法检测出差错，必须由上层实体或具有纠错能⼒ MODEM来解决传输差错问题。

PPP协议编辑 为了解决SLIP存在的问题，在串⾏通信应⽤中⼜开发了PPP协议。PPP协议是⼀种有效的点对点通信 协议，它由串⾏通信线路上的组帧⽅式，⽤于建⽴、配制、测试和拆除数据链路的链路控制协议LCP 及⼀组⽤以⽀持不同⽹络层协议的⽹络控制协议NCPs三部分组成。 PPP中的LCP协议提供了通信双⽅进⾏参数协商的⼿段，并且提供了⼀组NCPs协议，使得PPP可以⽀ 持多种⽹络层协议，如IP,IPX,OSI等。另外，⽀持IP的NCP提供了在建⽴链接时动态分配IP地址的功 能，解决了个⼈⽤⼾上INTERNET⽹的问题。

IP协议编辑

即互联⽹协议(Internet Protocol)，它将多个⽹络连成⼀个互联⽹，可以把⾼层的数据以多个数据包 的形式通过互联⽹分发出去。IP的基本任务是通过互联⽹传送数据包，各个IP数据包之间是相互独⽴ 的。

ICMP协议编辑

即互联⽹控制报⽂协议。从IP互联⽹协议的功能，可以知道IP 提供的是⼀种不可靠的⽆连接报⽂分组 传送服务。

若路由器或主机发⽣故障时⽹络阻塞，就需要通知发送主机采取相应措施。为了使互联⽹能报告差 错，或提供有关意外情况的信息，在IP层加⼊了⼀类特殊⽤途的报⽂机制，即ICMP。

分组接收⽅利⽤ICMP来通知IP模块发送⽅，进⾏必需的修改。ICMP通常是由发现报⽂有问题的站产 ⽣的，例如可由⽬的主机或中继路由器来发现问题并产⽣的ICMP。

如果⼀个分组不能传送，ICMP便可以被⽤来警告分组源，说明有⽹络，主机或端⼝不可达。ICMP也 可以⽤来报告⽹络阻塞。

ARP协议编辑

即地址转换协议。在TCP/IP⽹络环境下，每个主机都分配了⼀个32位的IP地址，这种互联⽹地址是在 ⽹际范围标识主机的⼀种逻辑地址。为了让报⽂在物理⽹上传送，必须知道彼此的物理地址。

这样就存在把互联⽹地址变换成物理地址的转换问题。这就需要在⽹络层有⼀组服务将 IP地址转换为 相应物理⽹络地址，这组协议即ARP。

TCP协议编辑

即传输控制协议，它提供的是⼀种可靠的数据流服务。当传送受差错⼲扰的数据，或举出⽹络故障， 或⽹络负荷太重⽽使⽹际基本传输系统不能正常⼯作时，就需要通过其他的协议来保证通信的可靠。

TCP就是这样的协议。TCP采⽤“带重传的肯定确认”技术来实现传输的可靠性。并使⽤“滑动窗 ⼝”的流量控制机制来提⾼⽹络的吞吐量。TCP通信建⽴实现了⼀种“虚电路”的概念。

双⽅通信之前，先建⽴⼀条链接然后双⽅就可以在其上发送数据流。这种数据交换⽅式能提⾼效率， 但事先建⽴连接和事后拆除连接需要开销。

UDP协议编辑

即⽤⼾数据包协议，它是对IP协议组的扩充，它增加了⼀种机制，发送⽅可以区分⼀台计算机上的多 个接收者。每个UDP报⽂除了包含数据外还有报⽂的⽬的端⼝的编号和报⽂源端⼝的编号，从⽽使 UDP软件可以把报⽂递送给正确的接收者，然后接收者要发出⼀个应答。

由于UDP的这种扩充，使得在两个⽤⼾进程之间递送数据包成为可能。我们频繁使⽤的OICQ软件正 是基于UDP协议和这种机制。

FTP协议编辑

即⽂件传输协议，它是⽹际提供的⽤于访问远程机器的协议，它使⽤⼾可以在本地机与远程机之间进 ⾏有关⽂件的操作。FTP⼯作时建⽴两条TCP链接，分别⽤于传送⽂件和⽤于传送控制。

FTP采⽤客⼾/服务器模式?它包含客⼾FTP和服务器FTP。客⼾FTP启动传送过程，⽽服务器FTP对其 作出应答。

DNS协议编辑

即域名服务协议，它提供域名到IP地址的转换，允许对域名资源进⾏分散管理。DNS最初设计的⽬的 是使邮件发送⽅知道邮件接收主机及邮件发送主机的IP地址，后来发展成可服务于其他许多⽬标的协 议

SMTP协议编辑

即简单邮件传送协议互联⽹标准中的电⼦邮件是⼀个简单的基于⽂本的协议，⽤于可靠、有效地数据 传输。SMTP作为应⽤层的服务，并不关⼼它下⾯采⽤的是何种传输服务，

它可通过⽹络在TXP链接上传送邮件，或者简单地在同⼀机器的进程之间通过进程通信的通道来传送 邮件，这样，邮件传输就独⽴于传输⼦系统，可在TCP/IP环境或X.25协议环境中传输邮件

1.36、tcp，udp区别

TCP（Transmission Control Protocol，传输控制协议）是⾯向连接的协议，也就是说，在收发数据 前，必须和对⽅建⽴可靠的连接。⼀个TCP连接必须要经过三次“对话”才能建⽴起来，其中的过程 ⾮常复杂，只简单的描述下这三次对话的简单过程：

主机A向主机B发出连接请求数据包：“我想给你发数据，可以吗？”，这是第⼀次对话；主机B向主 机A发送同意连接和要求同步（同步就是两台主机⼀个在发送，⼀个在接收，协调⼯作）的数据 包：“可以，你什么时候发？”，这是第⼆次对话；

主机A再发出⼀个数据包确认主机B的要求同步：“我现在就发，你接着吧！”，这是第三次对话。三 次“对话”的⽬的是使数据包的发送和接收同步，经过三次“对话”之后，主机A才向主机B正式发送 数据

UDP（User Data Protocol，⽤⼾数据报协议）

（1） UDP是⼀个⾮连接的协议，传输数据之前源端和终端不建⽴连接，当它想传送时就简单地去抓 取来⾃应⽤程序的数据，并尽可能快地把它扔到⽹络上。

在发送端，UDP传送数据的速度仅仅是受应⽤程序⽣成数据的速度、计算机的能⼒和传输带宽的限 制；在接收端，UDP把每个消息段放在队列中，应⽤程序每次从队列中读⼀个消息段。

（2） 由于传输数据不建⽴连接，因此也就不需要维护连接状态，包括收发状态等，因此⼀台服务机 可同时向多个客⼾机传输相同的消息。

（3） UDP信息包的标题很短，只有8个字节，相对于TCP的20个字节信息包的额外开销很⼩。

（4） 吞吐量不受拥挤控制算法的调节，只受应⽤软件⽣成数据的速率、传输带宽、源端和终端主机 性能的限制。

（5）UDP使⽤尽最⼤努⼒交付，即不保证可靠交付，因此主机不需要维持复杂的链接状态表（这⾥ ⾯有许多参数）。

（6）UDP是⾯向报⽂的。发送⽅的UDP对应⽤程序交下来的报⽂，在添加⾸部后就向下交付给IP 层。既不拆分，也不合并，⽽是保留这些报⽂的边界，因此，应⽤程序需要选择合适的报⽂⼤⼩。

我们经常使⽤“ping”命令来测试两台主机之间TCP/IP通信是否正常，其实“ping”命令的原理就是 向对⽅主机发送UDP数据包，然后对⽅主机确认收到数据包，如果数据包是否到达的消息及时反馈回 来，那么⽹络就是通的。

UDP的包头结构：

源端⼝ 16位

⽬的端⼝ 16位

⻓度 16位

校验和 16位

⼩结: TCP与UDP的区别：

1 .基于连接与⽆连接；

2 .对系统资源的要求（TCP较多，UDP少）；

3 .UDP程序结构较简单；

4 .流模式与数据报模式 ；

5 .TCP保证数据正确性，UDP可能丢包，TCP保证数据顺序，UDP不保证

1.37、⽤过哪些加密算法：对称加密，⾮对称加密算法

对称加密是最快速、最简单的⼀种加密⽅式，加密（encryption）与解密（decryption）⽤的是同样 的密钥（secret key）。对称加密有很多种算法，由于它效率很⾼，所以被⼴泛使⽤在很多加密协议 的核⼼当中。

对称加密通常使⽤的是相对较⼩的密钥，⼀般⼩于256 bit。因为密钥越⼤，加密越强，但加密与解密 的过程越慢。如果你只⽤1 bit来做这个密钥，那⿊客们可以先试着⽤0来解密，不⾏的话就再⽤1解；

但如果你的密钥有1 MB⼤，⿊客们可能永远也⽆法破解，但加密和解密的过程要花费很⻓的时间。密 钥的⼤⼩既要照顾到安全性，也要照顾到效率，是⼀个trade-off

常⻅对称加密算法 DES算法，3DES算法，TDEA算法，Blowfish算法，RC5算法，IDEA算法 ⾮对称加密为数据的加密与解密提供了⼀个⾮常安全的⽅法，它使⽤了⼀对密钥，公钥（public key）和私钥（private key）。

私钥只能由⼀⽅安全保管，不能外泄，⽽公钥则可以发给任何请求它的⼈。⾮对称加密使⽤这对密钥 中的⼀个进⾏加密，⽽解密则需要另⼀个密钥。

⽐如，你向银⾏请求公钥，银⾏将公钥发给你，你使⽤公钥对消息加密，那么只有私钥的持有⼈—银 ⾏才能对你的消息解密。与对称加密不同的是，银⾏不需要将私钥通过⽹络发送出去，因此安全性⼤ ⼤提⾼。

⽬前最常⽤的⾮对称加密算法是RSA算法 Elgamal、背包算法、Rabin、HD,ECC（椭圆曲线加密算 法）

1.38、说说tcp三次握⼿，四次挥⼿

据段:”我已收到回复,我现在要开始传输实际数据了

这样3次握⼿就完成了,主机A和主机B 就可以传输数据了.

3次握⼿的特点

没有应⽤层的数据

SYN这个标志位只有在TCP建产连接时才会被置1

握⼿完成后SYN标志位被置0

TCP建⽴连接要进⾏3次握⼿,⽽断开连接要进⾏4次

1 当主机A完成数据传输后,将控制位FIN置1,提出停⽌TCP连接的请求

2 主机B收到FIN后对其作出响应,确认这⼀⽅向上的TCP连接将关闭,将ACK置1

3 由B 端再提出反⽅向的关闭请求,将FIN置1

4 主机A对主机B的请求进⾏确认,将ACK置1,双⽅向的关闭结束.

由TCP的三次握⼿和四次断开可以看出,TCP使⽤⾯向连接的通信⽅式,⼤⼤提⾼了数据通信的可靠性, 使发送数据端

和接收端在数据正式传输前就有了交互,为数据正式传输打下了可靠的基础

名词解释

ACK TCP报头的控制位之⼀,对数据进⾏确认.确认由⽬的端发出,⽤它来告诉发送端这个序列号之前的 数据段 都收到了

.⽐如,确认号为X,则表⽰前X-1个数据段都收到了,只有当ACK=1时,确认号才有效,当ACK=0时, 确认号⽆效,这时会要求重传数据,保证数据的完整性.

SYN 同步序列号,TCP建⽴连接时将这个位置1

FIN 发送端完成发送任务位,当TCP完成数据传输需要断开时,提出断开连接的⼀⽅将这位置1

TCP的包头结构：

源端⼝ 16位

⽬标端⼝ 16位

序列号 32位

回应序号 32位

TCP头⻓度 4位

reserved 6位

控制代码 6位

窗⼝⼤⼩ 16位

偏移量 16位

校验和 16位

选项 32位(可选)

这样我们得出了TCP包头的最⼩⻓度，为20字节

1.40、cookie和session的区别，分布式环境怎么保存用户状态

1、session保存在服务器，客⼾端不知道其中的信息；cookie保存在客⼾端，服务器能够知道其中的 信息。

2、session中保存的是对象，cookie中保存的是字符串。

3、session不能区分路径，同⼀个⽤⼾在访问⼀个⽹站期间，所有的session在任何⼀个地⽅都可以 访问到。⽽cookie中如果设置了路径参数，那么同⼀个⽹站中不同路径下的cookie互相是访问不到 的。

4、session需要借助cookie才能正常。如果客⼾端完全禁⽌cookie，session将失效。 分布式Session的⼏种实现⽅式

• 1 .基于数据库的Session共享

• 2 .基于NFS共享⽂件系统

• 3 .基于memcached 的session，如何保证 memcached 本⾝的⾼可⽤性？

• 4 . 基于resin/tomcat web容器本⾝的session复制机制

• 5 . 基于TT/Redis 或 jbosscache 进⾏ session 共享。

• 6 . 基于cookie 进⾏session共享

1.41、Git，svn区别

GIT是分布式的，SVN不是：这是GIT和其它⾮分布式的版本控制系统，例如SVN，CVS等，最核⼼的 区

GIT把内容按元数据⽅式存储，⽽SVN是按⽂件

GIT分⽀和SVN的分⽀不同：

分⽀在SVN中⼀点不特别，就是版本库中的另外的⼀个⽬录。如果你想知道是否合并了⼀个分⽀，你 需要⼿⼯运⾏像这样的命令svn propget svn:mergeinfo，来确认代码是否被合并。

然⽽，处理GIT的分⽀却是相当的简单和有趣。你可以从同⼀个⼯作⽬录下快速的在⼏个分⽀间切 换。你很容易发现未被合并的分⽀，你能简单⽽快捷的合并这些⽂件

GIT没有⼀个全局的版本号，⽽SVN有

GIT的内容完整性要优于SVN

1.42、ThreadLocal可以⽤来共享数据吗

ThreadLocal是基于线程对象的,类似于⼀个map ,key为当前线程对象,所以它可以在同线程内共享数 据

1.43、bio，nio，aio的区别

IO的⽅式通常分为⼏种，同步阻塞的BIO、同步非阻塞的NIO、异步非阻塞的AIO

一、BIO

在JDK1.4出来之前，我们建⽴⽹络连接的时候采⽤BIO模式，需要先在服务端启动⼀个 ServerSocket，然后在客⼾端启动Socket来对服务端进⾏通信，

默认情况下服务端需要对每个请求建⽴⼀堆线程等待请求，⽽客⼾端发送请求后，先咨询服务端是 否有线程相应，如果没有则会⼀直等待或者遭到拒绝请求，如果有的话，客⼾端会线程在等待请求结束后才继续执⾏

⼆、NIO NIO本⾝是基于事件驱动思想来完成的，其主要想解决的是BIO的⼤并发问题： 在使⽤同步I/O的⽹ 络应⽤中，如果要同时处理多个客⼾端请求，或是在客⼾端要同时和多个服务器进⾏通讯，就必须使 ⽤多线程来处理。

也就是说，将每⼀个客⼾端请求分配给⼀个线程来单独处理。这样做虽然可以达到我们的要求，但 同时⼜会带来另外⼀个问题。由于每创建⼀个线程，就要为这个线程分配⼀定的内存空间（也叫⼯作 存储器），⽽且操作系统本⾝也对线程的总数有⼀定的限制。

如果客⼾端的请求过多，服务端程序可能会因为不堪重负⽽拒绝客⼾端的请求，甚⾄服务器可能会 因此⽽瘫痪。

NIO基于Reactor，当socket有流可读或可写⼊socket时，操作系统会相应的通知引⽤程序进⾏处 理，应⽤再将流读取到缓冲区或写⼊操作系统。

也就是说，这个时候，已经不是⼀个连接就要对应⼀个处理线程了，⽽是有效的请求，对应⼀个线 程，当连接没有数据时，是没有⼯作线程来处理的。

BIO与NIO⼀个⽐较重要的不同，是我们使⽤BIO的时候往往会引⼊多线程，每个连接⼀个单独的线 程；⽽NIO则是使⽤单线程或者只使⽤少量的多线程，每个连接共⽤⼀个线程。

NIO的最重要的地⽅是当⼀个连接创建后，不需要对应⼀个线程，这个连接会被注册到多路复⽤器 上⾯，所以所有的连接只需要⼀个线程就可以搞定，

当这个线程中的多路复⽤器进⾏轮询的时候，发现连接上有请求的话，才开启⼀个线程进⾏处 理，也就是⼀个请求⼀个线程模式

在NIO的处理⽅式中，当⼀个请求来的话，开启线程进⾏处理，可能会等待后端应⽤的资源(JDBC 连接等)，其实这个线程就被阻塞了，当并发上来的话，还是会有BIO⼀样的问题。

HTTP/1.1出现后，有了Http⻓连接，这样除了超时和指明特定关闭的http header外，这个链接 是⼀直打开的状态的，这样在NIO处理中可以进⼀步的进化，在后端资源中可以实现资源池或者队 列，

当请求来的话，开启的线程把请求和请求数据传送给后端资源池或者队列⾥⾯就返回，并且在全局 的地⽅保持住这个现场(哪个连接的哪个请求等)，这样前⾯的线程还是可以去接受其他的请求，

⽽后端的应⽤的处理只需要执⾏队列⾥⾯的就可以了，这样请求处理和后端应⽤是异步的.当后端处 理完，到全局地⽅得到现场，产⽣响应，这个就实现了异步处理。

三、AIO

与NIO不同，当进⾏读写操作时，只须直接调⽤API的read或write⽅法即可。这两种⽅法均为异步 的，对于读操作⽽⾔，当有流可读取时，操作系统会将可读的流传⼊read⽅法的缓冲区，并通知应⽤ 程序；

对于写操作⽽⾔，当操作系统将write⽅法传递的流写⼊完毕时，操作系统主动通知应⽤程序。 即 可以理解为，read/write⽅法都是异步的，完成后会主动调⽤回调函数。

在JDK1.7中，这部分内容被称作NIO.2，主要在Java.nio.channels包下增加了下⾯四个异步通道：

AsynchronousSocketChannel
AsynchronousServerSocketChannel
AsynchronousFileChannel
AsynchronousDatagramChannel

其中的read/write⽅法，会返回⼀个带回调函数的对象，当执⾏完读取/写⼊操作后，直接调⽤回调函 数。

BIO是⼀个连接⼀个线程。

NIO是⼀个请求⼀个线程。

AIO是⼀个有效请求⼀个线程。

先来个例⼦理解⼀下概念，以银⾏取款为例：

同步 ： ⾃⼰亲⾃出⻢持银⾏卡到银⾏取钱（使⽤同步IO时，Java⾃⼰处理IO读写）；

异步 ： 委托⼀⼩弟拿银⾏卡到银⾏取钱，然后给你（使⽤异步IO时，Java将IO读写委托给OS处理， 需要将数据缓冲区地址和⼤⼩传给OS(银⾏卡和密码)，OS需要⽀持异步IO操作API）；

阻塞 ： ATM排队取款，你只能等待（使⽤阻塞IO时，Java调⽤会⼀直阻塞到读写完成才返回）；

非阻塞 ： 柜台取款，取个号，然后坐在椅⼦上做其它事，等号⼴播会通知你办理，没到号你就不能 去，你可以不断问⼤堂经理排到了没有，⼤堂经理如果说还没到你就不能去（使⽤非阻塞IO时，如果不能读写Java调⽤会⻢上返回，当IO事件分发器会通知可读写时再继续进⾏读写，不断循环直到读写 完成）

Java对BIO、NIO、AIO的⽀持：

Java BIO ： 同步并阻塞，服务器实现模式为⼀个连接⼀个线程，即客⼾端有连接请求时服务器端就 需要启动⼀个线程进⾏处理，如果这个连接不做任何事情会造成不必要的线程开销，当然可以通过线 程池机制改善。

java NIO ： 同步⾮阻塞，服务器实现模式为⼀个请求⼀个线程，即客⼾端发送的连接请求都会注册 到多路复⽤器上，多路复⽤器轮询到连接有I/O请求时才启动⼀个线程进⾏处理。

Java AIO(NIO.2) ： 异步⾮阻塞，服务器实现模式为⼀个有效请求⼀个线程，客⼾端的I/O请求都是由 OS先完成了再通知服务器应⽤去启动线程进⾏处理，

BIO、NIO、AIO适⽤场景分析:

BIO⽅式适⽤于连接数⽬⽐较⼩且固定的架构，这种⽅式对服务器资源要求⽐较⾼，并发局限于应⽤ 中，JDK1.4以前的唯⼀选择，但程序直观简单易理解。

NIO⽅式适⽤于连接数⽬多且连接⽐较短（轻操作）的架构，⽐如聊天服务器，并发局限于应⽤中， 编程⽐较复杂，JDK1.4开始⽀持。

AIO⽅式使⽤于连接数⽬多且连接⽐较⻓（重操作）的架构，⽐如相册服务器，充分调⽤OS参与并发 操作，编程⽐较复杂，JDK7开始⽀持。

另外，I/O属于底层操作，需要操作系统⽀持，并发也需要操作系统的⽀持，所以性能⽅⾯不同操作 系统差异会⽐较明显。

在⾼性能的I/O设计中，有两个⽐较著名的模式Reactor和Proactor模式，其中Reactor模式⽤于同步 I/O，⽽Proactor运⽤于异步I/O操作。

在⽐较这两个模式之前，我们⾸先的搞明⽩⼏个概念，什么是阻塞和⾮阻塞，什么是同步和异步,同 步和异步是针对应⽤程序和内核的交互⽽⾔的，

同步指的是⽤⼾进程触发IO操作并等待或者轮询的去查看IO操作是否就绪，⽽异步是指⽤⼾进程触 发IO操作以后便开始做⾃⼰的事情，⽽当IO操作已经完成的时候会得到IO完成的通知。

⽽阻塞和⾮阻塞是针对于进程在访问数据的时候，根据IO操作的就绪状态来采取的不同⽅式，说⽩ 了是⼀种读取或者写⼊操作函数的实现⽅式，阻塞⽅式下读取或者写⼊函数将⼀直等待，⽽⾮阻塞⽅ 式下，读取或者写⼊函数会⽴即返回⼀个状态值。

⼀般来说I/O模型可以分为：同步阻塞，同步⾮阻塞，异步阻塞，异步⾮阻塞IO

同步阻塞IO：在此种⽅式下，⽤⼾进程在发起⼀个IO操作以后，必须等待IO操作的完成，只有当真正 完成了IO操作以后，⽤⼾进程才能运⾏。JAVA传统的IO模型属于此种⽅式！

同步⾮阻塞IO:在此种⽅式下，⽤⼾进程发起⼀个IO操作以后边可返回做其它事情，但是⽤⼾进程需 要时不时的询问IO操作是否就绪，这就要求⽤⼾进程不停的去询问，从⽽引⼊不必要的CPU资源浪 费。其中⽬前JAVA的NIO就属于同步⾮阻塞IO

异步阻塞IO：此种⽅式下是指应⽤发起⼀个IO操作以后，不等待内核IO操作的完成，等内核完成IO操 作以后会通知应⽤程序，这其实就是同步和异步最关键的区别，同步必须等待或者主动的去询问IO是 否完成，那么为什么说是阻塞的呢？因为此时是通过select系统调⽤来完成的，⽽select函数本⾝的 实现⽅式是阻塞的，⽽采⽤select函数有个好处就是它可以同时监听多个⽂件句柄，从⽽提⾼系统的 并发性！

异步⾮阻塞IO:在此种模式下，⽤⼾进程只需要发起⼀个IO操作然后⽴即返回，等IO操作真正的完成 以后，应⽤程序会得到IO操作完成的通知，此时⽤⼾进程只需要对数据进⾏处理就好了，不需要进⾏ 实际的IO读写操作，

因为真正的IO读取或者写⼊操作已经由内核完成了。⽬前Java中还没有⽀持此种IO模型

1.44、nio框架：dubbo的实现原理；

client⼀个线程调⽤远程接⼝，⽣成⼀个唯⼀的ID（⽐如⼀段随机字符串，UUID等），Dubbo是使⽤ AtomicLong从0开始累计数字的

将打包的⽅法调⽤信息（如调⽤的接⼝名称，⽅法名称，参数值列表等），和处理结果的回调对象 callback，全部封装在⼀起，组成⼀个对象object

向专⻔存放调⽤信息的全局ConcurrentHashMap⾥⾯put(ID, object)

将ID和打包的⽅法调⽤信息封装成⼀对象connRequest，使⽤IoSession.write(connRequest)异步发 送出去

当前线程再使⽤callback的get()⽅法试图获取远程返回的结果，在get()内部，则使⽤synchronized 获取回调对象callback的锁， 再先检测是否已经获取到结果，如果没有，然后调⽤callback的wait() ⽅法，释放callback上的锁，让当前线程处于等待状态。

服务端接收到请求并处理后，将结果（此结果中包含了前⾯的ID，即回传）发送给客⼾端，客⼾端 socket连接上专⻔监听消息的线程收到消息，分析结果，取到ID，再从前⾯的ConcurrentHashMap ⾥⾯get(ID)，从⽽找到callback，将⽅法调⽤结果设置到callback对象⾥。

监听线程接着使⽤synchronized获取回调对象callback的锁（因为前⾯调⽤过wait()，那个线程已释 放callback的锁了），再notifyAll()，唤醒前⾯处于等待状态的线程继续执⾏（callback的get()⽅法 继续执⾏就能拿到调⽤结果了），⾄此，整个过程结束。

当前线程怎么让它“暂停”，等结果回来后，再向后执⾏？

答：先⽣成⼀个对象obj，在⼀个全局map⾥put(ID,obj)存放起来，再⽤synchronized获取obj 锁，再调⽤obj.wait()让当前线程处于等待状态，然后另⼀消息监听线程等到服 务端结果来了 后，再map.get(ID)找到obj，再⽤synchronized获取obj锁，再调⽤obj.notifyAll()唤醒前⾯处于等待 状态的线程。

正如前⾯所说，Socket通信是⼀个全双⼯的⽅式，如果有多个线程同时进⾏远程⽅法调⽤，这时建⽴ 在client server之间的socket连接上会有很多双⽅发送的消息传递，前后顺序也可能是乱七⼋糟的， server处理完结果后，将结果消息发送给client，client收到很多消息，怎么知道哪个消息结果是原先 哪个线程调⽤的?

答：使⽤⼀个ID，让其唯⼀，然后传递给服务端，再服务端⼜回传回来，这样就知道结果是原先哪 个线程的了

第⼆章：JVM

2.1、介绍下Java内存区域（运⾏时数据区）

1）程序计数器（Program Counter Register）

⼀块较⼩的内存空间，可以看作当前线程所执⾏的字节码的行号指⽰器。如果线程正在执⾏的是⼀个 Java⽅法，这个计数器记录的是正在执⾏的虚拟机字节码指令的地址；如果正在执⾏的是Native⽅ 法，这个计数器值则为空。

2）Java虚拟机栈（Java Virtual Machine Stacks）

与程序计数器⼀样，Java虚拟机栈也是线程私有的，它的⽣命周期与线程相同。虚拟机栈描述的是 Java⽅法执⾏的内存模型：每个⽅法在执⾏的同时都会创建⼀个栈帧⽤于存储局部变量表、操作数 栈、动态链接、⽅法出⼝等信息。每⼀个⽅法从调⽤直⾄执⾏完成的过程，就对应着⼀个栈帧在虚拟 机栈中⼊栈到出栈的过程。

3）本地⽅法栈（Native Method Stack）

本地⽅法栈与虚拟机栈所发挥的作⽤是⾮常相似的，它们之间的区别不过是虚拟机栈为虚拟机执⾏ Java⽅法（也就是字节码）服务，⽽本地⽅法栈则为虚拟机使⽤到的Native⽅法服务。

4）Java堆（Java Heap）

对⼤多数应⽤来说，Java堆是Java虚拟机所管理的内存中最⼤的⼀块。Java堆是被所有线程共享的 ⼀块内存区域，在虚拟机启动时创建。此内存区域的唯⼀⽬的就是存放对象实例，⼏乎所有的对象实 例都在这⾥分配内存。

5）元数据区（Method Area） 在JDK1.7的时候，有⼀个JVM内存区域中有⼀块⽅法区，主要存放虚拟机加载的类信息，静态变量， 常量等。JDK1.8时，移除了⽅法区的概念，⽤⼀个元数据区代替。与Java堆⼀样，是各个线程共享 的内存区域，它⽤于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数 据。⽅法区是JVM规范中定义的⼀个概念，具体放在哪⾥，不同的实现可以放在不同的地⽅。

6）运⾏时常量池（Runtime Constant Pool） 运⾏时常量池是⽅法区的⼀部分。Class⽂件中除了有类的版本、字段、⽅法、接⼝等描述信息外， 还有⼀项信息是常量池，⽤于存放编译期⽣成的各种字⾯量和符号引⽤，这部分内容将在类加载后进 ⼊⽅法区的运⾏时常量池中存放

2.2、怎么判定对象已经“死去”？

常⻅的判定⽅法有两种：引⽤计数法和可达性分析算法，HotSpot中采⽤的是可达性分析算法。

引⽤计数法 给对象中添加⼀个引⽤计数器，每当有⼀个地⽅引⽤它时，计数器值就加1；当引⽤失效时，计数器 值就减1；任何时刻计数器为0的对象就是不可能再被使⽤的。

客观地说，引⽤计数算法的实现简单，判定效率也很⾼，在⼤部分情况下它都是⼀个不错的算法，但 是主流的Java虚拟机⾥⾯没有选⽤引⽤计数算法来管理内存，其中最主要的原因是它很难解决对象之 间相互循环引⽤的问题。

可达性分析算法 这个算法的基本思路就是通过⼀系列的称为“GC Roots”的对象作为起始点，从这些节点开始向下搜 索，搜索所⾛过的路径称为引⽤链，当⼀个对象到GC Roots没有任何引⽤链相连（⽤图论的话来说， 就是从GC Roots到这个对象不可达）时，则证明此对象是不可⽤的。如下图所⽰，对象object 5、 object 6、object 7虽然互相有关联，但是它们到GC Roots是不可达的，所以它们将会被判定为是可 回收的对象

2.3、介绍下四种引⽤（强引⽤、软引⽤、弱引⽤、虚引⽤）？

强引⽤：在程序代码之中普遍存在的，类似“Object obj=new Object()”这类的引⽤，只要强引⽤还 存在，垃圾收集器永远不会回收掉被引⽤的对象。

软引⽤：⽤来描述⼀些还有⽤但并⾮必需的对象，使⽤SoftReference类来实现软引⽤，在系统将要 发⽣内存溢出异常之前，将会把这些对象列进回收范围之中进⾏第⼆次回收。

弱引⽤：⽤来描述⾮必需对象的，使⽤WeakReference类来实现弱引⽤，被弱引⽤关联的对象只能⽣ 存到下⼀次垃圾收集发⽣之前。

虚引⽤：是最弱的⼀种引⽤关系，使⽤PhantomReference类来实现虚引⽤，⼀个对象是否有虚引⽤ 的存在，完全不会对其⽣存时间构成影响，也⽆法通过虚引⽤来取得⼀个对象实例。为⼀个对象设置 虚引⽤关联的唯⼀⽬的就是能在这个对象被收集器回收时收到⼀个系统通知。

2.4、垃圾收集有哪些算法，各⾃的特点？

标记 - 清除算法

⾸先标记出所有需要回收的对象，在标记完成后统⼀回收所有被标记的对象。它的主要不⾜有两个： ⼀个是效率问题，标记和清除两个过程的效率都不⾼；另⼀个是空间问题，标记清除之后会产⽣⼤量 不连续的内存碎⽚，空间碎⽚太多可能会导致以后在程序运⾏过程中需要分配较⼤对象时，⽆法找到 ⾜够的连续内存⽽不得不提前触发另⼀次垃圾收集动作。

复制算法

为了解决效率问题，⼀种称为“复制”（Copying）的收集算法出现了，它将可⽤内存按容量划分为 ⼤⼩相等的两块，每次只使⽤其中的⼀块。当这⼀块的内存⽤完了，就将还存活着的对象复制到另外 ⼀块上⾯，然后再把已使⽤过的内存空间⼀次清理掉。这样使得每次都是对整个半区进⾏内存回收， 内存分配时也就不⽤考虑内存碎⽚等复杂情况，只要移动堆顶指针，按顺序分配内存即可，实现简 单，运⾏⾼效。只是这种算法的代价是将内存缩⼩为了原来的⼀半，未免太⾼了⼀点。

标记 - 整理算法

根据⽼年代的特点，有⼈提出了另外⼀种“标记-整理”（Mark-Compact）算法，标记过程仍然 与“标记-清除”算法⼀样，但后续步骤不是直接对可回收对象进⾏清理，⽽是让所有存活的对象都 向⼀端移动，然后直接清理掉端边界以外的内存。

分代收集算法

当前商业虚拟机的垃圾收集都采⽤“分代收集”算法，这种算法并⽆新的⽅法，只是根据对象的存活 周期的不同将内存划分为⼏块，⼀般是把Java堆分为新⽣代和⽼年代，这样就可以根据各个年代的特 点采⽤最适当的收集算法。在新⽣代中，每次垃圾收集时都发现有⼤批对象死去，只有少量存活，那 就选⽤复制算法，只需要付出少量存活对象的复制成本就可以完成收集。⽽⽼年代中因为对象存活率 ⾼、没有额外空间对它进⾏分配担保，就必须使⽤“标记-清理”或“标记-整理”算法来进⾏回收

2.5、HotSpot为什么要分为新⽣代和⽼年代？

HotSpot根据对象存活周期的不同将内存划分为⼏块，⼀般是把Java堆分为新⽣代和⽼年代，这样就 可以根据各个年代的特点采⽤最适当的收集算法。在新⽣代中，每次垃圾收集时都发现有⼤批对象死 去，只有少量存活，那就选⽤复制算法，只需要付出少量存活对象的复制成本就可以完成收集。⽽⽼ 年代中因为对象存活率⾼、没有额外空间对它进⾏分配担保，就必须使⽤“标记—清理”或者“标记 —整理”算法来进⾏回收。

其中新⽣代⼜分为1个Eden区和2个Survivor区，通常称为From Survivor和To Survivor区

2.6、新⽣代中Eden区和Survivor区的默认⽐例

在HotSpot虚拟机中，Eden区和Survivor区的默认⽐例为8:1:1，即-XX:SurvivorRatio=8，其中 Survivor分为From Survivor和ToSurvivor，因此Eden此时占新⽣代空间的80%

2.7、HotSpot GC的分类

针对HotSpot VM的实现，它⾥⾯的GC其实准确分类只有两⼤种：

    1）Partial GC：并不收集整个GC堆的模式，具体如下：

1. Young GC/Minor GC：只收集新⽣代的GC。
2. Old GC：只收集⽼年代的GC。只有CMS的concurrent collection是这个模式。
3. Mixed GC：收集整个新⽣代以及部分⽼年代的GC，只有G1有这个模式。

2）Full GC/Major GC：收集整个GC堆的模式，包括新⽣代、⽼年代、永久代（如果存在的话）等所 有部分的模式。

FullGC是对整个堆来说的，出现Full GC的时候经常伴随⾄少⼀次的Minor GC，但⾮绝对的。Major GC的速度⼀般会⽐Minor GC慢10倍以上

2.8、HotSpot GC的触发条件？

这⾥只说常⻅的Young GC和Full GC。

Young GC：当新⽣代中的Eden区没有⾜够空间进⾏分配时会触发Young GC。

Full GC：

1. 当准备要触发⼀次Young GC时，如果发现统计数据说之前Young GC的平均晋升⼤⼩⽐⽬前⽼年代 剩余的空间⼤，则不会触发Young GC⽽是转为触发Full GC。（通常情况）
2. 如果有永久代的话，在永久代需要分配空间但已经没有⾜够空间时，也要触发⼀次Full GC。
3. System.gc()默认也是触发Full GC。
4. heap dump带GC默认也是触发Full GC。
5. CMS GC时出现Concurrent Mode Failure会导致⼀次Full GC的产⽣。

2.9、Full GC后⽼年代的空间反⽽变⼩？

HotSpot的Full GC实现中，默认新⽣代⾥所有活的对象都要晋升到⽼年代，实在晋升不了才会留在新 ⽣代。假如做Full GC的时候，⽼年代⾥的对象⼏乎没有死掉的，⽽新⽣代⼜要晋升活对象上来，那么 Full GC结束后⽼年代的使⽤量⾃然就上升了。

2.10、什么情况下新⽣代对象会晋升到⽼年代？

1. 如果新⽣代的垃圾收集器为Serial和ParNew，并且设置了-XX:PretenureSizeThreshold参数，当 对象⼤于这个参数值时，会被认为是⼤对象，直接进⼊⽼年代。
2. Young GC后，如果对象太⼤⽆法进⼊Survivor区，则会通过分配担保机制进⼊⽼年代。
3. 对象每在Survivor区中“熬过”⼀次Young GC，年龄就增加1岁，当它的年龄增加到⼀定程度（默 认为15岁，可以通过-XX:MaxTenuringThreshold设置），就将会被晋升到⽼年代中。
4. 如果在Survivor区中相同年龄所有对象⼤⼩的总和⼤于Survivor空间的⼀半，年龄⼤于或等于该年 龄的对象就可以直接进⼊⽼年代，⽆须等到MaxTenuringThreshold中要求的年龄。

2.11、新⽣代垃圾回收器和⽼年代垃圾回收器都有哪些？有什么区别

• 新⽣代回收器：Serial、ParNew、Parallel Scavenge

• ⽼年代回收器：Serial Old、Parallel Old、CMS

• 整堆回收器：G1

新⽣代垃圾回收器⼀般采⽤的是复制算法，复制算法的优点是效率⾼，缺点是内存利⽤率低；⽼年代 回收器⼀般采⽤的是标记-整理的算法进⾏垃圾回收。

1）Serial收集器（复制算法): 新⽣代单线程收集器，标记和清理都是单线程，优点是简单⾼效；

2）ParNew收集器 (复制算法): 新⽣代收并⾏集器，实际上是Serial收集器的多线程版本，在多核 CPU环境下有着⽐Serial更好的表现；

3）Parallel Scavenge收集器 (复制算法): 新⽣代并⾏收集器，追求⾼吞吐量，⾼效利⽤ CPU。吞吐 量 = ⽤⼾线程时间/(⽤⼾线程时间+GC线程时间)，⾼吞吐量可以⾼效率的利⽤CPU时间，尽快完成程 序的运算任务，适合后台应⽤等对交互相应要求不⾼的场景；

4）Serial Old收集器 (标记-整理算法): ⽼年代单线程收集器，Serial收集器的⽼年代版本；

5）Parallel Old收集器 (标记-整理算法)： ⽼年代并⾏收集器，吞吐量优先，Parallel Scavenge收 集器的⽼年代版本；

6）CMS(Concurrent Mark Sweep)收集器（标记-清除算法）： ⽼年代并⾏收集器，以获取最短回 收停顿时间为⽬标的收集器，具有⾼并发、低停顿的特点，追求最短GC回收停顿时间。对于要求服 务器响应速度的应⽤上，这种垃圾回收器⾮常适合。在启动 JVM 的参数加上“- XX:+UseConcMarkSweepGC”来指定使⽤ CMS 垃圾回收器。CMS 使⽤的是标记-清除的算法实现 的，所以在 gc 的时候回产⽣⼤量的内存碎⽚，当剩余内存不能满⾜程序运⾏要求时，系统将会出现 Concurrent Mode Failure，临时 CMS 会采⽤ Serial Old 回收器进⾏垃圾清除，此时的性能将会被降 低。

7）G1(Garbage First)收集器 (标记-整理算法)： Java堆并⾏收集器，G1收集器是JDK1.7开始提供 的⼀个新收集器，G1收集器基于“标记-整理”算法实现，也就是说不会产⽣内存碎⽚。此外，G1收 集器不同于之前的收集器的⼀个重要特点是：G1回收的范围是整个Java堆(包括新⽣代，⽼年代)，⽽ 前六种收集器回收的范围仅限于新⽣代或⽼年代

第三章：集合

3.1：有用过ArrayList吗？ 它是做什么用的

ArrayList就是数组列表，底层是数组 Object[] elementData。ArrayList在装载基本数据类型时，实 际装载的是对应的包装类。 与ArrayList类似的还有LinkedList，他们俩相⽐：

1. ArrayList：查找和访问元素的速度快，新增、删除的速度慢。线程不安全，使⽤频率⾼。
2. LinkedList：查找和访问元素的速度慢，新增、删除的速度快。

3.2：ArrayList线程不安全，为什么还要去⽤？

实际开发中有以下⼏种场景：

1. 频繁增删：使⽤LinkedList，但是涉及到频繁增删的场景不多
2. 追求线程安全：使⽤Vector。
3. 普通的⽤来查询：使⽤ArrayList，使⽤的场景最多。

根据数据结构的特性，三者难以全包含，只能在相互之间做取舍。

3.3：ArrayList线程不安全，为什么还要去用？

使⽤⽆参构造创建ArrayList

/**
* Default initial capacity.
* 默认的初始化容量
*/
private static final int DEFAULT_CAPACITY = 10;
/**
* Shared empty array instance used for default sized empty instances. We
* distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
* first element is added.
这个是创建的默认⼤⼩的空数组。EMPTY_ELEMENTDATA⽤于表⽰当第⼀个数据被添加时该空数
组初始化的⼤⼩。
*/
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
/**
* Constructs an empty list with an initial capacity of ten.
* 构造⼀个空的List，该List具有10个容量
*/
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

使⽤ArrayList空参的构造器创建集合时，数组并没有创建。当集合中添加第⼀个元素时，数组被创 建，初始化容量为4. • 使⽤有参构造创建ArrayList 有参构造创建时，如果指定了容量则会创建出指定容量⼤⼩的数组。如果指定容量为0，则⽆参构造 ⼀样。

/**
* Constructs an empty list with the specified initial capacity.
*
* @param initialCapacity the initial capacity of the list
* @throws IllegalArgumentException if the specified initial capacity
* is negative
*/
public ArrayList(int initialCapacity) {
    if (initialCapacity > 0) {
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        throw new IllegalArgumentException("Illegal             Capacity: "+
        initialCapacity);
    }
}

3.4：ArrayList(int initialCapacity)会不会初始化数组⼤⼩？

/**
* Constructs an empty list with the specified initial capacity.
*
* @param initialCapacity the initial capacity of the list
* @throws IllegalArgumentException if the specified initial capacity
* is negative
*/
public ArrayList(int initialCapacity) {
    if (initialCapacity > 0) {
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        throw new IllegalArgumentException("Illegal             Capacity: "+
        initialCapacity);
    }
}

会 初始化⼤⼩，但如果通过ArrayList的size()⽅法进⾏判断时结果依然为0，因为只有在添加元素时才 会对ArrayList的size属性+1

/**
* The size of the ArrayList (the number of elements it contains).
*
* @serial
*/
private int size;

3.5：ArrayList底层是⽤数组实现，但数组⻓度是有限的，如何实现扩容？

当新增元素，ArrayList放不下该元素时，触发扩容。

扩容的容量将会是原容量的1/2，也就是新容量是旧容量的1.5倍。

确定新容量确定的源码：

/**
* Increases the capacity to ensure that it can hold at least the
* number of elements specified by the minimum capacity argument.
*
* @param minCapacity the desired minimum capacity
*/
private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    //新容量=旧容量+1/2旧容量
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // minCapacity is usually close to size, so this is a         win:
    elementData = Arrays.copyOf(elementData, newCapacity);
}

执⾏扩容时使⽤系统类System的数组复制⽅法arraycopy()进⾏扩容

扩容的源码：

public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
    @SuppressWarnings("unchecked")
    T[] copy = ((Object)newType == (Object)Object[].class)
        ? (T[]) new Object[newLength]
        : (T[])                                     Array.newInstance(newType.getComponentType(), newLength);
    System.arraycopy(original, 0, copy, 0,
    Math.min(original.length, newLength));
    return copy;
}

3.6：ArrayList1.7之前和1.7及以后的区别？

1.7之前ArrayList在初始化的时候直接调⽤this(10)，初始化容量为10的数组。在1.7及以后，只有第 ⼀次执⾏add⽅法向集合添加元素时才会创建容量为10的数组

3.7：为什么ArrayList增删⽐较慢，增删是如何做的？

没有指定index添加元素 直接添加到最后，如果容量不够则需要扩容

/**
* Appends the specified element to the end of this list.
*
* @param e element to be appended to this list
* @return <tt>true</tt> (as specified by {@link Collection#add})
*/
public boolean add(E e) {
    ensureCapacityInternal(size + 1); // Increments modCount!!
    elementData[size++] = e;
    return true;
}

如果指定了index添加元素

/**
* Inserts the specified element at the specified position in this
* list. Shifts the element currently at that position (if any) and
* any subsequent elements to the right (adds one to their indices).
*
* @param index index at which the specified element is to be inserted
* @param element element to be inserted
* @throws IndexOutOfBoundsException {@inheritDoc}
*/
public void add(int index, E element) {
    rangeCheckForAdd(index);
    ensureCapacityInternal(size + 1); // Increments modCount!!
    System.arraycopy(elementData, index, elementData,         index + 1,
    size - index);
    elementData[index] = element;
    size++;
}

从源码⾥看到，是将要添加的元素位置index之后的已有元素全部拷⻉到添加到原数组index+1处，然 后再把新的数据加⼊

3.8：ArrayList插⼊和删除数据⼀定慢吗？

不⼀定，取决于删除的数据离数组末端有多远，如果离末端较近，则性能不⼀定差。

3.9：ArrayList如何删除数据？

/*
* Private remove method that skips bounds checking and does not
* return the value removed.
*/
private void fastRemove(int index) {
    modCount++;
    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1,     elementData, index,
    numMoved);
    elementData[--size] = null; // clear to let GC do its work
}

ArrayList删除数据时同样使⽤拷⻉数组的⽅式，将要删除的位置之后的所有元素拷到当前位置，最后 再对最后⼀个位置的数据设置为null，交给gc来回收。这种删除，其实就是覆盖，如果数据量⼤，那 么效率很低。

3.10：ArrayList适合做队列吗？

队列需要遵循先进先出的原则，如果从ArrayList的数组头部⼊队列，数组尾部出队列，那么对于⼊队 列时的操作，会涉及⼤数据量的数组拷⻉，⼗分耗性能。队头队尾反⼀反也是⼀样，因此ArrayList不 适合做队列。

3.11：数组适合做队列吗？

ArrayBlockingQueue环形队列就是⽤数组来实现的。ArrayBlockingQueue的存和取操作的索引是在 当索引值等于容量值时，将索引值设置为0实现环形队列的效果，因此在这种情况下，数组适合做队 列

/**
* Inserts element at current put position, advances, and signals.
* Call only when holding lock.
*/
private void enqueue(E x) {
// assert lock.getHoldCount() == 1;
// assert items[putIndex] == null;
final Object[] items = this.items;
items[putIndex] = x;
if (++putIndex == items.length)
putIndex = 0;
count++;
notEmpty.signal();
}

/**
* Extracts element at current take position, advances, and signals.
* Call only when holding lock.
*/
private E dequeue() {
// assert lock.getHoldCount() == 1;
// assert items[takeIndex] != null;
final Object[] items = this.items;
@SuppressWarnings("unchecked")
E x = (E) items[takeIndex];
items[takeIndex] = null;
if (++takeIndex == items.length)
takeIndex = 0;
count--;
if (itrs != null)
itrs.elementDequeued();
notFull.signal();
return x;
}

3.12：ArrayList和LinkedList两者的遍历性能孰优孰劣？

ArrayList的遍历性能明显要⽐LinkedList好，因为ArrayList存储的数据在内存中时连续的，CPU内部 缓存结构会缓存连续的内存⽚段，可以⼤幅降低读取内存的性能开销

3.13：了解数据结构中的HashMap吗？介绍下他的结构和底层原理

HashMap是由数组+链表组成的数据结构（jdk1.8中是数组+链表+红⿊树的数据结构）

1.7 版本：根据hash(key)确定存储位置后，以链表的形式在该位置处存数据。此时数组该位置的 链表存了多个数据，因此也称为桶

存放的数据是⽤Entry描述:

static class Entry<K,V> implements Map.Entry<K,V> {
final K key;
V value;
Entry<K,V> next;
int hash;
/**
* Creates new entry.
*/
Entry(int h, K k, V v, Entry<K,V> n) {
value = v;
next = n;
key = k;
hash = h;
}

1.8 版本： 存放的数据是⽤Node描述:

static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
Node(int hash, K key, V value, Node<K,V> next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}

链表有可能过⻓，所以在满⾜以下条件时，链表会转换成红⿊树

1. 链表⻓度>8
2. 数组⼤⼩>=64
3. 1.8版本：当红⿊树节点个数<6时转换为链表

3.14：那你清楚HashMap的插⼊数据的过程吗？

3.15：刚才你提到HashMap的初始化，那HashMap怎么设定初始容量⼤ ⼩的？

如果没有指定容量：则使⽤默认的容量为16，负载因⼦0.75

/**
* Constructs an empty <tt>HashMap</tt> with the default initial capacity
* (16) and the default load factor (0.75).
*/
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}

如果指定了容量，则会初始化容量为：⼤于指定容量的，最近的2的整数次⽅的数。⽐如传⼊是 10，则会初始化容量为16（2的4次⽅）

具体实现：

/**
* 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
;
}

该算法的逻辑是让⾼位1的之后所有位上的数都为1，再做+1的操作，实现初始化容量为：⼤于指定容 量的，最近的2的整数次⽅的数

3.16：你提到hash函数，你知道HashMap的hash函数是如何设计的？

// jdk1.8
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
//jdk1.7 相⽐jdk1.8, jdk1.7做了四次移位和四次异或运算，效率⽐1.8要低
h ^= (h >>> 20) ^ (h >>> 12);
return h ^ (h >>> 7) ^ (h >>> 4);

⽤key的hashCode()与其低16位做异或运算。这个扰动函数的设计有两个原因： • 计算出来的hash值尽量分散，降级hash碰撞的概率 • ⽤位运算做算法，更加⾼效 这样答只是答了表象的东西，深层的内容是这样的： ⾸先我们要知道hash运算的⽬的是⽤来定位该数据要存放在数组的哪个位置，如何计算？

// jdk 1.8
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
// jdk 1.7
static int indexFor(int h, int length) {
// assert Integer.bitCount(length) == 1 : "length must be a non-zero power o
f 2";
return h & (length-1);
}

是通过n-1的操作与原hash值做“与”运算，其中n是数组的⻓度。相当于是更⾼效的%取模运算。⽽ n-1恰好是⼀个低位掩码。⽐如初始化⻓度是16，那n-1是15，即⼆进制的0000 1111。 此时得到了另⼀个问题的答案：那么为什么不能直接⽤key的hashCode()作为hash值，⽽⼀定要^ (h >>> 16)？ 因为如果直接⽤key的hashCode()作为hash值，很容易发⽣hash碰撞。 使⽤扰动函数^ (h >>> 16)，就是为了混淆原始哈希码的⾼位和低位，以此来加⼤低位的随机性。且低 位中参杂了⾼位的信息，这样⾼位的信息也作为扰动函数的关键信息

3.17：1.8相⽐1.7，做了哪些优化?

1.8除了引⼊了红⿊树，将时间复杂度由O(n)降为O(log n)以外，还将1.7的头插法改为1.8的尾插法。

• 头插法： 作者认为，后插⼊的数据，被访问的概率更⾼，所以使⽤了头插法，但头插法会存在遍历时死循环的 情况

扩容之前：

扩容之后：获得新的index，头插法会导致链表反转：

源码：

/**
* Transfers all entries from current table to newTable.
*/
void transfer(Entry[] newTable, boolean rehash) {
int newCapacity = newTable.length;
for (Entry<K,V> e : table) {
while(null != e) {
Entry<K,V> next = e.next;
if (rehash) {
e.hash = null == e.key ? 0 : hash(e.key);
}
int i = indexFor(e.hash, newCapacity);
e.next = newTable[i]; //此处如果发⽣并发，线程1执⾏反转过程中线程2执
⾏
newTable[i] = e;
e = next;
}
}
}

当线程1执⾏反转过程中线程2执⾏，就可能会出现如下情况，造成链表成环的死循环问题

• 尾插法

在扩容时会保持链表元素原先的顺序，因此不会出现链表成环的死循环问题。

3.18：HashMap怎么实现扩容的?

HashMap执⾏扩容关系到两个参数：

Capacity：HashMap当前容量

loadFactor：负载因⼦（默认是0.75）

当HashMap容量达到Capacity*loadFactor时，进⾏扩容。

1.7和1.8版本的扩容区别：

• 1.7版本 先扩容，再插⼊数据。扩容时会创建⼀个为原数组的2倍⼤⼩的数组，然后将原数组的元素重新 hash，存进新数组。

• 1.8版本 先插⼊数据，再执⾏扩容。扩容时会创建⼀个为原数组的2倍⼤⼩的数组，然后将原数组的元素存进 新数组。不同的是1.8使⽤位移操作创建2倍⼤⼩的新数组

 newThr = oldThr << 1;

3.19：插⼊数据时扩容的重新hash是怎么做的？

1.7：需要再做⼀次hash

/**
* Adds a new entry with the specified key, value and hash code to
* the specified bucket. It is the responsibility of this
* method to resize the table if appropriate.
*
* Subclass overrides this to alter the behavior of put method.
*/
void addEntry(int hash, K key, V value, int bucketIndex) {
if ((size >= threshold) && (null != table[bucketIndex])) {
resize(2 * table.length);
hash = (null != key) ? hash(key) : 0;
bucketIndex = indexFor(hash, table.length);
}
createEntry(hash, key, value, bucketIndex);
}

1.8：不需要做hash，通过原⽅式获取存储位置

newTab[e.hash & (newCap - 1)] = e; 由于newCap为新数组的⼤⼩，因此在做与操作时，在没有改变key的hash的情况下，改变了与数的 值来获取新的存储位置，效率更⾼。⽽且位预算的newCap-1 实际上由于2的幂的关系，-1的操作实 际上就是在⾼位补1，效率更⾼。

3.20：为什么重写equals⽅法后还要重写hashCode⽅法

因为在put的时候，如果数据已经存在，就需要把⽼的数据return，存⼊新的数据。那如何判断数据 已存在呢？是通过先⽐较hash值，如果hash值相同，再⽤equals判断。

Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;

重写equals和hashCode⽅法的⽬的就是根据对象的属性来进⾏判断对象是否相同，⽽⾮根据对象的 内存地址来判断

public class User {
private int id;
private String name;
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
User user = (User) o;
return id == user.id && Objects.equals(name, user.name);
}
@Override
public int hashCode() {
return Objects.hash(id, name);
}
}

3.21：HashMap在多线程使⽤场景下会存在线程安全问题，怎么处理？

处理⽅案有以下三种:

1. 使⽤Collections.synchronizedMap()创建线程安全的map集合
2. 使⽤Hashtable
3. 使⽤ConcurrentHashMap

鉴于效率考虑，推荐使⽤ConcurrentHashMap。

3.22:Collections.synchronizedMap()如何实现线程安全

private static class SynchronizedMap<K,V>
implements Map<K,V>, Serializable {
private final Map<K,V> m; // Backing Map
final Object mutex; // Object on which to synchronize
SynchronizedMap(Map<K,V> m) {
this.m = Objects.requireNonNull(m);
mutex = this; //设置当前对象互斥量
}

Collections.synchronizedMap(map)创建出的SynchronizedMap对象，把当前对象作为互斥量（也 可以指定互斥量）。

之后操作该SynchronizedMap，其操作Map的⽅法都被加上了synchronized。

public int size() {
synchronized (mutex) {return m.size();}
}
public boolean isEmpty() {
synchronized (mutex) {return m.isEmpty();}
}
public boolean containsKey(Object key) {
synchronized (mutex) {return m.containsKey(key);}
}
public boolean containsValue(Object value) {
synchronized (mutex) {return m.containsValue(value);}
}
public V get(Object key) {
synchronized (mutex) {return m.get(key);}
}
public V put(K key, V value) {
synchronized (mutex) {return m.put(key, value);}
}
public V remove(Object key) {
synchronized (mutex) {return m.remove(key);}
}
public void putAll(Map<? extends K, ? extends V> map) {
synchronized (mutex) {m.putAll(map);}
}
public void clear() {
synchronized (mutex) {m.clear();}
}

3.23：Hashtable的性能为什么不好？

Hashtable的每个操作都使⽤了synchronized上了锁，甚⾄读的操作也上锁。

public synchronized V get(Object key) {
Entry<?,?> tab[] = table;
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length;
for (Entry<?,?> e = tab[index] ; e != null ; e = e.next) {
if ((e.hash == hash) && e.key.equals(key)) {
return (V)e.value;
}
}
return null;
}

3.24：Hashtable和HashMap有什么区别?

Hashtable的键值不能为null，但HashMap可以为null。

HashMap在存放null的键时做了处理

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

为什么要Hashtable设计成不能为null？ 因为Hashtable如果可以存null，那么有可能导致判断数据是否已存在时，没办法判断是否是null还 是不存在。

public synchronized boolean containsKey(Object key) {
Entry<?,?> tab[] = table;
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length;
for (Entry<?,?> e = tab[index] ; e != null ; e = e.next) {
if ((e.hash == hash) && e.key.equals(key)) {
return true;
}
}
return false;
}

除此之外，Hashtable的初始化容量是11，扩容时是当前容量*2+1。

int newCapacity = (oldCapacity << 1) + 1;

3.25：什么是fail-safe和fail-fast

fail-safe：安全失败。java.util.concurrent并发包下的容器都是遵循安全失败机制。即可以在多线 程下并发修改。不会抛出并发修改的异常Concurrent Modification Exception • Fail-fast: 快速失败。Java集合在使⽤迭代器遍历时，如果遍历过程中对集合中的内容进⾏了增删 改的操作时，则会抛出并发修改的异常Concurrent Modification Exception。即使不存在并发， 也会抛出该异常，所以称之为快速失败。

@Override
public void forEach(BiConsumer<? super K, ? super V> action) {
Node<K,V>[] tab;
if (action == null)
throw new NullPointerException();
if (size > 0 && (tab = table) != null) {
int mc = modCount;
for (int i = 0; i < tab.length; ++i) {
for (Node<K,V> e = tab[i]; e != null; e = e.next)
action.accept(e.key, e.value);
}
if (modCount != mc)
throw new ConcurrentModificationException();
}
}

3.26：ConcurrentHashMap的数据结构是怎么样？

从类关系图上来看HashMap和ConcurrentHashMap都来⾃于Map，因此ConcurrentHashMap数据 结构遵循HashMap的1.7和1.8的特征。

• 1.7版本使⽤的是数组+链表结构

• 1.8版本使⽤的是数组+链表+红⿊树结构

但是ConcurrentHashMap在数组中存的元素不同。 • 1.7版本： 存⼊的数据⽤Segment类型来封装。

/**
* Segments are specialized versions of hash tables. This
* subclasses from ReentrantLock opportunistically, just to
* simplify some locking and avoid separate construction.
*/
static final class Segment<K,V> extends ReentrantLock implements Serializab
le {
...
}

⼀个ConcurrentHashMap包含⼀个Segment数组，Segment⾥包含⼀个HashEntry数组，每个 HashEntry数组中是⼀个链表结构的元素，每个Segment守护着⼀个HashEntry数组⾥的元素，当对 HashEntry数组的数据进⾏修改时，必须⾸先获得与它对应的Segment锁。每个Segment元素相当于 ⼀个⼩的HashMap。 ⼀个ConcurrentHashMap中只有⼀个Segment 类型的segments数组，每个segment中只有⼀个HashEntry 类型的table数组，table数组中存放⼀个HashEntry节点。

HashEntry的内部结构：

static final class HashEntry<K,V> {
final int hash;
final K key;
volatile V value; //加了volatile修饰，保存内存可⻅性及防⽌指令重排
volatile HashEntry<K,V> next;
HashEntry(int hash, K key, V value, HashEntry<K,V> next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}

很显然，1.7版本的ConcurrentHashMap采⽤了分段锁（Segment）技术，其中Segment继承了 ReentrantLock。

在插⼊ConcurrentHashMap元素时，先尝试获得Segment锁，先是⾃旋获锁，如果⾃旋次数超过阈 值，则转为ReentrantLock上锁。

inal V put(K key, int hash, V value, boolean onlyIfAbsent) {
             HashEntry<K,V> node = tryLock() ? null :
                scanAndLockForPut(key, hash, value); /⾃旋获锁
             V oldValue;
            try {
                 HashEntry<K,V>[] tab = table;
                 int index = (tab.length - 1) & hash;/算出插⼊位置
                 HashEntry<K,V> first = entryAt(tab, index);
                for (HashEntry<K,V> e = first;;) {
                     if (e != null) {
                         K k;
                         if ((k = e.key) == key | |
                             (e.hash == hash && key.equals(k))) {/判断插⼊的元素
是否已存在
                            oldValue = e.value;
                             if (!onlyIfAbsent) {
                                 e.value = value;
                                ++modCount;
                             }
                             break;
                         }
                         e = e.next;/不存在则遍历下⼀个
}
    else {
if (node != null)
node.setNext(first);
else
node = new HashEntry<K,V>(hash, key, value, first);
//创建节点
int c = count + 1;
if (c > threshold && tab.length < MAXIMUM_CAPACITY)
rehash(node);//扩容
else
setEntryAt(tab, index, node);//存⼊节点
++modCount;
count = c;
oldValue = null;
break;
}
}
} finally {
unlock();//释放锁
}
return oldValue;
}

3.27：Segment如何实现扩容？

/**
* Doubles size of table and repacks entries, also adding the
* given node to new table
*/
@SuppressWarnings("unchecked")
private void rehash(HashEntry<K,V> node) {
HashEntry<K,V>[] oldTable = table;
int oldCapacity = oldTable.length;
int newCapacity = oldCapacity << 1;
threshold = (int)(newCapacity * loadFactor);
HashEntry<K,V>[] newTable =
(HashEntry<K,V>[]) new HashEntry[newCapacity];
int sizeMask = newCapacity - 1;
for (int i = 0; i < oldCapacity ; i++) {
HashEntry<K,V> e = oldTable[i];
    if (e != null) {
HashEntry<K,V> next = e.next;
int idx = e.hash & sizeMask;
if (next == null) // Single node on list
newTable[idx] = e;
else { // Reuse consecutive sequence at same slot
HashEntry<K,V> lastRun = e;
int lastIdx = idx;
for (HashEntry<K,V> last = next;
last != null;
last = last.next) {
int k = last.hash & sizeMask;
if (k != lastIdx) {//如果找到不相同的hash索引位置，则继
续找下⼀个，直到找到最后⼀个相同的索引位置。
lastIdx = k;
lastRun = last;
}
}//找到第⼀个后续节点新的index不变的节点。
newTable[lastIdx] = lastRun;
// Clone remaining nodes 第⼀个后续节点新index不变节点前所
有节点均需要重新创建分配。——⽤以提升效率
for (HashEntry<K,V> p = e; p != lastRun; p = p.next) {
V v = p.value;
int h = p.hash;
int k = h & sizeMask;
HashEntry<K,V> n = newTable[k];
newTable[k] = new HashEntry<K,V>(h, p.key, v, n);
}
}
}
}
int nodeIndex = node.hash & sizeMask; // add the new node
node.setNext(newTable[nodeIndex]);
newTable[nodeIndex] = node;
table = newTable;
}