From d1e64fb5db0d3c08954ace7f8a3d222dbb648865 Mon Sep 17 00:00:00 2001 From: dupirefr Date: Wed, 29 Apr 2020 10:05:02 +0200 Subject: [PATCH] [BAEL-3981] Code for article * Equality operators * Object#equals method * Objects#equals static method * Comparable interface * Comparator interface * Apache Commons features * Guava features --- core-java-modules/core-java-lang-2/pom.xml | 9 +- .../java/com/baeldung/comparing/Person.java | 217 ++++++++++++++++++ .../ApacheCommonsObjectUtilsUnitTest.java | 59 +++++ .../ComparableInterfaceUnitTest.java | 107 +++++++++ .../ComparatorInterfaceUnitTest.java | 81 +++++++ .../comparing/EqualityOperatorUnitTest.java | 116 ++++++++++ .../comparing/EqualsMethodUnitTest.java | 73 ++++++ .../com/baeldung/comparing/GuavaUnitTest.java | 80 +++++++ .../ObjectsEqualsStaticMethodUnitTest.java | 50 ++++ 9 files changed, 791 insertions(+), 1 deletion(-) create mode 100644 core-java-modules/core-java-lang-2/src/main/java/com/baeldung/comparing/Person.java create mode 100644 core-java-modules/core-java-lang-2/src/test/java/com/baeldung/comparing/ApacheCommonsObjectUtilsUnitTest.java create mode 100644 core-java-modules/core-java-lang-2/src/test/java/com/baeldung/comparing/ComparableInterfaceUnitTest.java create mode 100644 core-java-modules/core-java-lang-2/src/test/java/com/baeldung/comparing/ComparatorInterfaceUnitTest.java create mode 100644 core-java-modules/core-java-lang-2/src/test/java/com/baeldung/comparing/EqualityOperatorUnitTest.java create mode 100644 core-java-modules/core-java-lang-2/src/test/java/com/baeldung/comparing/EqualsMethodUnitTest.java create mode 100644 core-java-modules/core-java-lang-2/src/test/java/com/baeldung/comparing/GuavaUnitTest.java create mode 100644 core-java-modules/core-java-lang-2/src/test/java/com/baeldung/comparing/ObjectsEqualsStaticMethodUnitTest.java diff --git a/core-java-modules/core-java-lang-2/pom.xml b/core-java-modules/core-java-lang-2/pom.xml index 5aa80ce3df..449b700560 100644 --- a/core-java-modules/core-java-lang-2/pom.xml +++ b/core-java-modules/core-java-lang-2/pom.xml @@ -20,7 +20,12 @@ org.apache.commons commons-lang3 - 3.9 + ${commons-lang3.version} + + + com.google.guava + guava + ${guava.version} commons-beanutils @@ -65,6 +70,8 @@ 1.19 3.12.2 1.9.4 + 3.9 + 29.0-jre diff --git a/core-java-modules/core-java-lang-2/src/main/java/com/baeldung/comparing/Person.java b/core-java-modules/core-java-lang-2/src/main/java/com/baeldung/comparing/Person.java new file mode 100644 index 0000000000..7c7088a0c7 --- /dev/null +++ b/core-java-modules/core-java-lang-2/src/main/java/com/baeldung/comparing/Person.java @@ -0,0 +1,217 @@ +package com.baeldung.comparing; + +import java.time.LocalDate; +import java.util.Comparator; +import java.util.Objects; + +public class Person { + public static class PersonWithoutEquals { + private String firstName; + private String lastName; + + public PersonWithoutEquals(String firstName, String lastName) { + this.firstName = firstName; + this.lastName = lastName; + } + } + + public static 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); + } + } + + public static class PersonWithEqualsAndWrongComparable implements Comparable { + 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); + } + } + + public static class PersonWithEqualsAndComparable implements Comparable { + 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; + } + } + } + + public static class PersonWithEqualsAndComparableUsingComparator implements Comparable { + 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); + } + } +} diff --git a/core-java-modules/core-java-lang-2/src/test/java/com/baeldung/comparing/ApacheCommonsObjectUtilsUnitTest.java b/core-java-modules/core-java-lang-2/src/test/java/com/baeldung/comparing/ApacheCommonsObjectUtilsUnitTest.java new file mode 100644 index 0000000000..33b8dcb3fc --- /dev/null +++ b/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(); + } +} diff --git a/core-java-modules/core-java-lang-2/src/test/java/com/baeldung/comparing/ComparableInterfaceUnitTest.java b/core-java-modules/core-java-lang-2/src/test/java/com/baeldung/comparing/ComparableInterfaceUnitTest.java new file mode 100644 index 0000000000..6e10188852 --- /dev/null +++ b/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() { + Person.PersonWithEqualsAndWrongComparable richard = new Person.PersonWithEqualsAndWrongComparable("Richard", "Jefferson"); + Person.PersonWithEqualsAndWrongComparable joe = new Person.PersonWithEqualsAndWrongComparable("Joe", "Portman"); + + assertThat(richard.compareTo(joe)).isNegative(); + } + + @Test + void givenTwoPersonWithEqualsAndWrongComparableAndSameLastNames_whenReversedCompareTo_thenZero() { + Person.PersonWithEqualsAndWrongComparable richard = new Person.PersonWithEqualsAndWrongComparable("Richard", "Jefferson"); + Person.PersonWithEqualsAndWrongComparable mike = new Person.PersonWithEqualsAndWrongComparable("Mike", "Jefferson"); + + assertThat(richard.compareTo(mike)).isZero(); + } + + @Test + void givenTwoPersonWithEqualsAndWrongComparableAndConsecutiveLastNames_whenReversedCompareTo_thenPositive() { + Person.PersonWithEqualsAndWrongComparable richard = new Person.PersonWithEqualsAndWrongComparable("Richard", "Jefferson"); + Person.PersonWithEqualsAndWrongComparable joe = new Person.PersonWithEqualsAndWrongComparable("Joe", "Portman"); + + assertThat(joe.compareTo(richard)).isPositive(); + } + + @Test + void givenTwoPersonWithEqualsAndWrongComparableAndSameLastNames_whenSortedSet_thenProblem() { + Person.PersonWithEqualsAndWrongComparable richard = new Person.PersonWithEqualsAndWrongComparable("Richard", "Jefferson"); + Person.PersonWithEqualsAndWrongComparable mike = new Person.PersonWithEqualsAndWrongComparable("Mike", "Jefferson"); + + SortedSet people = new TreeSet<>(); + people.add(richard); + people.add(mike); + + assertThat(people).containsExactly(richard); + } + + @Test + void givenTwoPersonWithEqualsAndComparableAndConsecutiveLastNames_whenCompareTo_thenNegative() { + Person.PersonWithEqualsAndComparable richard = new Person.PersonWithEqualsAndComparable("Richard", "Jefferson"); + Person.PersonWithEqualsAndComparable joe = new Person.PersonWithEqualsAndComparable("Joe", "Portman"); + + assertThat(richard.compareTo(joe)).isNegative(); + } + + @Test + void givenTwoPersonWithEqualsAndComparableAndSameLastNames_whenReversedCompareTo_thenZero() { + Person.PersonWithEqualsAndComparable richard = new Person.PersonWithEqualsAndComparable("Richard", "Jefferson"); + Person.PersonWithEqualsAndComparable mike = new Person.PersonWithEqualsAndComparable("Mike", "Jefferson"); + + assertThat(richard.compareTo(mike)).isPositive(); + } + + @Test + void givenTwoPersonWithEqualsAndComparableAndConsecutiveLastNames_whenReversedCompareTo_thenPositive() { + Person.PersonWithEqualsAndComparable richard = new Person.PersonWithEqualsAndComparable("Richard", "Jefferson"); + Person.PersonWithEqualsAndComparable joe = new Person.PersonWithEqualsAndComparable("Joe", "Portman"); + + assertThat(joe.compareTo(richard)).isPositive(); + } + + @Test + void givenTwoPersonWithEqualsAndComparableAndSameLastNames_whenSortedSet_thenProblem() { + Person.PersonWithEqualsAndComparable richard = new Person.PersonWithEqualsAndComparable("Richard", "Jefferson"); + Person.PersonWithEqualsAndComparable mike = new Person.PersonWithEqualsAndComparable("Mike", "Jefferson"); + + SortedSet people = new TreeSet<>(); + people.add(richard); + people.add(mike); + + assertThat(people).containsExactly(mike, richard); + } +} diff --git a/core-java-modules/core-java-lang-2/src/test/java/com/baeldung/comparing/ComparatorInterfaceUnitTest.java b/core-java-modules/core-java-lang-2/src/test/java/com/baeldung/comparing/ComparatorInterfaceUnitTest.java new file mode 100644 index 0000000000..a406b12752 --- /dev/null +++ b/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() { + Person.PersonWithEquals joe = new Person.PersonWithEquals("Joe", "Portman"); + Person.PersonWithEquals allan = new Person.PersonWithEquals("Allan", "Dale"); + + List people = new ArrayList<>(); + people.add(joe); + people.add(allan); + + Comparator compareByFirstNames = new Comparator() { + @Override + public int compare(Person.PersonWithEquals o1, Person.PersonWithEquals o2) { + return o1.firstName().compareTo(o2.firstName()); + } + }; + people.sort(compareByFirstNames); + + assertThat(people).containsExactly(allan, joe); + } + + @Test + void givenListOfTwoPersonWithEqualsAndComparatorByFirstNameFunctionalStyle_whenSort_thenSortedByFirstNames() { + Person.PersonWithEquals joe = new Person.PersonWithEquals("Joe", "Portman"); + Person.PersonWithEquals allan = new Person.PersonWithEquals("Allan", "Dale"); + + List people = new ArrayList<>(); + people.add(joe); + people.add(allan); + + Comparator compareByFirstNames = Comparator.comparing(Person.PersonWithEquals::firstName); + people.sort(compareByFirstNames); + + assertThat(people).containsExactly(allan, joe); + } + + @Test + void givenTwoPersonWithEqualsAndComparableUsingComparatorAndConsecutiveLastNames_whenCompareTo_thenNegative() { + Person.PersonWithEqualsAndComparableUsingComparator richard = new Person.PersonWithEqualsAndComparableUsingComparator("Richard", "Jefferson"); + Person.PersonWithEqualsAndComparableUsingComparator joe = new Person.PersonWithEqualsAndComparableUsingComparator("Joe", "Portman"); + + assertThat(richard.compareTo(joe)).isNegative(); + } + + @Test + void givenTwoPersonWithEqualsAndComparableUsingComparatorAndSameLastNames_whenReversedCompareTo_thenZero() { + Person.PersonWithEqualsAndComparableUsingComparator richard = new Person.PersonWithEqualsAndComparableUsingComparator("Richard", "Jefferson"); + Person.PersonWithEqualsAndComparableUsingComparator mike = new Person.PersonWithEqualsAndComparableUsingComparator("Mike", "Jefferson"); + + assertThat(richard.compareTo(mike)).isPositive(); + } + + @Test + void givenTwoPersonWithEqualsAndComparableUsingComparatorAndConsecutiveLastNames_whenReversedCompareTo_thenPositive() { + Person.PersonWithEqualsAndComparableUsingComparator richard = new Person.PersonWithEqualsAndComparableUsingComparator("Richard", "Jefferson"); + Person.PersonWithEqualsAndComparableUsingComparator joe = new Person.PersonWithEqualsAndComparableUsingComparator("Joe", "Portman"); + + assertThat(joe.compareTo(richard)).isPositive(); + } + + @Test + void givenTwoPersonWithEqualsAndComparableUsingComparatorAndSameLastNames_whenSortedSet_thenProblem() { + Person.PersonWithEqualsAndComparableUsingComparator richard = new Person.PersonWithEqualsAndComparableUsingComparator("Richard", "Jefferson"); + Person.PersonWithEqualsAndComparableUsingComparator mike = new Person.PersonWithEqualsAndComparableUsingComparator("Mike", "Jefferson"); + + SortedSet people = new TreeSet<>(); + people.add(richard); + people.add(mike); + + assertThat(people).containsExactly(mike, richard); + } +} diff --git a/core-java-modules/core-java-lang-2/src/test/java/com/baeldung/comparing/EqualityOperatorUnitTest.java b/core-java-modules/core-java-lang-2/src/test/java/com/baeldung/comparing/EqualityOperatorUnitTest.java new file mode 100644 index 0000000000..ebcf83ef5b --- /dev/null +++ b/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(); + } +} diff --git a/core-java-modules/core-java-lang-2/src/test/java/com/baeldung/comparing/EqualsMethodUnitTest.java b/core-java-modules/core-java-lang-2/src/test/java/com/baeldung/comparing/EqualsMethodUnitTest.java new file mode 100644 index 0000000000..4775bc3de1 --- /dev/null +++ b/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() { + Person.PersonWithoutEquals joe = new Person.PersonWithoutEquals("Joe", "Portman"); + Person.PersonWithoutEquals joeAgain = new Person.PersonWithoutEquals("Joe", "Portman"); + + assertThat(joe.equals(joeAgain)).isFalse(); + } + + @Test + void givenTwoPersonWithEqualsWithSameNames_whenEquals_thenTrue() { + Person.PersonWithEquals joe = new Person.PersonWithEquals("Joe", "Portman"); + Person.PersonWithEquals joeAgain = new Person.PersonWithEquals("Joe", "Portman"); + + assertThat(joe.equals(joeAgain)).isTrue(); + } + + @Test + void givenTwoPersonWittEqualsWithDifferentNames_whenEquals_thenFalse() { + Person.PersonWithEquals joe = new Person.PersonWithEquals("Joe", "Portman"); + Person.PersonWithEquals nathalie = new Person.PersonWithEquals("Nathalie", "Portman"); + + assertThat(joe.equals(nathalie)).isFalse(); + } +} diff --git a/core-java-modules/core-java-lang-2/src/test/java/com/baeldung/comparing/GuavaUnitTest.java b/core-java-modules/core-java-lang-2/src/test/java/com/baeldung/comparing/GuavaUnitTest.java new file mode 100644 index 0000000000..0a4d0dd8d3 --- /dev/null +++ b/core-java-modules/core-java-lang-2/src/test/java/com/baeldung/comparing/GuavaUnitTest.java @@ -0,0 +1,80 @@ +package com.baeldung.comparing; + +import com.google.common.base.Objects; +import com.google.common.base.Strings; +import com.google.common.collect.ComparisonChain; +import com.google.common.primitives.Booleans; +import com.google.common.primitives.Bytes; +import com.google.common.primitives.Ints; +import com.google.common.primitives.Shorts; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.util.ArrayList; +import java.util.List; + +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_thenSortedJoeFirstAndNathalieSecond() { + Person.PersonWithEquals nathalie = new Person.PersonWithEquals("Nathalie", "Portman"); + Person.PersonWithEquals joe = new Person.PersonWithEquals("Joe", "Portman"); + + int comparisonResult = ComparisonChain.start() + .compare(nathalie.lastName(), joe.lastName()) + .compare(nathalie.firstName(), joe.firstName()) + .result(); + + assertThat(comparisonResult).isPositive(); + } + } +} diff --git a/core-java-modules/core-java-lang-2/src/test/java/com/baeldung/comparing/ObjectsEqualsStaticMethodUnitTest.java b/core-java-modules/core-java-lang-2/src/test/java/com/baeldung/comparing/ObjectsEqualsStaticMethodUnitTest.java new file mode 100644 index 0000000000..c26cb4e08c --- /dev/null +++ b/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() { + Person.PersonWithEquals joe = new Person.PersonWithEquals("Joe", "Portman"); + Person.PersonWithEquals joeAgain = new Person.PersonWithEquals("Joe", "Portman"); + + assertThat(Objects.equals(joe, joeAgain)).isTrue(); + } + + @Test + void givenTwoPersonWithEqualsWithDifferentNames_whenObjectsEquals_thenFalse() { + Person.PersonWithEquals joe = new Person.PersonWithEquals("Joe", "Portman"); + Person.PersonWithEquals nathalie = new Person.PersonWithEquals("Nathalie", "Portman"); + + assertThat(Objects.equals(joe, nathalie)).isFalse(); + } + + @Test + void givenTwoPersonWithEqualsFirstNull_whenObjectsEquals_thenFalse() { + Person.PersonWithEquals nobody = null; + Person.PersonWithEquals joe = new Person.PersonWithEquals("Joe", "Portman"); + + assertThat(Objects.equals(nobody, joe)).isFalse(); + } + + @Test + void givenTwoObjectsSecondtNull_whenObjectsEquals_thenFalse() { + Person.PersonWithEquals joe = new Person.PersonWithEquals("Joe", "Portman"); + Person.PersonWithEquals nobody = null; + + assertThat(Objects.equals(joe, nobody)).isFalse(); + } + + @Test + void givenTwoObjectsNull_whenObjectsEquals_thenTrue() { + Person.PersonWithEquals nobody = null; + Person.PersonWithEquals nobodyAgain = null; + + assertThat(Objects.equals(nobody, nobodyAgain)).isTrue(); + } +}