java代码如何实现两个对象的比较 java代码对象比较的基础教程-java教程-PHP中文网

直接使用 '==' 比较对象通常是错误的，因为 == 比较的是两个引用是否指向同一内存地址，而非对象内容是否相等；1. 对于基本类型，== 比较值；2. 对于对象类型，== 比较引用地址；3. 要比较内容相等，应重写 equals() 方法；4. 重写 equals() 时必须同时重写 hashcode() 以满足哈希契约；5. 实现排序时，若需自然顺序则实现 comparable 接口；6. 若需多种排序方式或外部排序，则使用 comparator 接口。

java代码如何实现两个对象的比较 java代码对象比较的基础教程

在Java里比较两个对象，这事儿说起来简单，做起来却常常让人挠头。核心就一点：你究竟想比较的是它们在内存里是不是同一个东西（引用相等），还是它们在业务逻辑上是不是代表着相同的值（内容相等）。大多数时候，我们关心的都是后者。所以，通常我们会用到

equals()

登录后复制

方法，并且为了集合类的正确性，还需要和

hashCode()

登录后复制

方法配合。如果涉及到排序，那就是

Comparable

登录后复制

或

Comparator

登录后复制

的地盘了。

解决方案

要实现Java对象的比较，关键在于理解并恰当地使用

==

登录后复制

运算符、

equals()

登录后复制

方法、以及

Comparable

登录后复制

和

Comparator

登录后复制

接口。

对于基本数据类型（int, char, boolean等），

==

登录后复制

直接比较它们的值。但对于对象类型，

==

登录后复制

比较的是两个引用是否指向内存中的同一个对象实例。这意味着，即使两个对象的内容完全一样，如果它们是不同的实例，

==

登录后复制

也会返回

false

登录后复制

。

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

而

equals()

登录后复制

方法，它的默认行为和

==

登录后复制

是一样的，也是比较引用。但

Object

登录后复制

类提供了这个方法，就是为了让我们可以在自定义类中重写它，从而实现“内容相等”的逻辑。当你重写

equals()

登录后复制

时，几乎总是需要同时重写

hashCode()

登录后复制

，以遵守它们之间的契约，确保基于哈希的集合（如

HashMap

登录后复制

HashSet

登录后复制

）能正确工作。

当需要对对象进行排序时，Java提供了两种主要的接口：

```
Comparable<T>
```
登录后复制
：用于定义对象的“自然顺序”。一个类实现这个接口后，它就能够与同类型的其他对象进行比较，比如数字从小到大，字符串按字典序。
```
Comparator<T>
```
登录后复制
：如果一个类没有自然顺序，或者你需要多种不同的排序方式，就可以使用
```
Comparator
```
登录后复制
。它是一个外部的比较器，可以独立于被比较的类存在。

为什么直接使用 '==' 比较对象通常是错误的？

说实话，这问题我个人觉得挺基础的，但又是个常年有人踩的坑。当我们用

==

登录后复制

来比较两个Java对象时，你得明白，它压根儿就不是在看对象肚子里装了啥，它看的是两个引用是不是指着同一个内存地址。简单点说，就是看它们是不是同一个“身份证号”的家伙。

举个例子，你可能有两个

String

登录后复制

对象，它们的内容都是 "hello"。如果你写

String s1 = new String("hello"); String s2 = new String("hello");

登录后复制

，然后

s1 == s2

登录后复制

，结果多半会让你失望——它是

false

登录后复制

。为啥？因为

new String()

登录后复制

每次都会在内存里创建一个全新的字符串对象，即使它们的值一模一样，它们也是两个独立的个体。只有当你写

String s3 = s1;

登录后复制

这种，

s1 == s3

登录后复制

才会是

true

登录后复制

，因为

s3

登录后复制

现在也指向了

s1

登录后复制

指向的那个对象。

