java如何用==判断两个值是否相等 java比较语句的基础教程-java教程-PHP中文网

Java中==对基本类型比较值，对对象比较引用地址；对象内容比较应使用equals()，且重写equals()时必须重写hashCode()以保证哈希集合的正确性。

java如何用==判断两个值是否相等 java比较语句的基础教程

在Java里，

==

登录后复制

这个操作符，说白了，它就是用来比较两个东西是不是“同一个”。对于基本数据类型（比如

int

登录后复制

boolean

登录后复制

double

登录后复制

），它比较的是它们的值是否相等。但对于对象（比如

String

登录后复制

、你自定义的类），它比较的则是这两个引用变量是否指向内存中的同一个对象实例。这听起来简单，却是很多Java初学者甚至一些老手都会偶尔“翻车”的地方，因为我们常常想当然地认为它应该比较“内容”是否一样。

解决方案

要搞清楚Java里

==

登录后复制

的用法，得把基本类型和对象类型分开看，这两种情况下的行为逻辑完全不同。

1. 基本数据类型（Primitive Types）的比较： 当涉及到

int

登录后复制

、

long

登录后复制

、

float

登录后复制

、

double

登录后复制

、

char

登录后复制

、

byte

登录后复制

、

short

登录后复制

、

boolean

登录后复制

这些基本数据类型时，

==

登录后复制

的行为非常直观：它直接比较这两个变量存储的实际数值是否相等。

int a = 10;
int b = 10;
System.out.println(a == b); // 输出 true

char c1 = 'A';
char c2 = 'A';
System.out.println(c1 == c2); // 输出 true

boolean flag1 = true;
boolean flag2 = false;
System.out.println(flag1 == flag2); // 输出 false

登录后复制

这没什么好说的，符合直觉。

2. 对象（Object Types）的比较： 这才是

==

登录后复制

真正让人“头疼”的地方。对于所有非基本数据类型的对象（包括

String

登录后复制

、数组、自定义类的实例，以及包装类如

Integer

登录后复制

、

double

登录后复制

等），

==

登录后复制

比较的不是它们的内容，而是它们在内存中的地址。也就是说，它检查的是这两个引用变量是否指向了内存中的同一个对象。

String s1 = new String("hello");
String s2 = new String("hello");
System.out.println(s1 == s2); // 输出 false

String s3 = "world"; // 字符串字面量，会进入常量池
String s4 = "world"; // s4会引用常量池中与s3相同的对象
System.out.println(s3 == s4); // 输出 true

Object obj1 = new Object();
Object obj2 = new Object();
System.out.println(obj1 == obj2); // 输出 false

// 即使内容相同，只要是两个不同的对象，== 就返回false

登录后复制

你可能会疑惑，

s3 == s4

登录后复制

为什么是

true

登录后复制

？这是因为Java对字符串字面量做了优化，它们会被存储在字符串常量池中，如果内容相同，会复用同一个对象。但通过

new String()

登录后复制

方式创建的字符串，每次都会在堆内存中创建一个新的对象。

立即学习“Java免费学习笔记（深入）”；

所以，如果你想比较两个对象的内容是否相等，几乎总是应该使用它们的

equals()

登录后复制

方法，而不是

==

登录后复制

。

Java中

==

登录后复制

对对象比较的陷阱与原理是什么？

说实话，

==

登录后复制

对于对象来说，它的本意就是判断“身份”是否一致，而不是“内容”是否一致。这其实是个非常底层且高效的判断，因为它只需要比较两个内存地址。但对于我们日常编程，尤其是在处理像

String

登录后复制

这样的“值类型”对象时，往往希望比较的是内容，这就造成了认知上的偏差，进而产生了“陷阱”。

最典型的例子就是字符串。一个初学者写下

if (myString == "某个值")

登录后复制

，往往会得到意想不到的结果。因为

myString

登录后复制

可能是在运行时动态生成的，即使它的字符序列和

"某个值"

登录后复制

一模一样，它们在内存中也可能是两个不同的

String

登录后复制

对象。

String user_input = new Scanner(System.in).nextLine(); // 假设用户输入 "admin"
String expected_value = "admin";

// 这是一个常见的错误示范！
if (user_input == expected_value) {
    System.out.println("匹配成功 (可能是巧合或者字符串常量池的魔术)");
} else {
    System.out.println("匹配失败 (更常见的结果)");
}

// 正确的做法
if (user_input.equals(expected_value)) {
    System.out.println("匹配成功 (内容相等)");
}

登录后复制

这种设计并非Java的“缺陷”，而是其对引用类型和值类型的区分。

==

登录后复制

提供了最基本的引用比较能力，而

equals()

登录后复制

则提供了更高级、可自定义的“值”比较能力。理解这一点，就能避开很多坑。

创客贴设计

创客贴设计，一款智能在线设计工具，设计不求人，AI助你零基础完成专业设计！

150

查看详情

Java中包装类（Wrapper Classes）的

==

登录后复制

比较有何特殊之处？

包装类，比如

Integer

登录后复制

、

long

登录后复制

、

boolean

登录后复制

等，它们是基本数据类型的对象表示。当用

==

登录后复制

比较两个包装类对象时，遵循的是对象比较的规则，即比较引用地址。然而，这里又有一个小小的“陷阱”——缓存机制和自动装箱/拆箱。

Java为了性能优化，对一些常用的包装类值进行了缓存。例如，

Integer

登录后复制

类在

-128

登录后复制

到

登录后复制

之间的值会被缓存。这意味着，如果你创建两个

Integer

登录后复制

对象，它们的值在这个范围内且是通过自动装箱创建的，那么它们很可能引用的是同一个缓存对象。

