Java面试题对象相等判断

朱雀 2023-10-09 20:02 111阅读 0赞

**对象相等判断**

**==** **和** **equals** **的区别是什么**

== : 它的作用是判断两个对象的地址是不是相等。即，判断两个对象是不是同 一个对象。(基本数据类型

== 比较的是值，引用数据类型 == 比较的是内存地址)

equals() : 它的作用也是判断两个对象是否相等。但它一般有两种使用情况： 情况1：类没有覆盖

equals() 方法。则通过 equals() 比较该类的两个对象时， 等价于通过“==”比较这两个对象。

情况2：类覆盖了 equals() 方法。一般，我们都覆盖 equals() 方法来两个对象 的内容相等；若它们的内

容相等，则返回 true (即，认为这两个对象相等)。

举个例子：

说明：

String中的equals方法是被重写过的，因为object的equals方法是比较的对象的 内存地址，而

String的equals方法比较的是对象的值。

当创建String类型的对象时，虚拟机会在常量池中查找有没有已经存在的值和要 创建的值相同的对

象，如果有就把它赋给当前引用。如果没有就在常量池中重新创建 一个String对象。

1 public class test1 \{

2 public static void main(String\[\] args) \{

3 String a = new String("ab"); // a 为一个引用

4 String b = new String("ab"); // b为另一个引用,对象的内容一样

5 String aa = "ab"; // 放在常量池中

6 String bb = "ab"; // 从常量池中查找

7 if (aa == bb) // true

8 System.out.println("aa==bb");

9 if (a == b) // false，非同一对象

10 System.out.println("a==b");

11 if (a.equals(b)) // true

12 System.out.println("aEQb");

13 if (42 == 42.0) \{ // true

14 System.out.println("true");

15 \}

16 \}

17 \}**hashCode** **与** **equals (****重要****)**

HashSet如何检查重复

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

hashCode和equals方法的关系

面试官可能会问你：“你重写过 hashcode 和 equals 么，为什么重写equals时 必须重写hashCode方

法？”

**hashCode()****介绍**

hashCode() 的作用是获取哈希码，也称为散列码；它实际上是返回一个int整 数。这个哈希码的作用是

确定该对象在哈希表中的索引位置。hashCode() 定义 在JDK的Object.java中，这就意味着Java中的任何

类都包含有hashCode()函数。

散列表存储的是键值对(key-value)，它的特点是：能根据“键”快速的检索出 对应的“值”。这其中就利用

到了散列码！（可以快速找到所需要的对象）

**为什么要有** **hashCode**

**我们以****“HashSet** **如何检查重复****”****为例子来说明为什么要有** **hashCode****：**

当你把对象加入 HashSet 时，HashSet 会先计算对象的 hashcode 值来判断对 象加入的位置，同时也

会与其他已经加入的对象的 hashcode 值作比较，如果 没有相符的hashcode，HashSet会假设对象没

有重复出现。但是如果发现有相 同 hashcode 值的对象，这时会调用 equals()方法来检查 hashcode 相

等的对 象是否真的相同。如果两者相同，HashSet 就不会让其加入操作成功。如果不 同的话，就会重

新散列到其他位置。（摘自我的Java启蒙书《Head first java》 第二版）。这样我们就大大减少了

equals 的次数，相应就大大提高了执行速 度。

**hashCode()****与****equals()****的相关规定**

如果两个对象相等，则hashcode一定也是相同的 两个对象相等，对两个对象分别调用equals方法都返

回true 两个对象有相同的hashcode值，它们也不一定是相等的

**因此，****equals** **方法被覆盖过，则** **hashCode** **方法也必须被覆盖**

hashCode() 的默认行为是对堆上的对象产生独特值。如果没有重写

hashCode()，则该 class 的两个对象无论如何都不会相等（即使这两个对象指 向相同的数据）

**对象的相等与指向他们的引用相等，两者有什么不同？**

对象的相等 比的是内存中存放的内容是否相等而 引用相等 比较的是他们指向的 内存地址是否相等。

**值传递**

**当一个对象被当作参数传递到一个方法后，此方法可改变这个对 象的**

**属性，并可返回变化后的结果，那么这里到底是值传递还是 引用传递**

是值传递。Java 语言的方法调用只支持参数的值传递。当一个对象实例作为一 个参数被传递到方法中

时，参数的值就是对该对象的引用。对象的属性可以在被 调用过程中被改变，但对对象引用的改变是不

会影响到调用者的**为什么** **Java** **中只有值传递**

首先回顾一下在程序设计语言中有关将参数传递给方法（或函数）的一些专业术 语。**按值调用****(call by**

**value)****表示方法接收的是调用者提供的值，而按引用调用 （****call by reference)****表示方法接收的是调用**

**者提供的变量地址。一个方法可以 修改传递引用所对应的变量值，而不能修改传递值调用所对应的变量**

