Module dev.mccue.guava.base
Package dev.mccue.guava.base

Class Equivalence<T>

java.lang.Object
dev.mccue.guava.base.Equivalence<T>
All Implemented Interfaces:
BiPredicate<@Nullable T,@Nullable T>
public abstract class Equivalence<T> extends Object implements BiPredicate<@Nullable T,@Nullable T>
A strategy for determining whether two instances are considered equivalent, and for computing hash codes in a manner consistent with that equivalence. Two examples of equivalences are the #identity() identity equivalence and the #equals "equals" equivalence.
Since:
10.0 (mostly source-compatible since 4.0)
Author:
Bob Lee, Ben Yu, Gregory Kick

  • Nested Class Summary

    Nested Classes
    Modifier and Type
    Class
    Description
    static final class 
    Equivalence.Wrapper<T extends @Nullable Object>
    Wraps an object so that #equals(Object) and #hashCode() delegate to an Equivalence.

  • Constructor Summary

    Constructors
    Modifier
    Constructor
    Description
    protected
    Equivalence()
    Constructor for use by subclasses.

  • Method Summary

    Modifier and Type
    Method
    Description
    protected abstract boolean
    doEquivalent(T a, T b)
    Implemented by the user to determine whether a and b are considered equivalent, subject to the requirements specified in #equivalent.
    protected abstract int
    doHash(T t)
    Implemented by the user to return a hash code for t, subject to the requirements specified in #hash.
    static Equivalence<Object>
    equals()
    Returns an equivalence that delegates to Object#equals and Object#hashCode.
    final boolean
    equivalent(T a, T b)
    Returns true if the given objects are considered equivalent.
    final Predicate<@Nullable T>
    equivalentTo(T target)
    Returns a predicate that evaluates to true if and only if the input is equivalent to target according to this equivalence relation.
    final int
    hash(T t)
    Returns a hash code for t.
    static Equivalence<Object>
    identity()
    Returns an equivalence that uses == to compare values and System#identityHashCode(Object) to compute the hash code.
    final <F> Equivalence<F>
    onResultOf(Function<? super F,? extends @Nullable T> function)
    Returns a new equivalence relation for F which evaluates equivalence by first applying function to the argument, then evaluating using this.
    final <S extends @Nullable T>
    Equivalence<Iterable<S>>
    pairwise()
    Returns an equivalence over iterables based on the equivalence of their elements.
    final boolean
    test(T t, T u)
    Deprecated.
    Provided only to satisfy the BiPredicate interface; use #equivalent instead.
    final <S extends @Nullable T>
    Equivalence.Wrapper<S>
    wrap(S reference)
    Returns a wrapper of reference that implements Wrapper#equals(Object) Object.equals() such that wrap(a).equals(wrap(b)) if and only if equivalent(a, b).

    Methods inherited from class java.lang.Object

    clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

    Methods inherited from interface java.util.function.BiPredicate

    and, negate, or

  • Constructor Details

    • Equivalence

      protected Equivalence()
      Constructor for use by subclasses.

  • Method Details

    • equivalent

      public final boolean equivalent(@CheckForNull T a, @CheckForNull T b)
      Returns true if the given objects are considered equivalent.

      This method describes an equivalence relation on object references, meaning that for all references x, y, and z (any of which may be null):

      • equivalent(x, x) is true (reflexive property)
      • equivalent(x, y) and equivalent(y, x) each return the same result (symmetric property)
      • If equivalent(x, y) and equivalent(y, z) are both true, then equivalent(x, z) is also true (transitive property)

      Note that all calls to equivalent(x, y) are expected to return the same result as long as neither x nor y is modified.

    • test

      @Deprecated public final boolean test(@CheckForNull T t, @CheckForNull T u)
      Deprecated.
      Provided only to satisfy the BiPredicate interface; use #equivalent instead.
      Specified by:
      test in interface BiPredicate<@Nullable T,@Nullable T>
      Since:
      21.0

    • doEquivalent

      @ForOverride protected abstract boolean doEquivalent(T a, T b)
      Implemented by the user to determine whether a and b are considered equivalent, subject to the requirements specified in #equivalent.

      This method should not be called except by #equivalent. When #equivalent calls this method, a and b are guaranteed to be distinct, non-null instances.

      Since:
      10.0 (previously, subclasses would override equivalent())

    • hash

      public final int hash(@CheckForNull T t)
      Returns a hash code for t.

      The hash has the following properties:

      • It is consistent: for any reference x, multiple invocations of hash(x} consistently return the same value provided x remains unchanged according to the definition of the equivalence. The hash need not remain consistent from one execution of an application to another execution of the same application.
      • It is distributable across equivalence: for any references x and y, if equivalent(x, y), then hash(x) == hash(y). It is not necessary that the hash be distributable across inequivalence. If equivalence(x, y) is false, hash(x) == hash(y) may still be true.
      • hash(null) is 0.

    • doHash

      @ForOverride protected abstract int doHash(T t)
      Implemented by the user to return a hash code for t, subject to the requirements specified in #hash.

      This method should not be called except by #hash. When #hash calls this method, t is guaranteed to be non-null.

      Since:
      10.0 (previously, subclasses would override hash())

    • onResultOf

      public final <F> Equivalence<F> onResultOf(Function<? super F,? extends @Nullable T> function)
      Returns a new equivalence relation for F which evaluates equivalence by first applying function to the argument, then evaluating using this. That is, for any pair of non-null objects x and y, equivalence.onResultOf(function).equivalent(a, b) is true if and only if equivalence.equivalent(function.apply(a), function.apply(b)) is true.

      For example: 

      
 Equivalence<Person> SAME_AGE = Equivalence.equals().onResultOf(GET_PERSON_AGE);

      function will never be invoked with a null value.

      Note that function must be consistent according to this equivalence relation. That is, invoking Function#apply multiple times for a given value must return equivalent results. For example, Equivalence.identity().onResultOf(Functions.toStringFunction()) is broken because it's not guaranteed that Object#toString) always returns the same string instance.

      Since:
      10.0

    • wrap

      public final <S extends @Nullable T> Equivalence.Wrapper<S> wrap(S reference)
      Returns a wrapper of reference that implements Wrapper#equals(Object) Object.equals() such that wrap(a).equals(wrap(b)) if and only if equivalent(a, b).

      The returned object is serializable if both this Equivalence and reference are serializable (including when reference is null).

      Since:
      10.0

    • pairwise

      public final <S extends @Nullable T> Equivalence<Iterable<S>> pairwise()
      Returns an equivalence over iterables based on the equivalence of their elements. More specifically, two iterables are considered equivalent if they both contain the same number of elements, and each pair of corresponding elements is equivalent according to this. Null iterables are equivalent to one another.

      Note that this method performs a similar function for equivalences as dev.mccue.guava.collect.Ordering#lexicographical does for orderings.

      The returned object is serializable if this object is serializable.

      Since:
      10.0

    • equivalentTo

      public final Predicate<@Nullable T> equivalentTo(@CheckForNull T target)
      Returns a predicate that evaluates to true if and only if the input is equivalent to target according to this equivalence relation.
      Since:
      10.0

    • equals

      public static Equivalence<Object> equals()
      Returns an equivalence that delegates to Object#equals and Object#hashCode. Equivalence#equivalent returns true if both values are null, or if neither value is null and Object#equals returns true. Equivalence#hash returns 0 if passed a null value.
      Since:
      13.0, 8.0 (in Equivalences with null-friendly behavior), 4.0 (in Equivalences)

    • identity

      public static Equivalence<Object> identity()
      Returns an equivalence that uses == to compare values and System#identityHashCode(Object) to compute the hash code. Equivalence#equivalent returns true if a == b, including in the case that a and b are both null.
      Since:
      13.0, 4.0 (in Equivalences)