public class ObjectComparisonExample {
    public static void main(String[] args) {
        // 示例1：基本类型比较
        int a = 10;
        int b = 10;
        System.out.println("a == b: " + (a == b)); // true

        // 示例2：字符串对象比较 (new 出来的不同实例)
        String s1 = new String("hello");
        String s2 = new String("hello");
        System.out.println("s1 == s2: " + (s1 == s2)); // false

        // 示例3：字符串字面量比较 (JVM 字符串常量池优化)
        String s3 = "world";
        String s4 = "world";
        System.out.println("s3 == s4: " + (s3 == s4)); // true (因为JVM会优化，指向常量池的同一个对象)

        // 示例4：自定义对象比较
        MyObject obj1 = new MyObject(1, "test");
        MyObject obj2 = new MyObject(1, "test");
        MyObject obj3 = obj1; // obj3 和 obj1 指向同一个对象

        System.out.println("obj1 == obj2: " + (obj1 == obj2)); // false (不同实例)
        System.out.println("obj1 == obj3: " + (obj1 == obj3)); // true (同一个实例)
    }
}

class MyObject {
    int id;
    String name;

    public MyObject(int id, String name) {
        this.id = id;
        this.name = name;
    }
    // 未重写 equals() 和 hashCode()
}

登录后复制

所以，当你真正想判断两个对象在业务上是不是“一样”的时候，比如两个

User

登录后复制

对象，只要它们的

id

登录后复制

相同就认为是同一个用户，那

==

登录后复制

就完全帮不上忙了。它只会告诉你它们是不是同一个内存地址上的数据，而这往往不是我们想要的。这就是为什么我们需要

equals()

登录后复制

方法。

如何正确重写 equals() 和 hashCode() 方法？

这俩方法，我感觉是Java里最容易被误解，也最容易出问题的点之一。你重写

equals()

登录后复制

，几乎就得强制重写

hashCode()

登录后复制

，不然等着踩坑吧，尤其是在用

HashMap

登录后复制

或

HashSet

登录后复制

的时候。它们之间有个非常重要的“契约”：如果两个对象

equals()

登录后复制

true

登录后复制

，那么它们的

hashCode()

登录后复制

也必须返回相同的值。反之则不然，

hashCode()

登录后复制

相同，

equals()

登录后复制

不一定为

true

登录后复制

（这就是哈希冲突）。

重写

equals()

登录后复制

方法时，你需要遵循以下几个基本原则（通常称为

equals

登录后复制

契约）：

标书对比王

标书对比王是一款标书查重工具，支持多份投标文件两两相互比对，重复内容高亮标记，可快速定位重复内容原文所在位置，并可导出比对报告。

查看详情

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

重写

hashCode()

登录后复制

也很关键。一个好的

hashCode()

登录后复制

方法应该尽量让不同的对象产生不同的哈希值，减少冲突。

来，看个代码例子，我们给

MyObject

登录后复制

重写一下：

import java.util.Objects; // Java 7+ 推荐使用 Objects.hash()

class MyObjectWithEqualsHashCode {
    int id;
    String name;
    double value;

    public MyObjectWithEqualsHashCode(int id, String name, double value) {
        this.id = id;
        this.name = name;
        this.value = value;
    }

    @Override
    public boolean equals(Object o) {
        // 1. 自反性：如果是同一个对象，直接返回true
        if (this == o) return true;
        // 2. 与null比较：如果传入null，返回false
        // 3. 类型检查：如果类型不一致，返回false。这里用 instanceof 比较宽松，
        //    也可以用 o.getClass() != this.getClass() 严格检查是否是同一类。
        //    对于继承关系，getClass() 更严格，instanceof 更宽松。
        //    我个人倾向于 instanceof，因为它允许子类和父类对象进行逻辑上的相等比较。
        if (!(o instanceof MyObjectWithEqualsHashCode)) return false;

        // 4. 类型转换
        MyObjectWithEqualsHashCode that = (MyObjectWithEqualsHashCode) o;

        // 5. 逐个比较关键字段
        // 基本类型直接比较
        if (id != that.id) return false;
        // double 类型比较需要注意浮点数精度问题，这里简单直接比较，实际可能需要容忍度
        if (Double.compare(that.value, value) != 0) return false;
        // 对象类型（如String）使用其自身的 equals 方法比较
        return Objects.equals(name, that.name); // 推荐使用 Objects.equals() 处理null安全
    }

