Merge pull request #9224 from dupirefr/author/BAEL-3981-comparing_objects

[BAEL-3981] Comparing in Java

core-java-modules/core-java-lang-2/pom.xml

@@ -20,7 +20,12 @@
         <dependency>
             <groupId>org.apache.commons</groupId>
             <artifactId>commons-lang3</artifactId>
-            <version>3.9</version>
+            <version>${commons-lang3.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+            <version>${guava.version}</version>
         </dependency>
         <dependency>
             <groupId>commons-beanutils</groupId>
@@ -65,6 +70,8 @@
         <jmh-generator.version>1.19</jmh-generator.version>
         <assertj.version>3.12.2</assertj.version>
         <commons.beanutils.version>1.9.4</commons.beanutils.version>
+        <commons-lang3.version>3.10</commons-lang3.version>
+        <guava.version>29.0-jre</guava.version>
     </properties>
 
 </project>

core-java-modules/core-java-lang-2/src/main/java/com/baeldung/comparing/PersonWithEquals.java

@@ -0,0 +1,51 @@
+package com.baeldung.comparing;
+
+import java.time.LocalDate;
+import java.util.Objects;
+
+public class PersonWithEquals {
+    private String firstName;
+    private String lastName;
+    private LocalDate birthDate;
+
+    public PersonWithEquals(String firstName, String lastName) {
+        if (firstName == null || lastName == null) {
+            throw new NullPointerException("Names can't be null");
+        }
+        this.firstName = firstName;
+        this.lastName = lastName;
+    }
+
+    public PersonWithEquals(String firstName, String lastName, LocalDate birthDate) {
+        this(firstName, lastName);
+
+        this.birthDate = birthDate;
+    }
+
+    public String firstName() {
+        return firstName;
+    }
+
+    public String lastName() {
+        return lastName;
+    }
+
+    public LocalDate birthDate() {
+        return birthDate;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        PersonWithEquals that = (PersonWithEquals) o;
+        return firstName.equals(that.firstName) &&
+          lastName.equals(that.lastName) &&
+          Objects.equals(birthDate, that.birthDate);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(firstName, lastName);
+    }
+}

core-java-modules/core-java-lang-2/src/main/java/com/baeldung/comparing/PersonWithEqualsAndComparable.java

@@ -0,0 +1,62 @@
+package com.baeldung.comparing;
+
+import java.time.LocalDate;
+import java.util.Objects;
+
+public class PersonWithEqualsAndComparable implements Comparable<PersonWithEqualsAndComparable> {
+    private String firstName;
+    private String lastName;
+    private LocalDate birthDate;
+
+    public PersonWithEqualsAndComparable(String firstName, String lastName) {
+        if (firstName == null || lastName == null) {
+            throw new NullPointerException("Names can't be null");
+        }
+        this.firstName = firstName;
+        this.lastName = lastName;
+    }
+
+    public PersonWithEqualsAndComparable(String firstName, String lastName, LocalDate birthDate) {
+        this(firstName, lastName);
+
+        this.birthDate = birthDate;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        PersonWithEqualsAndComparable that = (PersonWithEqualsAndComparable) o;
+        return firstName.equals(that.firstName) &&
+          lastName.equals(that.lastName) &&
+          Objects.equals(birthDate, that.birthDate);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(firstName, lastName);
+    }
+
+    @Override
+    public int compareTo(PersonWithEqualsAndComparable o) {
+        int lastNamesComparison = this.lastName.compareTo(o.lastName);
+        if (lastNamesComparison == 0) {
+            int firstNamesComparison = this.firstName.compareTo(o.firstName);
+            if (firstNamesComparison == 0) {
+                if (this.birthDate != null && o.birthDate != null) {
+                    return this.birthDate.compareTo(o.birthDate);
+                } else if (this.birthDate != null) {
+                  return 1;
+                } else if (o.birthDate != null) {
+                    return -1;
+                } else {
+                    return 0;
+                }
+            } else {
+                return firstNamesComparison;
+            }
+        } else {
+            return lastNamesComparison;
+        }
+    }
+}

core-java-modules/core-java-lang-2/src/main/java/com/baeldung/comparing/PersonWithEqualsAndComparableUsingComparator.java

@@ -0,0 +1,60 @@
+package com.baeldung.comparing;
+
+import java.time.LocalDate;
+import java.util.Comparator;
+import java.util.Objects;
+
+public class PersonWithEqualsAndComparableUsingComparator implements Comparable<PersonWithEqualsAndComparableUsingComparator> {
+    private String firstName;
+    private String lastName;
+    private LocalDate birthDate;
+
+    public PersonWithEqualsAndComparableUsingComparator(String firstName, String lastName) {
+        if (firstName == null || lastName == null) {
+            throw new NullPointerException("Names can't be null");
+        }
+        this.firstName = firstName;
+        this.lastName = lastName;
+    }
+
+    public PersonWithEqualsAndComparableUsingComparator(String firstName, String lastName, LocalDate birthDate) {
+        this(firstName, lastName);
+
+        this.birthDate = birthDate;
+    }
+
+    public String firstName() {
+        return firstName;
+    }
+
+    public String lastName() {
+        return lastName;
+    }
+
+    public LocalDate birthDate() {
+        return birthDate;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        PersonWithEqualsAndComparableUsingComparator that = (PersonWithEqualsAndComparableUsingComparator) o;
+        return firstName.equals(that.firstName) &&
+          lastName.equals(that.lastName) &&
+          Objects.equals(birthDate, that.birthDate);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(firstName, lastName);
+    }
+
+    @Override
+    public int compareTo(PersonWithEqualsAndComparableUsingComparator o) {
+        return Comparator.comparing(PersonWithEqualsAndComparableUsingComparator::lastName)
+          .thenComparing(PersonWithEqualsAndComparableUsingComparator::firstName)
+          .thenComparing(PersonWithEqualsAndComparableUsingComparator::birthDate, Comparator.nullsLast(Comparator.naturalOrder()))
+          .compare(this, o);
+    }
+}

core-java-modules/core-java-lang-2/src/main/java/com/baeldung/comparing/PersonWithEqualsAndWrongComparable.java

@@ -0,0 +1,44 @@
+package com.baeldung.comparing;
+
+import java.time.LocalDate;
+import java.util.Objects;
+
+public class PersonWithEqualsAndWrongComparable implements Comparable<PersonWithEqualsAndWrongComparable> {
+    private String firstName;
+    private String lastName;
+    private LocalDate birthDate;
+
+    public PersonWithEqualsAndWrongComparable(String firstName, String lastName) {
+        if (firstName == null || lastName == null) {
+            throw new NullPointerException("Names can't be null");
+        }
+        this.firstName = firstName;
+        this.lastName = lastName;
+    }
+
+    public PersonWithEqualsAndWrongComparable(String firstName, String lastName, LocalDate birthDate) {
+        this(firstName, lastName);
+
+        this.birthDate = birthDate;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        PersonWithEqualsAndWrongComparable that = (PersonWithEqualsAndWrongComparable) o;
+        return firstName.equals(that.firstName) &&
+          lastName.equals(that.lastName) &&
+          Objects.equals(birthDate, that.birthDate);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(firstName, lastName);
+    }
+
+    @Override
+    public int compareTo(PersonWithEqualsAndWrongComparable o) {
+        return this.lastName.compareTo(o.lastName);
+    }
+}

core-java-modules/core-java-lang-2/src/main/java/com/baeldung/comparing/PersonWithoutEquals.java

@@ -0,0 +1,11 @@
+package com.baeldung.comparing;
+
+public class PersonWithoutEquals {
+    private String firstName;
+    private String lastName;
+
+    public PersonWithoutEquals(String firstName, String lastName) {
+        this.firstName = firstName;
+        this.lastName = lastName;
+    }
+}

core-java-modules/core-java-lang-2/src/test/java/com/baeldung/comparing/ApacheCommonsObjectUtilsUnitTest.java

@@ -0,0 +1,59 @@
+package com.baeldung.comparing;
+
+import org.apache.commons.lang3.ObjectUtils;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class ApacheCommonsObjectUtilsUnitTest {
+
+    @Test
+    void givenTwoStringsWithSameValues_whenApacheCommonsEqualityMethods_thenEqualsTrueNotEqualsFalse() {
+        String a = new String("Hello!");
+        String b = new String("Hello!");
+
+        assertThat(ObjectUtils.equals(a, b)).isTrue();
+        assertThat(ObjectUtils.notEqual(a, b)).isFalse();
+    }
+
+    @Test
+    void givenTwoStringsWithDifferentValues_whenApacheCommonsEqualityMethods_thenEqualsFalseNotEqualsTrue() {
+        String a = new String("Hello!");
+        String b = new String("Hello World!");
+
+        assertThat(ObjectUtils.equals(a, b)).isFalse();
+        assertThat(ObjectUtils.notEqual(a, b)).isTrue();
+    }
+
+    @Test
+    void givenTwoStringsWithConsecutiveValues_whenApacheCommonsCompare_thenNegative() {
+        String first = new String("Hello!");
+        String second = new String("How are you?");
+
+        assertThat(ObjectUtils.compare(first, second)).isNegative();
+    }
+
+    @Test
+    void givenTwoStringsWithSameValues_whenApacheCommonsEqualityMethods_thenEqualsFalseNotEqualsTrue() {
+        String first = new String("Hello!");
+        String second = new String("Hello!");
+
+        assertThat(ObjectUtils.compare(first, second)).isZero();
+    }
+
+    @Test
+    void givenTwoStringsWithConsecutiveValues_whenApacheCommonsCompareReversed_thenPositive() {
+        String first = new String("Hello!");
+        String second = new String("How are you?");
+
+        assertThat(ObjectUtils.compare(second, first)).isPositive();
+    }
+
+    @Test
+    void givenTwoStringsOneNull_whenApacheCommonsCompare_thenPositive() {
+        String first = new String("Hello!");
+        String second = null;
+
+        assertThat(ObjectUtils.compare(first, second, false)).isPositive();
+    }
+}

core-java-modules/core-java-lang-2/src/test/java/com/baeldung/comparing/ComparableInterfaceUnitTest.java

@@ -0,0 +1,107 @@
+package com.baeldung.comparing;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.SortedSet;
+import java.util.TreeSet;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class ComparableInterfaceUnitTest {
+
+    @Test
+    void givenTwoConsecutiveStrings_whenCompareTo_thenNegative() {
+        String first = "Google";
+        String second = "Microsoft";
+
+        assertThat(first.compareTo(second)).isNegative();
+    }
+
+    @Test
+    void givenTwoEqualsStrings_whenCompareTo_thenZero() {
+        String first = "Google";
+        String second = "Google";
+
+        assertThat(first.compareTo(second)).isZero();
+    }
+
+    @Test
+    void givenTwoConsecutiveStrings_whenReversedCompareTo_thenPositive() {
+        String first = "Google";
+        String second = "Microsoft";
+
+        assertThat(second.compareTo(first)).isPositive();
+    }
+
+    @Test
+    void givenTwoPersonWithEqualsAndWrongComparableAndConsecutiveLastNames_whenCompareTo_thenNegative() {
+        PersonWithEqualsAndWrongComparable richard = new PersonWithEqualsAndWrongComparable("Richard", "Jefferson");
+        PersonWithEqualsAndWrongComparable joe = new PersonWithEqualsAndWrongComparable("Joe", "Portman");
+
+        assertThat(richard.compareTo(joe)).isNegative();
+    }
+
+    @Test
+    void givenTwoPersonWithEqualsAndWrongComparableAndSameLastNames_whenReversedCompareTo_thenZero() {
+        PersonWithEqualsAndWrongComparable richard = new PersonWithEqualsAndWrongComparable("Richard", "Jefferson");
+        PersonWithEqualsAndWrongComparable mike = new PersonWithEqualsAndWrongComparable("Mike", "Jefferson");
+
+        assertThat(richard.compareTo(mike)).isZero();
+    }
+
+    @Test
+    void givenTwoPersonWithEqualsAndWrongComparableAndConsecutiveLastNames_whenReversedCompareTo_thenPositive() {
+        PersonWithEqualsAndWrongComparable richard = new PersonWithEqualsAndWrongComparable("Richard", "Jefferson");
+        PersonWithEqualsAndWrongComparable joe = new PersonWithEqualsAndWrongComparable("Joe", "Portman");
+
+        assertThat(joe.compareTo(richard)).isPositive();
+    }
+
+    @Test
+    void givenTwoPersonWithEqualsAndWrongComparableAndSameLastNames_whenSortedSet_thenProblem() {
+        PersonWithEqualsAndWrongComparable richard = new PersonWithEqualsAndWrongComparable("Richard", "Jefferson");
+        PersonWithEqualsAndWrongComparable mike = new PersonWithEqualsAndWrongComparable("Mike", "Jefferson");
+
+        SortedSet<PersonWithEqualsAndWrongComparable> people = new TreeSet<>();
+        people.add(richard);
+        people.add(mike);
+
+        assertThat(people).containsExactly(richard);
+    }
+
+    @Test
+    void givenTwoPersonWithEqualsAndComparableAndConsecutiveLastNames_whenCompareTo_thenNegative() {
+        PersonWithEqualsAndComparable richard = new PersonWithEqualsAndComparable("Richard", "Jefferson");
+        PersonWithEqualsAndComparable joe = new PersonWithEqualsAndComparable("Joe", "Portman");
+
+        assertThat(richard.compareTo(joe)).isNegative();
+    }
+
+    @Test
+    void givenTwoPersonWithEqualsAndComparableAndSameLastNames_whenReversedCompareTo_thenZero() {
+        PersonWithEqualsAndComparable richard = new PersonWithEqualsAndComparable("Richard", "Jefferson");
+        PersonWithEqualsAndComparable mike = new PersonWithEqualsAndComparable("Mike", "Jefferson");
+
+        assertThat(richard.compareTo(mike)).isPositive();
+    }
+
+    @Test
+    void givenTwoPersonWithEqualsAndComparableAndConsecutiveLastNames_whenReversedCompareTo_thenPositive() {
+        PersonWithEqualsAndComparable richard = new PersonWithEqualsAndComparable("Richard", "Jefferson");
+        PersonWithEqualsAndComparable joe = new PersonWithEqualsAndComparable("Joe", "Portman");
+
+        assertThat(joe.compareTo(richard)).isPositive();
+    }
+
+    @Test
+    void givenTwoPersonWithEqualsAndComparableAndSameLastNames_whenSortedSet_thenProblem() {
+        PersonWithEqualsAndComparable richard = new PersonWithEqualsAndComparable("Richard", "Jefferson");
+        PersonWithEqualsAndComparable mike = new PersonWithEqualsAndComparable("Mike", "Jefferson");
+
+        SortedSet<PersonWithEqualsAndComparable> people = new TreeSet<>();
+        people.add(richard);
+        people.add(mike);
+
+        assertThat(people).containsExactly(mike, richard);
+    }
+}

core-java-modules/core-java-lang-2/src/test/java/com/baeldung/comparing/ComparatorInterfaceUnitTest.java

@@ -0,0 +1,81 @@
+package com.baeldung.comparing;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.*;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class ComparatorInterfaceUnitTest {
+
+    @Test
+    void givenListOfTwoPersonWithEqualsAndComparatorByFirstName_whenSort_thenSortedByFirstNames() {
+        PersonWithEquals joe = new PersonWithEquals("Joe", "Portman");
+        PersonWithEquals allan = new PersonWithEquals("Allan", "Dale");
+
+        List<PersonWithEquals> people = new ArrayList<>();
+        people.add(joe);
+        people.add(allan);
+
+        Comparator<PersonWithEquals> compareByFirstNames = new Comparator<PersonWithEquals>() {
+            @Override
+            public int compare(PersonWithEquals o1, PersonWithEquals o2) {
+                return o1.firstName().compareTo(o2.firstName());
+            }
+        };
+        people.sort(compareByFirstNames);
+
+        assertThat(people).containsExactly(allan, joe);
+    }
+
+    @Test
+    void givenListOfTwoPersonWithEqualsAndComparatorByFirstNameFunctionalStyle_whenSort_thenSortedByFirstNames() {
+        PersonWithEquals joe = new PersonWithEquals("Joe", "Portman");
+        PersonWithEquals allan = new PersonWithEquals("Allan", "Dale");
+
+        List<PersonWithEquals> people = new ArrayList<>();
+        people.add(joe);
+        people.add(allan);
+
+        Comparator<PersonWithEquals> compareByFirstNames = Comparator.comparing(PersonWithEquals::firstName);
+        people.sort(compareByFirstNames);
+
+        assertThat(people).containsExactly(allan, joe);
+    }
+
+    @Test
+    void givenTwoPersonWithEqualsAndComparableUsingComparatorAndConsecutiveLastNames_whenCompareTo_thenNegative() {
+        PersonWithEqualsAndComparableUsingComparator richard = new PersonWithEqualsAndComparableUsingComparator("Richard", "Jefferson");
+        PersonWithEqualsAndComparableUsingComparator joe = new PersonWithEqualsAndComparableUsingComparator("Joe", "Portman");
+
+        assertThat(richard.compareTo(joe)).isNegative();
+    }
+
+    @Test
+    void givenTwoPersonWithEqualsAndComparableUsingComparatorAndSameLastNames_whenReversedCompareTo_thenZero() {
+        PersonWithEqualsAndComparableUsingComparator richard = new PersonWithEqualsAndComparableUsingComparator("Richard", "Jefferson");
+        PersonWithEqualsAndComparableUsingComparator mike = new PersonWithEqualsAndComparableUsingComparator("Mike", "Jefferson");
+
+        assertThat(richard.compareTo(mike)).isPositive();
+    }
+
+    @Test
+    void givenTwoPersonWithEqualsAndComparableUsingComparatorAndConsecutiveLastNames_whenReversedCompareTo_thenPositive() {
+        PersonWithEqualsAndComparableUsingComparator richard = new PersonWithEqualsAndComparableUsingComparator("Richard", "Jefferson");
+        PersonWithEqualsAndComparableUsingComparator joe = new PersonWithEqualsAndComparableUsingComparator("Joe", "Portman");
+
+        assertThat(joe.compareTo(richard)).isPositive();
+    }
+
+    @Test
+    void givenTwoPersonWithEqualsAndComparableUsingComparatorAndSameLastNames_whenSortedSet_thenProblem() {
+        PersonWithEqualsAndComparableUsingComparator richard = new PersonWithEqualsAndComparableUsingComparator("Richard", "Jefferson");
+        PersonWithEqualsAndComparableUsingComparator mike = new PersonWithEqualsAndComparableUsingComparator("Mike", "Jefferson");
+
+        SortedSet<PersonWithEqualsAndComparableUsingComparator> people = new TreeSet<>();
+        people.add(richard);
+        people.add(mike);
+
+        assertThat(people).containsExactly(mike, richard);
+    }
+}

core-java-modules/core-java-lang-2/src/test/java/com/baeldung/comparing/EqualityOperatorUnitTest.java

@@ -0,0 +1,116 @@
+package com.baeldung.comparing;
+
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class EqualityOperatorUnitTest {
+
+    @Test
+    void givenTwoIntsWithSameValues_whenEqualityOperators_thenConsideredSame() {
+        int a = 1;
+        int b = 1;
+
+        assertThat(a == b).isTrue();
+        assertThat(a != b).isFalse();
+    }
+
+    @Test
+    void givenTwoIntsWithDifferentValues_whenEqualityOperators_thenNotConsideredSame() {
+        int a = 1;
+        int b = 2;
+
+        assertThat(a == b).isFalse();
+        assertThat(a != b).isTrue();
+    }
+
+    @Test
+    void givenTwoIntsWithSameValuesOneWrapped_whenEqualityOperators_thenConsideredSame() {
+        int a = 1;
+        Integer b = new Integer(1);
+
+        assertThat(a == b).isTrue();
+        assertThat(a != b).isFalse();
+    }
+
+    @Test
+    void givenTwoIntsWithDifferentValuesOneWrapped_whenEqualityOperators_thenNotConsideredSame() {
+        int a = 1;
+        Integer b = new Integer(2);
+
+        assertThat(a == b).isFalse();
+        assertThat(a != b).isTrue();
+    }
+
+    @Test
+    void givenTwoIntegersWithSameValues_whenEqualityOperators_thenNotConsideredSame() {
+        Integer a = new Integer(1);
+        Integer b = new Integer(1);
+
+        assertThat(a == b).isFalse();
+        assertThat(a != b).isTrue();
+    }
+
+    @Test
+    void givenTwoIntegersWithDifferentValues_whenEqualityOperators_thenNotConsideredSame() {
+        Integer a = new Integer(1);
+        Integer b = new Integer(2);
+
+        assertThat(a == b).isFalse();
+        assertThat(a != b).isTrue();
+    }
+
+    @Test
+    void givenTwoIntegersWithSameReference_whenEqualityOperators_thenConsideredSame() {
+        Integer a = new Integer(1);
+        Integer b = a;
+
+        assertThat(a == b).isTrue();
+        assertThat(a != b).isFalse();
+    }
+
+    @Test
+    void givenTwoIntegersFromValueOfWithSameValues_whenEqualityOperators_thenConsideredSame() {
+        Integer a = Integer.valueOf(1);
+        Integer b = Integer.valueOf(1);
+
+        assertThat(a == b).isTrue();
+        assertThat(a != b).isFalse();
+    }
+
+    @Test
+    void givenTwoStringsWithSameValues_whenEqualityOperators_thenNotConsideredSame() {
+        String a = new String("Hello!");
+        String b = new String("Hello!");
+
+        assertThat(a == b).isFalse();
+        assertThat(a != b).isTrue();
+    }
+
+    @Test
+    void givenTwoStringsFromLiteralsWithSameValues_whenEqualityOperators_thenConsideredSame() {
+        String a = "Hello!";
+        String b = "Hello!";
+
+        assertThat(a == b).isTrue();
+        assertThat(a != b).isFalse();
+    }
+
+    @Test
+    void givenTwoNullObjects_whenEqualityOperators_thenConsideredSame() {
+        Object a = null;
+        Object b = null;
+
+        assertThat(a == b).isTrue();
+        assertThat(a != b).isFalse();
+    }
+
+    @Test
+    void givenTwoObjectsOneNull_whenEqualityOperators_thenNotConsideredSame() {
+        Object a = null;
+        Object b = "Hello!";
+
+        assertThat(a == b).isFalse();
+        assertThat(a != b).isTrue();
+    }
+}

core-java-modules/core-java-lang-2/src/test/java/com/baeldung/comparing/EqualsMethodUnitTest.java

@@ -0,0 +1,73 @@
+package com.baeldung.comparing;
+
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+class EqualsMethodUnitTest {
+
+    @Test
+    void givenTwoIntegersWithSameValue_whenEquals_thenTrue() {
+        Integer a = new Integer(1);
+        Integer b = new Integer(1);
+
+        assertThat(a.equals(b)).isTrue();
+    }
+
+    @Test
+    void givenTwoStringsWithSameValue_whenEquals_thenTrue() {
+        String a = new String("Hello!");
+        String b = new String("Hello!");
+
+        assertThat(a.equals(b)).isTrue();
+    }
+
+    @Test
+    void givenTwoStringsWithDifferentValue_whenEquals_thenFalse() {
+        String a = new String("Hello!");
+        String b = new String("Hello World!");
+
+        assertThat(a.equals(b)).isFalse();
+    }
+
+    @Test
+    void givenTwoObjectsFirstNull_whenEquals_thenNullPointerExceptionThrown() {
+        Object a = null;
+        Object b = new String("Hello!");
+
+        assertThrows(NullPointerException.class, () -> a.equals(b));
+    }
+
+    @Test
+    void givenTwoObjectsSecondNull_whenEquals_thenFalse() {
+        Object a = new String("Hello!");
+        Object b = null;
+
+        assertThat(a.equals(b)).isFalse();
+    }
+
+    @Test
+    void givenTwoPersonWithoutEqualsWithSameNames_whenEquals_thenFalse() {
+        PersonWithoutEquals joe = new PersonWithoutEquals("Joe", "Portman");
+        PersonWithoutEquals joeAgain = new PersonWithoutEquals("Joe", "Portman");
+
+        assertThat(joe.equals(joeAgain)).isFalse();
+    }
+
+    @Test
+    void givenTwoPersonWithEqualsWithSameNames_whenEquals_thenTrue() {
+        PersonWithEquals joe = new PersonWithEquals("Joe", "Portman");
+        PersonWithEquals joeAgain = new PersonWithEquals("Joe", "Portman");
+
+        assertThat(joe.equals(joeAgain)).isTrue();
+    }
+
+    @Test
+    void givenTwoPersonWittEqualsWithDifferentNames_whenEquals_thenFalse() {
+        PersonWithEquals joe = new PersonWithEquals("Joe", "Portman");
+        PersonWithEquals natalie = new PersonWithEquals("Natalie", "Portman");
+
+        assertThat(joe.equals(natalie)).isFalse();
+    }
+}

core-java-modules/core-java-lang-2/src/test/java/com/baeldung/comparing/GuavaUnitTest.java

@@ -0,0 +1,73 @@
+package com.baeldung.comparing;
+
+import com.google.common.base.Objects;
+import com.google.common.collect.ComparisonChain;
+import com.google.common.primitives.Ints;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class GuavaUnitTest {
+
+    @Nested
+    class ObjectsEqualMethod {
+        @Test
+        void givenTwoStringsWithSameValues_whenObjectsEqualMethods_thenTrue() {
+            String a = new String("Hello!");
+            String b = new String("Hello!");
+
+            assertThat(Objects.equal(a, b)).isTrue();
+        }
+
+        @Test
+        void givenTwoStringsWithDifferentValues_whenObjectsEqualMethods_thenFalse() {
+            String a = new String("Hello!");
+            String b = new String("Hello World!");
+
+            assertThat(Objects.equal(a, b)).isFalse();
+        }
+    }
+
+    @Nested
+    class ComparisonMethods {
+        @Test
+        void givenTwoIntsWithConsecutiveValues_whenIntsCompareMethods_thenNegative() {
+            int first = 1;
+            int second = 2;
+            assertThat(Ints.compare(first, second)).isNegative();
+        }
+
+        @Test
+        void givenTwoIntsWithSameValues_whenIntsCompareMethods_thenZero() {
+            int first = 1;
+            int second = 1;
+
+            assertThat(Ints.compare(first, second)).isZero();
+        }
+
+        @Test
+        void givenTwoIntsWithConsecutiveValues_whenIntsCompareMethodsReversed_thenNegative() {
+            int first = 1;
+            int second = 2;
+
+            assertThat(Ints.compare(second, first)).isPositive();
+        }
+    }
+
+    @Nested
+    class ComparisonChainClass {
+        @Test
+        void givenTwoPersonWithEquals_whenComparisonChainByLastNameThenFirstName_thenSortedJoeFirstAndNatalieSecond() {
+            PersonWithEquals natalie = new PersonWithEquals("Natalie", "Portman");
+            PersonWithEquals joe = new PersonWithEquals("Joe", "Portman");
+
+            int comparisonResult = ComparisonChain.start()
+              .compare(natalie.lastName(), joe.lastName())
+              .compare(natalie.firstName(), joe.firstName())
+              .result();
+
+            assertThat(comparisonResult).isPositive();
+        }
+    }
+}

core-java-modules/core-java-lang-2/src/test/java/com/baeldung/comparing/ObjectsEqualsStaticMethodUnitTest.java

@@ -0,0 +1,50 @@
+package com.baeldung.comparing;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.Objects;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class ObjectsEqualsStaticMethodUnitTest {
+
+    @Test
+    void givenTwoPersonWithEqualsWithSameNames_whenObjectsEquals_thenTrue() {
+        PersonWithEquals joe = new PersonWithEquals("Joe", "Portman");
+        PersonWithEquals joeAgain = new PersonWithEquals("Joe", "Portman");
+
+        assertThat(Objects.equals(joe, joeAgain)).isTrue();
+    }
+
+    @Test
+    void givenTwoPersonWithEqualsWithDifferentNames_whenObjectsEquals_thenFalse() {
+        PersonWithEquals joe = new PersonWithEquals("Joe", "Portman");
+        PersonWithEquals natalie = new PersonWithEquals("Natalie", "Portman");
+
+        assertThat(Objects.equals(joe, natalie)).isFalse();
+    }
+
+    @Test
+    void givenTwoPersonWithEqualsFirstNull_whenObjectsEquals_thenFalse() {
+        PersonWithEquals nobody = null;
+        PersonWithEquals joe = new PersonWithEquals("Joe", "Portman");
+
+        assertThat(Objects.equals(nobody, joe)).isFalse();
+    }
+
+    @Test
+    void givenTwoObjectsSecondtNull_whenObjectsEquals_thenFalse() {
+        PersonWithEquals joe = new PersonWithEquals("Joe", "Portman");
+        PersonWithEquals nobody = null;
+
+        assertThat(Objects.equals(joe, nobody)).isFalse();
+    }
+
+    @Test
+    void givenTwoObjectsNull_whenObjectsEquals_thenTrue() {
+        PersonWithEquals nobody = null;
+        PersonWithEquals nobodyAgain = null;
+
+        assertThat(Objects.equals(nobody, nobodyAgain)).isTrue();
+    }
+}