1、我直接⽤思维导图的形式展示出来吧！这样更加直观形象⼀点，细化到某个知识点的话这张图没 有介绍到，留个悬念，下篇⽂章会详细介绍。
上⾯思维导图⼤概涵盖了技术⾯试可能会设计的技术，但是你不需要把上⾯的每⼀个知识点都搞
得很熟悉，要分清主次，对于⾃⼰不熟悉的技术不要写在简历上，对于⾃⼰简单了解的技术不要
说⾃⼰熟练掌握！
2.1. Java 基础
2.1.1. ⾯向对象和⾯向过程的区别
⾯向过程 ： ⾯向过程性能⽐⾯向对象⾼。 因为类调⽤时需要实例化，开销⽐⼤，⽐消
耗资源，所以当性能是最重要的考量因素的时候，⽐如单⽚机、嵌⼊式开发、 Linux/Unix 等
⼀般采⽤⾯向过程开发。但是， ⾯向过程没有⾯向对象易维护、易复⽤、易扩展。
⾯向对象 ： ⾯向对象易维护、易复⽤、易扩展。 因为⾯向对象有封装、继承、多态性的特
性，所以可以设计出低耦合的系统，使系统更加灵活、更加易于维护。但是， ⾯向对象性能
⽐⾯向过程低 。
参⻅ issue : ⾯向过程 ：⾯向过程性能⽐⾯向对象⾼？？
这个并不是根本原因，⾯向过程也需要分配内存，计算内存偏移量， Java 性能差的主要原
因并不是因为它是⾯向对象语⾔，⽽是 Java 是半编译语⾔，最终的执⾏代码并不是可以直
接被 CPU 执⾏的⼆进制机械码。
⽽⾯向过程语⾔⼤多都是直接编译成机械码在电脑上执⾏，并且其它⼀些⾯向过程的脚本语
⾔性能也并不⼀定⽐ Java 好。
2.1.2. Java 语⾔有哪些特点 ?
1. 简单易学；
2. ⾯向对象（封装，继承，多态）；
3. 平台⽆关性（ Java 虚拟机实现平台⽆关性）；
4. 可靠性；
5. 安全性；
6. ⽀持多线程（ C++ 语⾔没有内置的多线程机制，因此必须调⽤操作系统的多线程功能来进
⾏多线程程序设计，⽽ Java 语⾔却提供了多线程⽀持）；
7. ⽀持⽹络编程并且很⽅便（ Java 语⾔诞⽣本身就是为简化⽹络编程设计的，因此 Java 语
⾔不仅⽀持⽹络编程⽽且很⽅便）；
8. 编译与解释并存；
修正（参⻅： issue#544 ）： C++11 开始（ 2011 年的时候） ,C++ 就引⼊了多线程库，在
windows 、 linux 、 macos 都可以使⽤ std::thread 和 std::async 来创建线程。参考链接： http:/
/www.cplusplus.com/reference/thread/thread/?kw=thread 2.1.3. 关于 JVM JDK 和 JRE 最详细通俗的解答
2.1.3.1. JVM
Java 虚拟机（ JVM ）是运⾏ Java 字节码的虚拟机。 JVM 有针对不同系统的特定实现
（ Windows ， Linux ， macOS ），⽬的是使⽤相同的字节码，它们都会给出相同的结果。
什么是字节码 ? 采⽤字节码的好处是什么 ?
在 Java 中， JVM 可以理解的代码就叫做 （即扩展名为 .class 的⽂件），它不⾯
向任何特定的处理器，只⾯向虚拟机。 Java 语⾔通过字节码的⽅式，在⼀定程度上解决了
传统解释型语⾔执⾏效率低的问题，同时⼜保留了解释型语⾔可移植的特点。所以 Java 程
序运⾏时⽐⾼效，⽽且，由于字节码并不针对⼀种特定的机器，因此， Java 程序⽆须重
新编译便可在多种不同操作系统的计算机上运⾏。
Java 程序从源代码到运⾏⼀般有下⾯ 3 步：
我们需要格外注意的是 .class-> 机器码 这⼀步。在这⼀步 JVM 类加载器⾸先加载字节码⽂件，
然后通过解释器逐⾏解释执⾏，这种⽅式的执⾏速度会相对⽐慢。⽽且，有些⽅法和代码块是
经常需要被调⽤的 ( 也就是所谓的热点代码 ) ，所以后⾯引进了 JIT 编译器，⽽ JIT 属于运⾏时编
译。当 JIT 编译器完成第⼀次编译后，其会将字节码对应的机器码保存下来，下次可以直接使
⽤。⽽我们知道，机器码的运⾏效率肯定是⾼于 Java 解释器的。这也解释了我们为什么经常会
说 Java 是编译与解释共存的语⾔。
HotSpot 采⽤了惰性评估 (Lazy Evaluation) 的做法，根据⼆⼋定律，消耗⼤部分系统资源的
只有那⼀⼩部分的代码（热点代码），⽽这也就是 JIT 所需要编译的部分。 JVM 会根据代
码每次被执⾏的情况收集信息并相应地做出⼀些优化，因此执⾏的次数越多，它的速度就越
快。 JDK 9 引⼊了⼀种新的编译模式 AOT(Ahead of Time Compilation) ，它是直接将字节码
编译成机器码，这样就避免了 JIT 预热等各⽅⾯的开销。 JDK ⽀持分层编译和 AOT 协作使
⽤。但是 ， AOT 编译器的编译质量是肯定⽐不上 JIT 编译器的。
总结： Java 虚拟机（ JVM ）是运⾏ Java 字节码的虚拟机。 JVM 有针对不同系统的特定实现
（ Windows ， Linux ， macOS ），⽬的是使⽤相同的字节码，它们都会给出相同的结果。字节码
和不同系统的 JVM 实现是 Java 语⾔ “ ⼀次编译，随处可以运⾏ ” 的关键所在。
2.1.3.2. JDK 和 JRE
JDK 是 Java Development Kit ，它是功能⻬全的 Java SDK 。它拥有 JRE 所拥有的⼀切，还有编
译器（ javac ）和⼯具（如 javadoc 和 jdb ）。它能够创建和编译程序。
JRE 是 Java 运⾏时环境。它是运⾏已编译 Java 程序所需的所有内容的集合，包括 Java 虚拟机
（ JVM ）， Java 类库， java 命令和其他的⼀些基础构件。但是，它不能⽤于创建新程序。
如果你只是为了运⾏⼀下 Java 程序的话，那么你只需要安装 JRE 就可以了。如果你需要进⾏⼀
些 Java 编程⽅⾯的⼯作，那么你就需要安装 JDK 了。但是，这不是绝对的。有时，即使您不打
算在计算机上进⾏任何 Java 开发，仍然需要安装 JDK 。例如，如果要使⽤ JSP 部署 Web 应⽤
程序，那么从技术上讲，您只是在应⽤程序服务器中运⾏ Java 程序。那你为什么需要 JDK 呢？
因为应⽤程序服务器会将 JSP 转换为 Java servlet ，并且需要使⽤ JDK 来编译 servlet 。
2.1.4. Oracle JDK 和 OpenJDK 的对⽐
可能在看这个问题之前很多⼈和我⼀样并没有接触和使⽤过 OpenJDK 。那么 Oracle 和
OpenJDK 之间是否存在重⼤差异？下⾯我通过收集到的⼀些资料，为你解答这个被很多⼈忽视
的问题。
对于 Java 7 ，没什么关键的地⽅。 OpenJDK 项⽬主要基于 Sun 捐赠的 HotSpot 源代码。此外，
OpenJDK 被选为 Java 7 的参考实现，由 Oracle ⼯程师维护。关于 JVM ， JDK ， JRE 和
OpenJDK 之间的区别， Oracle 博客帖⼦在 2012 年有⼀个更详细的答案：
问： OpenJDK 存储库中的源代码与⽤于构建 Oracle JDK 的代码之间有什么区别？
答：⾮常接近 - 我们的 Oracle JDK 版本构建过程基于 OpenJDK 7 构建，只添加了⼏个部
分，例如部署代码，其中包括 Oracle 的 Java 插件和 Java WebStart 的实现，以及⼀些封
闭的源代码派对组件，如图形光栅化器，⼀些开源的第三⽅组件，如 Rhino ，以及⼀些零碎
的东⻄，如附加⽂档或第三⽅字体。展望未来，我们的⽬的是开源 Oracle JDK 的所有部
分，除了我们考虑商业功能的部分。
总结：
1. Oracle JDK ⼤概每 6 个⽉发⼀次主要版本，⽽ OpenJDK 版本⼤概每三个⽉发布⼀次。但
这不是固定的，我觉得了解这个没啥⽤处。详情参⻅： https://blogs.oracle.com/java-platfor
m-group/update-and-faq-on-the-java-se-release-cadence 。
2. OpenJDK 是⼀个参考模型并且是完全开源的，⽽ Oracle JDK 是 OpenJDK 的⼀个实现，并 不是完全开源的；
3. Oracle JDK ⽐ OpenJDK 更稳定。 OpenJDK 和 Oracle JDK 的代码⼏乎相同，但 Oracle
JDK 有更多的类和⼀些错误修复。因此，如果您想开发企业 / 商业软件，我建议您选择
Oracle JDK ，因为它经过了彻底的测试和稳定。某些情况下，有些⼈提到在使⽤ OpenJDK
可能会遇到了许多应⽤程序崩溃的问题，但是，只需切换到 Oracle JDK 就可以解决问题；
4. 在响应性和 JVM 性能⽅⾯， Oracle JDK 与 OpenJDK 相⽐提供了更好的性能；
5. Oracle JDK 不会为即将发布的版本提供⻓期⽀持，⽤户每次都必须通过更新到最新版本获
得⽀持来获取最新版本；
6. Oracle JDK 根据⼆进制代码许可协议获得许可，⽽ OpenJDK 根据 GPL v2 许可获得许可。
2.1.5. Java 和 C++ 的区别 ?
我知道很多⼈没学过 C++ ，但是⾯试官就是没事喜欢拿咱们 Java 和 C++ ⽐呀！没办法！！！就
算没学过 C++ ，也要记下来！
都是⾯向对象的语⾔，都⽀持封装、继承和多态
Java 不提供指针来直接访问内存，程序内存更加安全
Java 的类是单继承的， C++ ⽀持多重继承；虽然 Java 的类不可以多继承，但是接⼝可以多
继承。
Java 有⾃动内存管理机制，不需要程序员⼿动释放⽆⽤内存
在 C 语⾔中，字符串或字符数组最后都会有⼀个额外的字符 ‘\0’ 来表示结束。但是， Java 语
⾔中没有结束符这⼀概念。 这是⼀个值得深度思考的问题，具体原因推荐看这篇⽂章：
2.1.6. 字符型常量和字符串常量的区别 ?
1. 形式上 : 字符常量是单引号引起的⼀个字符 ; 字符串常量是双引号引起的若⼲个字符
2. 含义上 : 字符常量相当于⼀个整型值 ( ASCII 值 ), 可以参加表达式运算 ; 字符串常量代表⼀个地
址值 ( 该字符串在内存中存放位置 )
3. 占内存⼤⼩ 字符常量只占 2 个字节 ; 字符串常量占若⼲个字节 ( 注意： char 在 Java 中占两
个字节 ) java 编程思想第四版： 2.2.2 节
2.1.7. 构造器 Constructor 是否可被 override?
Constructor 不能被 override （重写） , 但是可以 overload （重载） , 所以你可以看到⼀个类中有多
个构造函数的情况。
2.1.8. 重载和重写的区别
重载就是同样的⼀个⽅法能够根据输⼊数据的不同，做出不同的处理
重写就是当⼦类继承⾃⽗类的相同⽅法，输⼊数据⼀样，但要做出有别于⽗类的响应时，你
就要覆盖⽗类⽅法
重载：
发⽣在同⼀个类中，⽅法名必须相同，参数类型不同、个数不同、顺序不同，⽅法返回值和访问
修饰符可以不同。
下⾯是《 Java 核⼼技术》对重载这个概念的介绍： 综上：重载就是同⼀个类中多个同名⽅法根据不同的传参来执⾏不同的逻辑处理。
重写：
重写发⽣在运⾏期，是⼦类对⽗类的允许访问的⽅法的实现过程进⾏重新编写。
1. 返回值类型、⽅法名、参数列表必须相同，抛出的异常范围⼩于等于⽗类，访问修饰符范围
⼤于等于⽗类。
2. 如果⽗类⽅法访问修饰符为 private/final/static 则⼦类就不能重写该⽅法，但是被 static 修饰
的⽅法能够被再次声明。
3. 构造⽅法⽆法被重写
综上：重写就是⼦类对⽗类⽅法的重新改造，外部样⼦不能改变，内部逻辑可以改变
暖⼼的 Guide 哥最后再来个图表总结⼀下！
⽅法的重写要遵循 “ 两同两⼩⼀⼤ ” （以下内容摘录⾃《疯狂 Java 讲义》 , issue#892 ）：
“ 两同 ” 即⽅法名相同、形参列表相同；
“ 两⼩ ” 指的是⼦类⽅法返回值类型应⽐⽗类⽅法返回值类型更⼩或相等，⼦类⽅法声明抛出
的异常类应⽐⽗类⽅法声明抛出的异常类更⼩或相等；
“ ⼀⼤ ” 指的是⼦类⽅法的访问权限应⽐⽗类⽅法的访问权限更⼤或相等。
2.1.9. Java ⾯向对象编程三⼤特性 : 封装 继承 多态
2.1.9.1. 封装
封装把⼀个对象的属性私有化，同时提供⼀些可以被外界访问的属性的⽅法，如果属性不想被外
界访问，我们⼤可不必提供⽅法给外界访问。但是如果⼀个类没有提供给外界访问的⽅法，那么
这个类也没有什么意义了。
2.1.9.2. 继承
继承是使⽤已存在的类的定义作为基础建⽴新类的技术，新类的定义可以增加新的数据或新的功
能，也可以⽤⽗类的功能，但不能选择性地继承⽗类。通过使⽤继承我们能够⾮常⽅便地复⽤以
前的代码。
关于继承如下 3 点请记住：
1. ⼦类拥有⽗类对象所有的属性和⽅法（包括私有属性和私有⽅法），但是⽗类中的私有属性
和⽅法⼦类是⽆法访问， 只是拥有 。
2. ⼦类可以拥有⾃⼰属性和⽅法，即⼦类可以对⽗类进⾏扩展。
3. ⼦类可以⽤⾃⼰的⽅式实现⽗类的⽅法。（以后介绍）。
2.1.9.3. 多态
所谓多态就是指程序中定义的引⽤变量所指向的具体类型和通过该引⽤变量发出的⽅法调⽤在编
程时并不确定，⽽是在程序运⾏期间才确定，即⼀个引⽤变量到底会指向哪个类的实例对象，该
引⽤变量发出的⽅法调⽤到底是哪个类中实现的⽅法，必须在由程序运⾏期间才能决定。
在 Java 中有两种形式可以实现多态：继承（多个⼦类对同⼀⽅法的重写）和接⼝（实现接⼝并
覆盖接⼝中同⼀⽅法）。 Man();
}
} 2.1.10. String StringBuffer 和 StringBuilder 的区别是什么 ?
String 为什么是不可变的 ?
可变性
简单的来说： String 类中使⽤ final 关键字修饰字符数组来保存字符串， private final char
value[] ，所以 String 对象是不可变的。
补充（来⾃ issue 675 ）：在 Java 9 之后， String 类的实现改⽤ byte 数组存储字符串
private final byte[] value
⽽ StringBuilder 与 StringBuffer 都继承⾃ AbstractStringBuilder 类，在 AbstractStringBuilder 中
也是使⽤字符数组保存字符串 char[]value 但是没有⽤ final 关键字修饰，所以这两种对象都是可
变的。
StringBuilder 与 StringBuffer 的构造⽅法都是调⽤⽗类构造⽅法也就是 AbstractStringBuilder 实
现的，⼤家可以⾃⾏查阅源码。 acity];
} String 中的对象是不可变的，也就可以理解为常量，线程安全。 AbstractStringBuilder 是
StringBuilder 与 StringBuffer 的公共⽗类，定义了⼀些字符串的基本操作，如 expandCapacity 、
append 、 insert 、 indexOf 等公共⽅法。 StringBuffer 对⽅法加了同步锁或者对调⽤的⽅法加了同
步锁，所以是线程安全的。 StringBuilder 并没有对⽅法进⾏加同步锁，所以是⾮线程安全的。
性能
每次对 String 类型进⾏改变的时候，都会⽣成⼀个新的 String 对象，然后将指针指向新的 String
对象。 StringBuffer 每次都会对 StringBuffer 对象本身进⾏操作，⽽不是⽣成新的对象并改变对象
引⽤。相同情况下使⽤ StringBuilder 相⽐使⽤ StringBuffer 仅能获得 10%~15% 左右的性能提
升，但却要冒多线程不安全的⻛险。
对于三者使⽤的总结：
1. 操作少量的数据 : 适⽤ String
2. 单线程操作字符串缓冲区下操作⼤量数据 : 适⽤ StringBuilder
3. 多线程操作字符串缓冲区下操作⼤量数据 : 适⽤ StringBuffer
2.1.11. ⾃动装箱与拆箱
装箱 ：将基本类型⽤它们对应的引⽤类型包装起来；
拆箱 ：将包装类型转换为基本数据类型；
更多内容⻅： 深⼊剖析 Java 中的装箱和拆箱
2.1.12. 在⼀个静态⽅法内调⽤⼀个⾮静态成员为什么是⾮法的 ?
由于静态⽅法可以不通过对象进⾏调⽤，因此在静态⽅法⾥，不能调⽤其他⾮静态变量，也不可
以访问⾮静态变量成员。
2.1.13. 在 Java 中定义⼀个不做事且没有参数的构造⽅法的作⽤
Java 程序在执⾏⼦类的构造⽅法之前，如果没有⽤ super() 来调⽤⽗类特定的构造⽅法，则会调
⽤⽗类中 “ 没有参数的构造⽅法 ” 。因此，如果⽗类中只定义了有参数的构造⽅法，⽽在⼦类的构
造⽅法中⼜没有⽤ super() 来调⽤⽗类中特定的构造⽅法，则编译时将发⽣错误，因为 Java 程
序在⽗类中找不到没有参数的构造⽅法可供执⾏。解决办法是在⽗类⾥加上⼀个不做事且没有参
数的构造⽅法。
2.1.14. 接⼝和抽象类的区别是什么？
1. 接⼝的⽅法默认是 public ，所有⽅法在接⼝中不能有实现 (Java 8 开始接⼝⽅法可以有默认
实现），⽽抽象类可以有⾮抽象的⽅法。
2. 接⼝中除了 static 、 final 变量，不能有其他变量，⽽抽象类中则不⼀定。
3. ⼀个类可以实现多个接⼝，但只能实现⼀个抽象类。接⼝⾃⼰本身可以通过 extends 关键
字扩展多个接⼝。
4. 接⼝⽅法默认修饰符是 public ，抽象⽅法可以有 public 、 protected 和 default 这些修饰
符（抽象⽅法就是为了被重写所以不能使⽤ private 关键字修饰！）。
5. 从设计层⾯来说，抽象是对类的抽象，是⼀种模板设计，⽽接⼝是对⾏为的抽象，是⼀种⾏
为的规范。
备注：
1. 在 JDK8 中，接⼝也可以定义静态⽅法，可以直接⽤接⼝名调⽤。实现类和实现是不
可以调⽤的。如果同时实现两个接⼝，接⼝中定义了⼀样的默认⽅法，则必须重写，不
然会报错。 ( 详⻅ issue: https://github.com/Snailclimb/JavaGuide/issues/146 。
2. jdk9 的接⼝被允许定义私有⽅法 。
总结⼀下 jdk7~jdk9 Java 中接⼝概念的变化（ 相关阅读 ）：
1. 在 jdk 7 或更早版本中，接⼝⾥⾯只能有常量变量和抽象⽅法。这些接⼝⽅法必须由选择实
现接⼝的类实现。
2. jdk 8 的时候接⼝可以有默认⽅法和静态⽅法功能。
3. Jdk 9 在接⼝中引⼊了私有⽅法和私有静态⽅法。
2.1.15. 成员变量与局部变量的区别有哪些？
1. 从语法形式上看 : 成员变量是属于类的，⽽局部变量是在⽅法中定义的变量或是⽅法的参数；
成员变量可以被 public , private , static 等修饰符所修饰，⽽局部变量不能被访问控制修饰
符及 static 所修饰；但是，成员变量和局部变量都能被 final 所修饰。
2. 从变量在内存中的存储⽅式来看 : 如果成员变量是使⽤ static 修饰的，那么这个成员变量是属
于类的，如果没有使⽤ static 修饰，这个成员变量是属于实例的。对象存于堆内存，如果局
部变量类型为基本数据类型，那么存储在栈内存，如果为引⽤数据类型，那存放的是指向堆
内存对象的引⽤或者是指向常量池中的地址。
3. 从变量在内存中的⽣存时间上看 : 成员变量是对象的⼀部分，它随着对象的创建⽽存在，⽽局
部变量随着⽅法的调⽤⽽⾃动消失。
4. 成员变量如果没有被赋初值 : 则会⾃动以类型的默认值⽽赋值（⼀种情况例外 : 被 final 修饰
的成员变量也必须显式地赋值），⽽局部变量则不会⾃动赋值。 2.1.16. 创建⼀个对象⽤什么运算符 ? 对象实体与对象引⽤有何不同 ?
new 运算符， new 创建对象实例（对象实例在堆内存中），对象引⽤指向对象实例（对象引⽤存
放在栈内存中）。⼀个对象引⽤可以指向 0 个或 1 个对象（⼀根绳⼦可以不系⽓球，也可以系⼀
个⽓球） ; ⼀个对象可以有 n 个引⽤指向它（可以⽤ n 条绳⼦系住⼀个⽓球）。
2.1.17. 什么是⽅法的返回值 ? 返回值在类的⽅法⾥的作⽤是什么 ?
⽅法的返回值是指我们获取到的某个⽅法体中的代码执⾏后产⽣的结果！（前提是该⽅法可能产
⽣结果）。返回值的作⽤ : 接收出结果，使得它可以⽤于其他的操作！
2.1.18. ⼀个类的构造⽅法的作⽤是什么 ? 若⼀个类没有声明构造⽅
法，该程序能正确执⾏吗 ? 为什么 ?
主要作⽤是完成对类对象的初始化⼯作。可以执⾏。因为⼀个类即使没有声明构造⽅法也会有默
认的不带参数的构造⽅法。
2.1.19. 构造⽅法有哪些特性？
1. 名字与类名相同。
2. 没有返回值，但不能⽤ void 声明构造函数。
3. ⽣成类的对象时⾃动执⾏，⽆需调⽤。
2.1.20. 静态⽅法和实例⽅法有何不同
1. 在外部调⽤静态⽅法时，可以使⽤ " 类名 . ⽅法名 " 的⽅式，也可以使⽤ " 对象名 . ⽅法名 " 的⽅
式。⽽实例⽅法只有后⾯这种⽅式。也就是说，调⽤静态⽅法可以⽆需创建对象。
2. 静态⽅法在访问本类的成员时，只允许访问静态成员（即静态成员变量和静态⽅法），⽽不
允许访问实例成员变量和实例⽅法；实例⽅法则⽆此限制。
2.1.21. 对象的相等与指向他们的引⽤相等 , 两者有什么不同 ?
对象的相等，⽐的是内存中存放的内容是否相等。⽽引⽤相等，⽐的是他们指向的内存地址是
否相等。
2.1.22. 在调⽤⼦类构造⽅法之前会先调⽤⽗类没有参数的构造⽅法 ,
其⽬的是 ?
帮助⼦类做初始化⼯作。 2.1.23. == 与 equals( 重要 )
== : 它的作⽤是判断两个对象的地址是不是相等。即，判断两个对象是不是同⼀个对象 ( 基本数据
类型 == ⽐的是值，引⽤数据类型 == ⽐的是内存地址 ) 。
equals() : 它的作⽤也是判断两个对象是否相等。但它⼀般有两种使⽤情况：
情况 1 ：类没有覆盖 equals() ⽅法。则通过 equals() ⽐该类的两个对象时，等价于通过
“==” ⽐这两个对象。
情况 2 ：类覆盖了 equals() ⽅法。⼀般，我们都覆盖 equals() ⽅法来⽐两个对象的内容是
否相等；若它们的内容相等，则返回 true ( 即，认为这两个对象相等 ) 。
举个例⼦：
说明：
String 中的 equals ⽅法是被重写过的，因为 object 的 equals ⽅法是⽐的对象的内存地
址，⽽ String 的 equals ⽅法⽐的是对象的值。
当创建 String 类型的对象时，虚拟机会在常量池中查找有没有已经存在的值和要创建的值相
同的对象，如果有就把它赋给当前引⽤。如果没有就在常量池中重新创建⼀个 String 对象。
} 2.1.24. hashCode 与 equals ( 重要 )
⾯试官可能会问你： “ 你重写过 hashcode 和 equals 么，为什么重写 equals 时必须重写
hashCode ⽅法？ ”
1)hashCode() 介绍 :
hashCode() 的作⽤是获取哈希码，也称为散列码；它实际上是返回⼀个 int 整数。这个哈希码的
作⽤是确定该对象在哈希表中的索引位置。 hashCode() 定义在 JDK 的 Object 类中，这就意味
着 Java 中的任何类都包含有 hashCode() 函数。另外需要注意的是： Object 的 hashcode ⽅法
是本地⽅法，也就是⽤ c 语⾔或 c++ 实现的，该⽅法通常⽤来将对象的 内存地址 转换为整数之
后返回。
散列表存储的是键值对 (key-value) ，它的特点是：能根据 “ 键 ” 快速的检索出对应的 “ 值 ” 。这其中就
利⽤到了散列码！（可以快速找到所需要的对象）
2) 为什么要有 hashCode ？
我们以 “ HashSet 如何检查重复 ” 为例⼦来说明为什么要有 hashCode ？
当你把对象加⼊ HashSet 时， HashSet 会先计算对象的 hashcode 值来判断对象加⼊的位置，
同时也会与其他已经加⼊的对象的 hashcode 值作⽐，如果没有相符的 hashcode ， HashSet
会假设对象没有重复出现。但是如果发现有相同 hashcode 值的对象，这时会调⽤ equals() ⽅
法来检查 hashcode 相等的对象是否真的相同。如果两者相同， HashSet 就不会让其加⼊操作成
功。如果不同的话，就会重新散列到其他位置。（摘⾃我的 Java 启蒙书《 Head First Java 》第
⼆版）。这样我们就⼤⼤减少了 equals 的次数，相应就⼤⼤提⾼了执⾏速度。
3) 为什么重写 equals 时必须重写 hashCode ⽅法？
如果两个对象相等，则 hashcode ⼀定也是相同的。两个对象相等 , 对两个对象分别调⽤ equals
⽅法都返回 true 。但是，两个对象有相同的 hashcode 值，它们也不⼀定是相等的 。 因此，
equals ⽅法被覆盖过，则 hashCode ⽅法也必须被覆盖。
hashCode() 的默认⾏为是对堆上的对象产⽣独特值。如果没有重写 hashCode() ，则该
class 的两个对象⽆论如何都不会相等（即使这两个对象指向相同的数据）
4) 为什么两个对象有相同的 hashcode 值，它们也不⼀定是相等的？
public native int hashCode(); 在这⾥解释⼀位⼩伙伴的问题。以下内容摘⾃《 Head Fisrt Java 》。
因为 hashCode() 所使⽤的杂凑算法也许刚好会让多个对象传回相同的杂凑值。越糟糕的杂凑算
法越容易碰撞，但这也与数据值域分布的特性有关（所谓碰撞也就是指的是不同的对象得到相同
的 hashCode 。
我们刚刚也提到了 HashSet , 如果 HashSet 在对⽐的时候，同样的 hashcode 有多个对象，它会
使⽤ equals() 来判断是否真的相同。也就是说 hashcode 只是⽤来缩⼩查找成本。
更多关于 hashcode() 和 equals() 的内容可以查看： Java hashCode() 和 equals() 的若⼲问题解
答
2.1.25. 为什么 Java 中只有值传递？
⾸先回顾⼀下在程序设计语⾔中有关将参数传递给⽅法（或函数）的⼀些专业术语。 按值调⽤
(call by value) 表示⽅法接收的是调⽤者提供的值，⽽按引⽤调⽤（ call by reference) 表示⽅法
接收的是调⽤者提供的变量地址。⼀个⽅法可以修改传递引⽤所对应的变量值，⽽不能修改传递
值调⽤所对应的变量值。 它⽤来描述各种程序设计语⾔（不只是 Java) 中⽅法参数传递⽅式。
Java 程序设计语⾔总是采⽤按值调⽤。也就是说，⽅法得到的是所有参数值的⼀个拷⻉，也就
是说，⽅法不能修改传递给它的任何参数变量的内容。
2.1.26. 简述线程、程序、进程的基本概念。以及他们之间关系是什
么 ?
线程 与进程相似，但线程是⼀个⽐进程更⼩的执⾏单位。⼀个进程在其执⾏的过程中可以产⽣多
个线程。与进程不同的是同类的多个线程共享同⼀块内存空间和⼀组系统资源，所以系统在产⽣
⼀个线程，或是在各个线程之间作切换⼯作时，负担要⽐进程⼩得多，也正因为如此，线程也被
称为轻量级进程。
程序 是含有指令和数据的⽂件，被存储在磁盘或其他的数据存储设备中，也就是说程序是静态的
代码。
进程 是程序的⼀次执⾏过程，是系统运⾏程序的基本单位，因此进程是动态的。系统运⾏⼀个程
序即是⼀个进程从创建，运⾏到消亡的过程。简单来说，⼀个进程就是⼀个执⾏中的程序，它在
计算机中⼀个指令接着⼀个指令地执⾏着，同时，每个进程还占有某些系统资源如 CPU 时间，
内存空间，⽂件，输⼊输出设备的使⽤权等等。换句话说，当程序在执⾏时，将会被操作系统载
⼊内存中。
线程是进程划分成的更⼩的运⾏单位。线程和进程最⼤的不同在于基本上各进程是独⽴的，⽽各
线程则不⼀定，因为同⼀进程中的线程极有可能会相互影响。从另⼀⻆度来说，进程属于操作系
统的范畴，主要是同⼀段时间内，可以同时执⾏⼀个以上的程序，⽽线程则是在同⼀程序内⼏乎
同时执⾏⼀个以上的程序段
本文含有隐藏内容，请 开通VIP 后查看