    @Override
    public int hashCode() {
        // 推荐使用 Objects.hash()，它能很好地处理多个字段的哈希计算，并且是null安全的。
        // 也可以手动计算，但很容易出错。
        return Objects.hash(id, name, value);
    }

    // 为了方便打印，重写 toString
    @Override
    public String toString() {
        return "MyObjectWithEqualsHashCode{" +
               "id=" + id +
               ", name='" + name + '\'' +
               ", value=" + value +
               '}';
    }
}

public class EqualsHashCodeDemo {
    public static void main(String[] args) {
        MyObjectWithEqualsHashCode objA = new MyObjectWithEqualsHashCode(1, "Alice", 10.5);
        MyObjectWithEqualsHashCode objB = new MyObjectWithEqualsHashCode(1, "Alice", 10.5);
        MyObjectWithEqualsHashCode objC = new MyObjectWithEqualsHashCode(2, "Bob", 20.0);

        System.out.println("objA.equals(objB): " + objA.equals(objB)); // true
        System.out.println("objA.equals(objC): " + objA.equals(objC)); // false
        System.out.println("objA.equals(null): " + objA.equals(null)); // false

        System.out.println("objA.hashCode(): " + objA.hashCode());
        System.out.println("objB.hashCode(): " + objB.hashCode());
        System.out.println("objC.hashCode(): " + objC.hashCode());

        // 演示在集合中的行为
        java.util.HashSet<MyObjectWithEqualsHashCode> set = new java.util.HashSet<>();
        set.add(objA);
        System.out.println("Set contains objA: " + set.contains(objA)); // true
        System.out.println("Set contains objB: " + set.contains(objB)); // true (因为equals和hashCode一致)
        set.add(objC);
        System.out.println("Set size: " + set.size()); // 2
    }
}

登录后复制

这里面有几个小细节值得说：

```
instanceof
```
登录后复制
vs
```
getClass()
```
登录后复制
：
```
instanceof
```
登录后复制
允许子类对象与父类对象在业务逻辑上相等（如果子类没有重写
```
equals
```
登录后复制
）。而
```
getClass()
```
登录后复制
严格要求两个对象的运行时类必须完全相同。这取决于你的业务需求。大多数时候，用
```
instanceof
```
登录后复制
配合
```
super.equals()
```
登录后复制
会更灵活。
浮点数比较：
```
Double.compare()
```
登录后复制
是比较安全的浮点数比较方式，因为它处理了
```
NaN
```
登录后复制
和
```
Infinity
```
登录后复制
的情况。但如果你需要考虑精度误差，可能需要自己定义一个小的容忍度（epsilon）。
```
Objects.equals()
```
登录后复制
和
```
Objects.hash()
```
登录后复制
：这是Java 7引入的工具类，强烈推荐使用。它们能帮你处理
```
null
```
登录后复制
值，避免
```
NullPointerException
```
登录后复制
，并且
```
Objects.hash()
```
登录后复制
能自动生成一个相对不错的哈希值。

什么时候应该使用 Comparable 或 Comparator 接口进行对象排序比较？

当你不仅仅是想判断两个对象是不是“一样”，而是想知道它们谁“更大”或谁“更小”时，比如需要对一个列表进行排序，或者把对象放到

TreeSet

登录后复制

、

TreeMap

登录后复制

这种有序集合里，那

Comparable

登录后复制

和

Comparator

登录后复制

就该登场了。

Comparable

登录后复制

：定义对象的“自然顺序”

如果一个类的对象天生就有一种默认的排序方式，比如数字从小到大，字符串按字典序，那么这个类就应该实现

Comparable<T>

登录后复制

接口。它只有一个方法

compareTo(T other)

登录后复制

：