**值。** 它用 来描述各种程序设计语言（不只是Java)中方法参数传递方式。

**Java****程序设计语言总是采用按值调用。也就是说，方法得到的是所有参数值的 一个拷贝，也就是说，**

**方法不能修改传递给它的任何参数变量的内容。**

下面通过 3 个例子来给大家说明

example 1

结果：

解析：

1 public static void main(String\[\] args) \{

2 int num1 = 10;

3 int num2 = 20;

5 swap(num1, num2);

7 System.out.println("num1 = " + num1);

8 System.out.println("num2 = " + num2);

9 \}

11 public static void swap(int a, int b) \{

12 int temp = a;

13 a = b;

14 b = temp;

16 System.out.println("a = " + a);

17 System.out.println("b = " + b);

18 \}

1 a = 20

2 b = 10

3 num1 = 10

4 num2 = 20在swap方法中，a、b的值进行交换，并不会影响到 num1、num2。因为，a、 b中的值，只是从

num1、num2 的复制过来的。也就是说，a、b相当于 num1、num2 的副本，副本的内容无论怎么修

改，都不会影响到原件本身。

通过上面例子，我们已经知道了一个方法不能修改一个基本数据类型的参数，而 对象引用作为参数就不

一样，请看 example2.

example 2

1 public static void main(String\[\] args) \{

2 int\[\] arr = \{ 1, 2, 3, 4, 5 \};

3 System.out.println(arr\[0\]);

4 change(arr);

5 System.out.println(arr\[0\]);

6 \}

8 public static void change(int\[\] array) \{

9 // 将数组的第一个元素变为0

10 array\[0\] = 0;

11 \}

结果：

1 1

2 0

解析：array 被初始化 arr 的拷贝也就是一个对象的引用，也就是说 array 和 arr 指向 的时同一个数组对象。

因此，外部对引用对象的改变会反映到所对应的对象 上。

通过 example2 我们已经看到，实现一个改变对象参数状态的方法并不是一件 难事。理由很简单，方法

得到的是对象引用的拷贝，对象引用及其他的拷贝同时 引用同一个对象。

很多程序设计语言（特别是，C++和Pascal)提供了两种参数传递的方式：值调 用和引用调用。有些程序

员（甚至本书的作者）认为Java程序设计语言对对象 采用的是引用调用，实际上，这种理解是不对的。

由于这种误解具有一定的普遍 性，所以下面给出一个反例来详细地阐述一下这个问题。

example 3

1 public class Test \{

3 public static void main(String\[\] args) \{

4 // TODO Auto\-generated method stub

5 Student s1 = new Student("小张");

6 Student s2 = new Student("小李");

7 Test.swap(s1, s2);

8 System.out.println("s1:" + s1.getName());

9 System.out.println("s2:" + s2.getName());

10 \}

12 public static void swap(Student x, Student y) \{

13 Student temp = x;

14 x = y;

15 y = temp;

16 System.out.println("x:" + x.getName());

17 System.out.println("y:" + y.getName());

18 \}

19 \}

结果：

1 x:小李

2 y:小张

3 s1:小张

4 s2:小李

解析：

交换之前：交换之后：

通过上面两张图可以很清晰的看出： 方法并没有改变存储在变量 s1 和 s2 中的 对象引用。swap方法的

参数x和y被初始化为两个对象引用的拷贝，这个方法交 换的是这两个拷贝

总结

Java程序设计语言对对象采用的不是引用调用，实际上，对象引用是按值传递的。

下面再总结一下Java中方法参数的使用情况：

一个方法不能修改一个基本数据类型的参数（即数值型或布尔型》

一个方法可以改变一个对象参数的状态。

一个方法不能让对象参数引用一个新的对象。

**值传递和引用传递有什么区别**

值传递：指的是在方法调用时，传递的参数是按值的拷贝传递，传递的是值的拷 贝，也就是说传递后就

互不相关了。 引用传递：指的是在方法调用时，传递的参数是按引用进行传递，其实传递的引 用的地

址，也就是变量所对应的内存空间的地址。传递的是值的引用，也就是说 传递前和传递后都指向同一个

引用（也就是同一个内存空间）。

**Java****包****JDK** **中常用的包有哪些**

java.lang：这个是系统的基础类；

java.io：这里面是所有输入输出有关的类，比如文件操作等；

java.nio：为了完善 io 包中的功能，提高 io 包中性能而写的一个新包；

java.net：这里面是与网络有关的类；

java.util：这个是系统辅助类，特别是集合类；

java.sql：这个是数据库操作的类。

**import java****和****javax****有什么区别**

刚开始的时候 JavaAPI 所必需的包是 java 开头的包，javax 当时只是扩展 API 包来说使用。然而随着时