Integer i1 = 100; // 自动装箱，从缓存获取
Integer i2 = 100; // 自动装箱，从缓存获取
System.out.println(i1 == i2); // 输出 true (因为100在缓存范围内，引用的是同一个对象)

Integer i3 = 200; // 自动装箱，不在缓存范围内，创建新对象
Integer i4 = 200; // 自动装箱，不在缓存范围内，创建新对象
System.out.println(i3 == i4); // 输出 false (两个不同的对象)

// 显式创建新对象，即使值在缓存范围内，也会创建新对象
Integer i5 = new Integer(100);
Integer i6 = new Integer(100);
System.out.println(i5 == i6); // 输出 false

登录后复制

这真的是一个非常隐蔽的坑。我个人就见过不少代码因为不了解这个缓存机制，在比较

Integer

登录后复制

时误用

==

登录后复制

导致偶发性 bug 的。所以，永远建议使用
equals()
登录后复制
方法来比较包装类对象的值，这样可以避免这些由缓存和对象创建方式带来的不确定性。

Integer val1 = 200;
Integer val2 = 200;
System.out.println(val1.equals(val2)); // 输出 true，这是正确的比较方式

登录后复制

何时应该使用

equals()

登录后复制

方法，以及如何正确重写它？

当你需要比较两个对象的“内容”或“语义”是否相等时，就应该使用

equals()

登录后复制

方法。这是Java中所有对象都继承自

Object

登录后复制

类的一个方法，它的默认实现和

==

登录后复制

一样，也是比较引用地址。因此，对于自定义的类，如果你希望它们在内容相同时被认为是相等的，你就必须重写

equals()

登录后复制

方法。

何时使用

equals()

登录后复制

：

比较两个
```
String
```
登录后复制
对象的内容。
比较两个自定义对象（例如
```
Person
```
登录后复制
类，你希望姓名和年龄都相同的两个人被认为是相等的）。
比较包装类对象的值。
比较集合框架中的元素（例如
```
ArrayList
```
登录后复制
、
```
HashSet
```
登录后复制
中的元素）。

如何正确重写

equals()

登录后复制

：重写

equals()

登录后复制

方法时，必须遵循

Object

登录后复制

类中定义的一系列“约定”（contract），否则可能会导致不可预测的行为，尤其是在使用集合类时。这些约定包括：

自反性 (Reflexive)： 对于任何非
```
null
```
登录后复制
的引用值
```
x
```
登录后复制
，
```
x.equals(x)
```
登录后复制
必须返回
```
true
```
登录后复制
。
对称性 (Symmetric)： 对于任何非
```
null
```
登录后复制
的引用值
```
x
```
登录后复制
和
```
y
```
登录后复制
，当且仅当
```
y.equals(x)
```
登录后复制
返回
```
true
```
登录后复制
时，
```
x.equals(y)
```
登录后复制
才返回
```
true
```
登录后复制
。
传递性 (Transitive)： 对于任何非
```
null
```
登录后复制
的引用值
```
x
```
登录后复制
、
```
y
```
登录后复制
和
```
z
```
登录后复制
，如果
```
x.equals(y)
```
登录后复制
返回
```
true
```
登录后复制
，并且
```
y.equals(z)
```
登录后复制
返回
```
true
```
登录后复制
，那么
```
x.equals(z)
```
登录后复制
也必须返回
```
true
```
登录后复制
。
一致性 (Consistent)： 对于任何非
```
null
```
登录后复制
的引用值
```
x
```
登录后复制
和
```
y
```
登录后复制
，只要
```
equals
```
登录后复制
比较中用到的信息没有被修改，多次调用
```
x.equals(y)
```
登录后复制
都会返回相同的结果。
非空性 (Nullity)： 对于任何非
```
null
```
登录后复制
的引用值
```
x
```
登录后复制
，
```
x.equals(null)
```
登录后复制
必须返回
```
false
```
登录后复制
。

此外，一个非常重要的最佳实践是：如果重写了

equals()

登录后复制

方法，就必须同时重写
hashCode()
登录后复制
方法。这是因为

HashSet

登录后复制

、

HashMap

登录后复制

等基于哈希表的集合类在存储和查找对象时，会先使用

hashCode()

登录后复制

来确定对象的存储位置，再使用

equals()

登录后复制

来确认对象是否相等。如果

equals()

登录后复制

相等的两个对象

hashCode()

登录后复制

不相等，就会导致在哈希集合中找不到本应存在的对象。

一个简单的

Person

登录后复制

类重写

equals()

登录后复制

和

hashCode()

登录后复制

的例子：

import java.util.Objects; // Java 7+ 引入的 Objects.equals 和 Objects.hash 简化了代码

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() { return name; }
    public int getAge() { return age; }

    @Override
    public boolean equals(Object o) {
        // 1. 检查是否是同一个对象引用，这是最快的判断
        if (this == o) return true;
        // 2. 检查传入对象是否为null，以及类型是否匹配
        //    getClass() 比 instanceof 更严格，要求类型完全一致
        if (o == null || getClass() != o.getClass()) return false;

        // 3. 类型转换
        Person person = (Person) o;

        // 4. 比较关键字段
        //    基本类型直接比较值
        //    引用类型使用其 equals 方法比较
        return age == person.age && Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        // 使用 Objects.hash() 可以方便地为多个字段生成哈希码
        return Objects.hash(name, age);
    }

    @Override
    public String toString() {
        return "Person{" +
               "name='" + name + '\'' +
               ", age=" + age +
               '}';
    }
}

// 使用示例
// Person p1 = new Person("张三", 30);
// Person p2 = new Person("张三", 30);
// System.out.println(p1.equals(p2)); // 输出 true
// System.out.println(p1 == p2);     // 输出 false

登录后复制

正确重写