Membandingkan Objek di Java

1. Perkenalan

Membandingkan objek adalah fitur penting dari bahasa pemrograman berorientasi objek.

Dalam tutorial ini, kita akan melihat beberapa fitur bahasa Java yang memungkinkan kita membandingkan objek. Selain itu, kami akan melihat fitur-fitur tersebut di pustaka eksternal.

2. == dan ! = Operator

Mari kita mulai dengan operator == dan ! = Yang dapat mengetahui apakah dua objek Java itu sama atau tidak.

2.1. Primitif

Untuk tipe primitif, menjadi sama berarti memiliki nilai yang sama:

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

Berkat unboxing otomatis, ini juga berfungsi saat membandingkan nilai primitif dengan pasangan jenis pembungkusnya :

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

Jika dua bilangan bulat memiliki nilai yang berbeda, operator == akan mengembalikan false , sedangkan operator ! = Akan mengembalikan true .

2.2. Objek

Katakanlah kita ingin membandingkan dua tipe pembungkus Integer dengan nilai yang sama:

Integer a = new Integer(1); Integer b = new Integer(1); assertThat(a == b).isFalse();

Dengan membandingkan dua objek, nilai objek tersebut bukan 1. Melainkan alamat memori mereka dalam tumpukan yang berbeda karena kedua objek dibuat menggunakan operator baru . Jika kita telah menetapkan a ke b , maka kita akan mendapatkan hasil yang berbeda:

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

Sekarang, mari kita lihat apa yang terjadi ketika kita menggunakan metode pabrik Integer # valueOf :

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

Dalam hal ini, mereka dianggap sama. Ini karena metode valueOf () menyimpan Integer dalam cache untuk menghindari pembuatan terlalu banyak objek pembungkus dengan nilai yang sama. Oleh karena itu, metode ini mengembalikan instance Integer yang sama untuk kedua panggilan.

Java juga melakukan ini untuk String :

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

Namun, jika dibuat menggunakan operator baru , maka keduanya tidak akan sama.

Akhirnya, dua referensi null dianggap sama, sedangkan objek bukan null akan dianggap berbeda dari null :

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

Tentu saja, perilaku operator kesetaraan dapat membatasi. Bagaimana jika kita ingin membandingkan dua objek yang dipetakan ke alamat yang berbeda namun tetap dianggap sama berdasarkan status internalnya? Kami akan melihat caranya di bagian selanjutnya.

3. Objek # sama dengan Metode

Sekarang, mari kita bicara tentang konsep persamaan yang lebih luas dengan metode equals () .

Metode ini didefinisikan di kelas Object sehingga setiap objek Java mewarisinya. Secara default, implementasinya membandingkan alamat memori objek, sehingga berfungsi sama dengan operator == . Namun, kita bisa mengganti metode ini untuk mendefinisikan apa arti persamaan untuk objek kita.

Pertama, mari kita lihat bagaimana perilakunya untuk objek yang sudah ada seperti Integer :

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

Metode ini masih mengembalikan nilai true jika kedua objek sama.

Kita harus mencatat bahwa kita dapat mengirimkan objek null sebagai argumen metode, tetapi tentu saja, bukan sebagai objek yang kita panggil metode tersebut.

Kita bisa menggunakan metode equals () dengan objek kita sendiri. Katakanlah kita memiliki kelas Person :

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

Kita bisa mengganti metode equals () untuk kelas ini sehingga kita bisa membandingkan dua Person berdasarkan detail internalnya:

@Override public boolean equals(Object o)  if (this == o) return true; if (o == null 

Untuk informasi lebih lanjut, lihat artikel kami tentang topik ini.

4. Objek # sama dengan Metode Statis

Sekarang mari kita lihat Objects # sama dengan metode statis. Kami telah menyebutkan sebelumnya bahwa kami tidak dapat menggunakan null sebagai nilai objek pertama jika tidak, NullPointerException akan dilempar.

Metode equals () dari class helper Objects memecahkan masalah itu. Dibutuhkan dua argumen dan membandingkannya, juga menangani nilai null .

Mari bandingkan kembali objek Person dengan:

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();

Seperti yang kami katakan, metode ini menangani nilai null . Oleh karena itu, jika kedua argumen adalah nol itu akan kembali benar , dan jika hanya salah satu dari mereka adalah nol , itu akan kembali palsu .

Ini bisa sangat berguna. Katakanlah kita ingin menambahkan tanggal lahir opsional ke kelas Person kita :

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

Kemudian, kami harus memperbarui metode equals () kami tetapi dengan penanganan null . Kita bisa melakukan ini dengan menambahkan kondisi ini ke metode equals () :

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

Namun, jika kita menambahkan banyak field nullable ke kelas kita, itu bisa menjadi sangat berantakan. Menggunakan metode Objects # equals dalam implementasi equals () kami jauh lebih bersih, dan meningkatkan keterbacaan:

Objects.equals(birthDate, that.birthDate);

5. Antarmuka Sebanding

Comparison logic can also be used to place objects in a specific order. The Comparable interface allows us to define an ordering between objects, by determining if an object is greater, equal, or lesser than another.

The Comparable interface is generic and has only one method, compareTo(), which takes an argument of the generic type and returns an int. The returned value is negative if this is lower than the argument, 0 if they are equal, and positive otherwise.

Let's say, in our Person class, we want to compare Person objects by their last name:

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

The compareTo() method will return a negative int if called with a Person having a greater last name than this, zero if the same last name, and positive otherwise.

For more information, take a look at our article about this topic.

6. Comparator Interface

The Comparator interface is generic and has a compare method that takes two arguments of that generic type and returns an integer. We already saw that pattern earlier with the Comparable interface.

Comparator is similar; however, it's separated from the definition of the class. Therefore, we can define as many Comparators we want for a class, where we can only provide one Comparable implementation.

Let's imagine we have a web page displaying people in a table view, and we want to offer the user the possibility to sort them by first names rather than last names. It isn't possible with Comparable if we also want to keep our current implementation, but we could implement our own Comparators.

Let's create a PersonComparator that will compare them only by their first names:

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

Let's now sort a List of people using that Comparator:

Person joe = new Person("Joe", "Portman"); Person allan = new Person("Allan", "Dale"); List people = new ArrayList(); people.add(joe); people.add(allan); people.sort(compareByFirstNames); assertThat(people).containsExactly(allan, joe);

There are other methods on the Comparator interface we can use in our compareTo() implementation:

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

In this case, we are first comparing last names, then first names. Then, we compare birth dates but as they are nullable we must say how to handle that so we give a second argument telling they should be compared according to their natural order but with null values going last.

7. Apache Commons

Let's now take a look at the Apache Commons library. First of all, let's import the Maven dependency:

 org.apache.commons commons-lang3 3.10 

7.1. ObjectUtils#notEqual Method

First, let's talk about the ObjectUtils#notEqual method. It takes two Object arguments, to determine if they are not equal, according to their own equals() method implementation. It also handles null values.

Let's reuse our String examples:

String a = new String("Hello!"); String b = new String("Hello World!"); assertThat(ObjectUtils.notEqual(a, b)).isTrue(); 

It should be noted that ObjectUtils has an equals() method. However, that's deprecated since Java 7, when Objects#equals appeared

7.2. ObjectUtils#compare Method

Now, let's compare object order with the ObjectUtils#compare method. It's a generic method that takes two Comparable arguments of that generic type and returns an Integer.

Let's see that using Strings again:

String first = new String("Hello!"); String second = new String("How are you?"); assertThat(ObjectUtils.compare(first, second)).isNegative();

By default, the method handles null values by considering them as greater. It offers an overloaded version that offers to invert that behavior and consider them lesser, taking a boolean argument.

8. Guava

Now, let's take a look at Guava. First of all, let's import the dependency:

 com.google.guava guava 29.0-jre 

8.1. Objects#equal Method

Similar to the Apache Commons library, Google provides us with a method to determine if two objects are equal, Objects#equal. Though they have different implementations, they return the same results:

String a = new String("Hello!"); String b = new String("Hello!"); assertThat(Objects.equal(a, b)).isTrue();

Though it's not marked as deprecated, the JavaDoc of this method says that it should be considered as deprecated since Java 7 provides the Objects#equals method.

8.2. Comparison Methods

Now, the Guava library doesn't offer a method to compare two objects (we'll see in the next section what we can do to achieve that though), but it does provide us with methods to compare primitive values. Let's take the Ints helper class and see how its compare() method works:

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

As usual, it returns an integer that may be negative, zero, or positive if the first argument is lesser, equal, or greater than the second, respectively. Similar methods exist for all the primitive types, except for bytes.

8.3. ComparisonChain Class

Finally, the Guava library offers the ComparisonChain class that allows us to compare two objects through a chain of comparisons. We can easily compare two Person objects by the first and last names:

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();

The underlying comparison is achieved using the compareTo() method, so the arguments passed to the compare() methods must either be primitives or Comparables.

9. Conclusion

Di artikel ini, kami melihat berbagai cara untuk membandingkan objek di Java. Kami memeriksa perbedaan antara kesamaan, persamaan, dan keteraturan. Kami juga telah melihat fitur terkait di pustaka Apache Commons dan Guava.

Seperti biasa, kode lengkap untuk artikel ini dapat ditemukan di GitHub.