返回负整数：表示当前对象小于
```
other
```
登录后复制
。
返回零：表示当前对象等于
```
other
```
登录后复制
。
返回正整数：表示当前对象大于
```
other
```
登录后复制
。

这就像给对象贴上了一个“默认排序规则”的标签。

class Product implements Comparable<Product> {
    private String name;
    private double price;

    public Product(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() { return name; }
    public double getPrice() { return price; }

    @Override
    public int compareTo(Product other) {
        // 自然排序：按价格从低到高排序
        // 如果价格相同，再按名称字母顺序排序
        int priceComparison = Double.compare(this.price, other.price);
        if (priceComparison != 0) {
            return priceComparison;
        }
        return this.name.compareTo(other.name);
    }

    @Override
    public String toString() {
        return "Product{name='" + name + "', price=" + price + '}';
    }
}

public class ComparableDemo {
    public static void main(String[] args) {
        java.util.List<Product> products = new java.util.ArrayList<>();
        products.add(new Product("Laptop", 1200.0));
        products.add(new Product("Mouse", 25.0));
        products.add(new Product("Keyboard", 75.0));
        products.add(new Product("Monitor", 1200.0)); // 价格相同，会按名称排序

        System.out.println("Original products: " + products);
        java.util.Collections.sort(products); // 使用Product的自然顺序
        System.out.println("Sorted by price (natural order): " + products);

        java.util.TreeSet<Product> productSet = new java.util.TreeSet<>();
        productSet.add(new Product("Tablet", 500.0));
        productSet.add(new Product("Phone", 800.0));
        productSet.add(new Product("Tablet", 500.0)); // TreeSet会使用compareTo来判断是否重复
        System.out.println("TreeSet of products: " + productSet);
    }
}

登录后复制

Comparator

登录后复制

：提供多种排序方式或外部排序

有时候，一个对象可能没有一个明确的“自然顺序”，或者你需要根据不同的业务场景，对同一类对象进行多种不同的排序。这时候，

Comparator<T>

登录后复制

就派上用场了。它是一个独立的类，实现了

compare(T o1, T o2)

登录后复制

方法。这个方法和

compareTo

登录后复制

类似，也是返回负、零或正整数。

你可以创建多个

Comparator

登录后复制

实现，来满足不同的排序需求，而无需修改被排序的类。这在很多场景下都非常灵活。

import java.util.Comparator;

// 价格降序比较器
class PriceDescComparator implements Comparator<Product> {
    @Override
    public int compare(Product p1, Product p2) {
        return Double.compare(p2.getPrice(), p1.getPrice()); // 注意p2在前，实现降序
    }
}

// 名称升序比较器
class NameAscComparator implements Comparator<Product> {
    @Override
    public int compare(Product p1, Product p2) {
        return p1.getName().compareTo(p2.getName());
    }
}

public class ComparatorDemo {
    public static void main(String[] args) {
        java.util.List<Product> products = new java.util.ArrayList<>();
        products.add(new Product("Laptop", 1200.0));
        products.add(new Product("Mouse", 25.0));
        products.add(new Product("Keyboard", 75.0));
        products.add(new Product("Monitor", 1200.0));

        System.out.println("Original products: " + products);

        // 使用价格降序比较器排序
        java.util.Collections.sort(products, new PriceDescComparator());
        System.out.println("Sorted by price descending: " + products);

        // 使用名称升序比较器排序
        java.util.Collections.sort(products, new NameAscComparator());
        System.out.println("Sorted by name ascending: " + products);

        // Java 8 以后，Comparator 接口提供了很多方便的静态方法，比如 comparing()
        // 按价格升序排序
        products.sort(Comparator.comparing(Product::getPrice));
        System.out.println("Sorted by price ascending (Java 8): " + products);

        // 按价格升序，价格相同则按名称降序
        products.sort(Comparator.comparing(Product::getPrice)
                                 .thenComparing(Product::getName, Comparator.reverseOrder()));
        System.out.println("Sorted by price asc, then name desc (Java 8): " + products);
    }
}

登录后复制

总的来说，如果你需要定义一个类自身的默认排序规则，就用