一、==和!=操作符

讓我們從==和！=開始可以分別判斷兩個Java對象是否相同的操作符。

1.1 原始類型（Primitives）

對于原始類型，相同意味著具有相等的值：

assertThat(1 == 1).isTrue();

感謝自動拆箱，在將原語值與其包裝類型對應(yīng)值進行比較時，也可以這樣做：

Integer a = new Integer(1);
assertThat(1 == a).isTrue();

如果兩個整數(shù)的值不同，==運算符將返回false，而!=運算符將返回true。

1.2 對象比較

假設(shè)我們要比較兩個具有相同值的整數(shù)包裝類型：

Integer a = new Integer(1);
Integer b = new Integer(1);

assertThat(a == b).isFalse();

通過比較兩個對象，這些對象的值不是1，而是它們在堆棧中的內(nèi)存地址，因為這兩個對象都是使用new操作符創(chuàng)建的。如果我們把a分配給b，我們會得到不同的結(jié)果：

Integer a = new Integer(1);
Integer b = a;

assertThat(a == b).isTrue();

現(xiàn)在，讓我們看看使用Integer#valueOf factory方法時會發(fā)生什么：

Integer a = Integer.valueOf(1);
Integer b = Integer.valueOf(1);

assertThat(a == b).isTrue();

在這種情況下，它們被認為是相同的。這是因為valueOf（）方法將整數(shù)存儲在緩存中，以避免創(chuàng)建太多具有相同值的包裝器對象。因此，該方法為兩個調(diào)用返回相同的整數(shù)實例。

對字符串也是一樣：

assertThat("Hello!" == "Hello!").isTrue();

但是，如果它們是使用new操作符創(chuàng)建的，那么它們就不一樣了。最后，兩個空引用被認為是相同的，而任何非空對象將被認為與空對象不同：

assertThat(null == null).isTrue();
assertThat("Hello!" == null).isFalse();

當然，相等運算符的行為可能是有限的。如果我們想比較兩個映射到不同地址的對象，并根據(jù)它們的內(nèi)部狀態(tài)將它們視為相等，那該怎么辦？我們將在下一節(jié)中看到如何操作。

二、Object的equals方法

現(xiàn)在，讓我們用equals()方法討論一個更廣泛的相等概念。這個方法是在Object類中定義的，以便每個Java對象都繼承它。默認情況下，它的實現(xiàn)比較對象內(nèi)存地址，因此它的工作方式與==運算符相同。但是，我們可以重寫這個方法來定義相等對我們的對象意味著什么。

首先，讓我們看看它對現(xiàn)有對象（如Integer）的表現(xiàn)：

Integer a = new Integer(1);
Integer b = new Integer(1);

assertThat(a.equals(b)).isTrue();

當兩個對象相同時，該方法仍然返回true。我們應(yīng)該注意，我們可以傳遞一個空對象作為方法的參數(shù)，但是當然，不能作為調(diào)用方法的對象。我們可以對自己的對象使用equals（）方法。假設(shè)我們有一個Person類：

public class Person {
    private String firstName;
    private String lastName;

    public Person(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }
}

我們可以重寫該類的equals（）方法，以便根據(jù)兩個人的內(nèi)部詳細信息進行比較：

@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    Person that = (Person) o;
    return firstName.equals(that.firstName) &&
      lastName.equals(that.lastName);
}

三、Objects的靜態(tài)方法equals

現(xiàn)在讓我們看看Objects的equals靜態(tài)方法。我們前面提到過，不能使用null作為第一個對象的值，否則會拋出NullPointerException。Objects助手類的equals()方法解決了這個問題。它接受兩個參數(shù)并比較它們，同時處理空值。

讓我們再次比較Person對象：

Person joe = new Person("Joe", "Portman");
Person joeAgain = new Person("Joe", "Portman");
Person natalie = new Person("Natalie", "Portman");

assertThat(Objects.equals(joe, joeAgain)).isTrue();
assertThat(Objects.equals(joe, natalie)).isFalse();

如前所述，該方法處理空值。因此，如果兩個參數(shù)都為null，則返回true；如果只有一個參數(shù)為null，則返回false。這真的很方便。假設(shè)我們想給Person類添加一個可選的出生日期：

public Person(String firstName, String lastName, LocalDate birthDate) {
    this(firstName, lastName);
    this.birthDate = birthDate;
}

然后，我們必須更新equals（）方法，但是要處理Null。我們可以將此條件添加到equals（）方法中：

birthDate == null ? that.birthDate == null : birthDate.equals(that.birthDate);

但是，如果我們在類中添加許多可為null的字段，它可能會變得非?；靵y。在equals（）實現(xiàn)中使用Objects#equals方法更加簡潔，并且提高了可讀性：

Objects.equals(birthDate, that.birthDate);

四、Comparable接口

比較邏輯也可用于給對象排序?？杀容^接口允許我們通過確定一個對象是大于、等于還是小于另一個對象來定義對象之間的順序。

Compariable接口是泛型的，只有一個方法compareTo()，該方法接受泛型類型的參數(shù)并返回int。如果當前值小于參數(shù)，則返回負值；如果它們相等，則返回0；否則返回正值。

比方說，在我們的Person類中，我們希望按Person對象的姓氏進行比較：

public class Person implements Comparable<Person> {
    //...

    @Override
    public int compareTo(Person o) {
        return this.lastName.compareTo(o.lastName);
    }
}

如果使用姓氏大于此的人調(diào)用compareTo（）方法，則返回負int；如果姓氏相同，則返回零；否則返回正int。

五、Comparator接口