间的推移，javax 逐渐的扩展成为 Java API 的组成部 分。但是，将扩展从 javax 包移动到 java 包将是太

麻烦了，最终会破坏一堆现 有的代码。因此，最终决定 javax 包将成为标准API的一部分。 所以，实际

上java和javax没有区别。这都是一个名字。

**IO****流**

**java** **中** **IO** **流分为几种****?**

按照流的流向分，可以分为输入流和输出流； 按照操作单元划分，可以划分为字节流和字符流； 按照流

的角色划分为节点流和处理流。 Java Io流共涉及40多个类，这些类看上去很杂乱，但实际上很有规则，

而且彼 此之间存在非常紧密的联系， Java I0流的40多个类都是从如下4个抽象类基类 中派生出来的。

InputStream/Reader: 所有的输入流的基类，前者是字节输入流，后者是字符 输入流。

OutputStream/Writer: 所有输出流的基类，前者是字节输出流，后者是字符输 出流。

按操作方式分类结构图：IO 操作方式分类按操作对象分类结构图：**BIO,NIO,AIO** **有什么区别****?**

简答

BIO：Block IO 同步阻塞式 IO，就是我们平常使用的传统 IO，它的特点是模式简单使用方便，并

发处理能力低。

NIO：Non IO 同步非阻塞 IO，是传统 IO 的升级，客户端和服务器端通过

Channel（通道）通讯，实现了多路复用。

AIO：Asynchronous IO 是 NIO 的升级，也叫 NIO2，实现了异步非堵塞 IO

，异步 IO 的操作基于事件和回调机制。

详细回答

BIO (Blocking I/O): 同步阻塞I/O模式，数据的读取写入必须阻塞在一个线程内等待其完成。在活动

连接数不是特别高（小于单机1000）的情况下，这种模型是比较不错的，可以让每一个连接专注于

自己的 I/O 并且编程模型简单，也不用过多考虑系统的过载、限流等问题。线程池本身就是一个天

然的漏斗，可以缓冲一些系统处理不了的连接或请求。但是，当面对十万甚至百万级连接的时候，

传统的 BIO 模型是无能为力的。因此，我们需要一种更高效的 I/O 处理模型来应对更高的并发量。

NIO (New I/O): NIO是一种同步非阻塞的I/O模型，在Java 1.4 中引入了NIO框架，对应 java.nio

包，提供了 Channel , Selector，Buffer等抽象。NIO中的 N可以理解为Non-blocking，不单纯是

New。它支持面向缓冲的，基于通道的I/O操作方法。 NIO提供了与传统BIO模型中的 Socket 和

ServerSocket 相对应的 SocketChannel 和 ServerSocketChannel 两种不同的套接字通道实现,两

种通道都支持阻塞和非阻塞两种模式。阻塞模式使用就像传统中的支持一样，比较简单，但是性能

和可靠性都不好；非阻塞模式正好与之相反。对于低负载、低并发的应用程序，可以使用同步阻塞

I/O来提升开发速率和更好的维护性；对于高负载、高并发的（网络）应用，应使用 NIO 的非阻塞

模式来开发

AIO (Asynchronous I/O): AIO 也就是 NIO 2。在 Java 7 中引入了 NIO 的改进版 NIO 2,它是异步非

阻塞的IO模型。异步 IO 是基于事件和回调机制实现的，也就是应用操作之后会直接返回，不会堵

塞在那里，当后台处理完成，操作系统会通知相应的线程进行后续的操作。AIO 是异步IO的缩写，

虽然 NIO 在网络操作中，提供了非阻塞的方法，但是 NIO 的 IO 行为还是同步的。对于 NIO 来

说，我们的业务线程是在 IO 操作准备好时，得到通知，接着就由这个线程自行进行 IO 操作，IO操作本身是同步的。查阅网上相关资料，我发现就目前来说 AIO 的应用还不是很广泛，Netty 之前也

尝试使用过 AIO，不过又放弃了。

**Files****的常用方法都有哪些？**

Files. exists()：检测文件路径是否存在。

Files. createFile()：创建文件。

Files. createDirectory()：创建文件夹。

Files. delete()：删除一个文件或目录。

Files. copy()：复制文件。

Files. move()：移动文件。

Files. size()：查看文件个数。

Files. read()：读取文件。

Files. write()：写入文件。

Java面试题对象相等判断

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 HashMap判断两个对象相等

相关 Java基础系列(二) 对象相等判断

相关严格相等宽松相等【JavaScript基础面试题】

相关 Java面试题对象相等判断

相关 Equals 判断对象相等总结：

相关面试官：为什么不建议用 equals 判断对象相等？

相关 JAVA--HashCode 基础（判断对象是否相等）

相关【面试题】Java String常量相等（==）问题

相关判断java中两个对象是否相等

相关断言判断数组、对象、容器相等