Merge pull request #9224 from dupirefr/author/BAEL-3981-comparing_objects
[BAEL-3981] Comparing in Java
This commit is contained in:
Greg
GitHub
commit
8c987e89c9
@ -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>
|
||||
|
||||
@ -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);
|
||||
}
|
||||
}
|
||||
@ -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;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -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);
|
||||
}
|
||||
}
|
||||
@ -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);
|
||||
}
|
||||
}
|
||||
@ -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;
|
||||
}
|
||||
}
|
||||
@ -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();
|
||||
}
|
||||
}
|
||||
@ -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);
|
||||
}
|
||||
}
|
||||
@ -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);
|
||||
}
|
||||
}
|
||||
@ -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();
|
||||
}
|
||||
}
|
||||
@ -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();
|
||||
}
|
||||
}
|
||||
@ -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();
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -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();
|
||||
}
|
||||
}
|
||||
Loading…
x
Reference in New Issue
Block a user