Comparator接口是泛型的，并且有一個compare方法，該方法接受該泛型類型的兩個參數(shù)并返回一個整數(shù)。我們在前面的可比較接口中已經(jīng)看到了這種模式。

比較器相似；但是，它與類的定義是分離的。因此，我們可以為一個類定義任意多個比較器，其中我們只能提供一個可比較的實現(xiàn)。

假設(shè)我們有一個在網(wǎng)頁中有一個展示人信息的表格，我們想讓用戶能夠按名字而不是姓氏對他們進行排序。如果我們還想保持當前的實現(xiàn)，那么使用Comparable是不可能的，但是我們可以實現(xiàn)自己的比較器。

讓我們創(chuàng)建一個Person Comparator，它將只根據(jù)他們的名字進行比較：

Comparator<Person> compareByFirstNames = Comparator.comparing(Person::getFirstName);

現(xiàn)在讓我們用這個比較器對一組人進行排序：

Person joe = new Person("Joe", "Portman");
Person allan = new Person("Allan", "Dale");

List<Person> people = new ArrayList<>();
people.add(joe);
people.add(allan);

people.sort(compareByFirstNames);

assertThat(people).containsExactly(allan, joe);

在compareTo()實現(xiàn)中，可以使用Comparator接口上的其他方法：

@Override
public int compareTo(Person o) {
    return Comparator.comparing(Person::getLastName)
      .thenComparing(Person::getFirstName)
      .thenComparing(Person::getBirthDate, Comparator.nullsLast(Comparator.naturalOrder()))
      .compare(this, o);
}

在這種情況下，我們首先比較姓，然后比較名。然后，我們比較出生日期，但是由于它們是可空的，我們必須說明如何處理它，所以我們給出了第二個參數(shù)，告訴它們應(yīng)該根據(jù)它們的自然順序進行比較，但是空值最后才是。

六、使用Apache Commons

現(xiàn)在讓我們看看apachecommons庫。首先，讓我們導(dǎo)入Maven依賴項：

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.11</version>
</dependency>

6.1 ObjectUtils的notEqual方法

首先，我們來討論ObjectUtils#notEqual方法。它需要兩個對象參數(shù)，根據(jù)它們自己的equals（）方法實現(xiàn)來確定它們是否相等。它還處理空值。

讓我們重新使用我們的字符串示例：

String a = new String("Hello!");
String b = new String("Hello World!");

assertThat(ObjectUtils.notEqual(a, b)).isTrue();

應(yīng)該注意，ObjectUtils有一個equals（）方法。但是，自從Java7出現(xiàn)Objects#equals之后，這種方法就被棄用了。

6.2 ObjectUtils的compare方法

現(xiàn)在，讓我們用ObjectUtils#compare方法比較對象順序。它是一個泛型方法，它接受該泛型類型的兩個可比較參數(shù)并返回一個整數(shù)。

讓我們再看看如何使用字符串：

String first = new String("Hello!");
String second = new String("How are you?");

assertThat(ObjectUtils.compare(first, second)).isNegative();

默認情況下，該方法通過將空值視為更大值來處理空值。它提供了一個重載版本，它提供了一個布爾參數(shù)來反轉(zhuǎn)該行為，并將它們考慮得更小。

七、使用Guava

現(xiàn)在，我們來看看Guava。Guava 是 Google 的一個開源項目，包含許多 Google 核心 Java 常用庫，如：集合 [collections] 、緩存 [caching] 、原生類型支持 [primitives support] 、并發(fā)庫 [concurrency libraries] 、通用注解 [common annotations] 、字符串處理 [string processing] 與 I/O 等。

首先，讓我們導(dǎo)入依賴項：

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>29.0-jre</version>
</dependency>

7.1 Objects的equal方法

與apache commons庫類似，Google為我們提供了一種方法來確定兩個對象是否相等，objects#equal。盡管它們有不同的實現(xiàn)，但它們返回相同的結(jié)果：

String a = new String("Hello!");
String b = new String("Hello!");

assertThat(Objects.equal(a, b)).isTrue();

盡管它沒有被標記為deprecated，但是這個方法的JavaDoc說它應(yīng)該被視為deprecated，因為java7提供了Objects#equals方法。

7.2 Comparison方法

現(xiàn)在，Guava庫沒有提供一個方法來比較兩個對象（我們將在下一節(jié)中看到如何實現(xiàn)這一點），但它確實提供了比較原始值的方法。讓我們看看Ints helper類的compare（）方法是如何工作的：

assertThat(Ints.compare(1, 2)).isNegative();

通常，如果第一個參數(shù)小于、等于或大于第二個參數(shù)，則返回一個整數(shù)，該整數(shù)可能為負、零或正。除了bytes之外，所有基元類型都有類似的方法。

7.3 ComparisonChain類

最后，Guava庫提供了ComparisonChain類，它允許我們通過一系列比較來比較兩個對象。我們可以很容易地比較兩個人的名字和姓氏：

Person natalie = new Person("Natalie", "Portman");
Person joe = new Person("Joe", "Portman");

int comparisonResult = ComparisonChain.start()
  .compare(natalie.getLastName(), joe.getLastName())
  .compare(natalie.getFirstName(), joe.getFirstName())
  .result();

assertThat(comparisonResult).isPositive();

底層比較是使用compareTo()方法實現(xiàn)的，因此傳遞給compare()方法的參數(shù)必須是原始類型或可比較的對象。

八、完整代碼

Java對象比較

到此這篇關(guān)于Java各種比較對象的方式的對比總結(jié)的文章就介紹到這了,更多相關(guān)Java比較對象的方式內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評論