ComparisonChain (Guava: Google Core Libraries for Java 19.0-rc3 API)

java.lang.Object
- com.google.common.collect.ComparisonChain

```
@CheckReturnValue
@GwtCompatible
public abstract class ComparisonChain
extends Object
```
A utility for performing a chained comparison statement. For example:
```
   public int compareTo(Foo that) {
     return ComparisonChain.start()
         .compare(this.aString, that.aString)
         .compare(this.anInt, that.anInt)
         .compare(this.anEnum, that.anEnum, Ordering.natural().nullsLast())
         .result();
   }
```
The value of this expression will have the same sign as the first nonzero comparison result in the chain, or will be zero if every comparison result was zero.
Note: ComparisonChain instances are immutable. For this utility to work correctly, calls must be chained as illustrated above.
Performance note: Even though the ComparisonChain caller always invokes its compare methods unconditionally, the ComparisonChain implementation stops calling its inputs' compareTo and compare methods as soon as one of them returns a nonzero result. This optimization is typically important only in the presence of expensive compareTo and compare implementations.
See the Guava User Guide article on ComparisonChain.
Since:

2.0

Author:

Mark Davis, Kevin Bourrillion

Method Summary

Methods
Modifier and Type	Method and Description
`ComparisonChain`	`compare(Boolean left, Boolean right)` Deprecated. Use `compareFalseFirst(boolean, boolean)`; or, if the parameters passed are being either negated or reversed, undo the negation or reversal and use `compareTrueFirst(boolean, boolean)`.
`abstract ComparisonChain`	`compare(Comparable<?> left, Comparable<?> right)` Compares two comparable objects as specified by `Comparable.compareTo(T)`, if the result of this comparison chain has not already been determined.
`abstract ComparisonChain`	`compare(double left, double right)` Compares two `double` values as specified by `Double.compare(double, double)`, if the result of this comparison chain has not already been determined.
`abstract ComparisonChain`	`compare(float left, float right)` Compares two `float` values as specified by `Float.compare(float, float)`, if the result of this comparison chain has not already been determined.
`abstract ComparisonChain`	`compare(int left, int right)` Compares two `int` values as specified by `Ints.compare(int, int)`, if the result of this comparison chain has not already been determined.
`abstract ComparisonChain`	`compare(long left, long right)` Compares two `long` values as specified by `Longs.compare(long, long)`, if the result of this comparison chain has not already been determined.
`abstract <T> ComparisonChain`	`compare(T left, T right, Comparator<T> comparator)` Compares two objects using a comparator, if the result of this comparison chain has not already been determined.
`abstract ComparisonChain`	`compareFalseFirst(boolean left, boolean right)` Compares two `boolean` values, considering `false` to be less than `true`, if the result of this comparison chain has not already been determined.
`abstract ComparisonChain`	`compareTrueFirst(boolean left, boolean right)` Compares two `boolean` values, considering `true` to be less than `false`, if the result of this comparison chain has not already been determined.
`abstract int`	`result()` Ends this comparison chain and returns its result: a value having the same sign as the first nonzero comparison result in the chain, or zero if every result was zero.
`static ComparisonChain`	`start()` Begins a new chained comparison statement.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - start
```
public static ComparisonChain start()
```
    Begins a new chained comparison statement. See example in the class documentation.
  - compare
```
public abstract ComparisonChain compare(Comparable<?> left,
                      Comparable<?> right)
```
    Compares two comparable objects as specified by Comparable.compareTo(T), if the result of this comparison chain has not already been determined.
  - compare
```
public abstract <T> ComparisonChain compare(@Nullable
                          T left,
                          @Nullable
                          T right,
                          Comparator<T> comparator)
```
    Compares two objects using a comparator, if the result of this comparison chain has not already been determined.
  - compare
```
public abstract ComparisonChain compare(int left,
                      int right)
```
    Compares two int values as specified by Ints.compare(int, int), if the result of this comparison chain has not already been determined.
  - compare
```
public abstract ComparisonChain compare(long left,
                      long right)
```
    Compares two long values as specified by Longs.compare(long, long), if the result of this comparison chain has not already been determined.
  - compare
```
public abstract ComparisonChain compare(float left,
                      float right)
```
    Compares two float values as specified by Float.compare(float, float), if the result of this comparison chain has not already been determined.
  - compare
```
public abstract ComparisonChain compare(double left,
                      double right)
```
    Compares two double values as specified by Double.compare(double, double), if the result of this comparison chain has not already been determined.
  - compare
```
@Deprecated
public final ComparisonChain compare(Boolean left,
                                 Boolean right)
```
    Deprecated. Use compareFalseFirst(boolean, boolean); or, if the parameters passed are being either negated or reversed, undo the negation or reversal and use compareTrueFirst(boolean, boolean).
    
    Discouraged synonym for compareFalseFirst(boolean, boolean).
    
    Since:
    
    19.0
  - compareTrueFirst
```
public abstract ComparisonChain compareTrueFirst(boolean left,
                               boolean right)
```
    Compares two boolean values, considering true to be less than false, if the result of this comparison chain has not already been determined.
    
    Since:
    
    12.0
  - compareFalseFirst
```
public abstract ComparisonChain compareFalseFirst(boolean left,
                                boolean right)
```
    Compares two boolean values, considering false to be less than true, if the result of this comparison chain has not already been determined.
    
    Since:
    
    12.0 (present as compare since 2.0)
  - result
```
public abstract int result()
```
    Ends this comparison chain and returns its result: a value having the same sign as the first nonzero comparison result in the chain, or zero if every result was zero.

Class ComparisonChain

Method Summary

Methods inherited from class java.lang.Object

Method Detail

start

compare

compare

compare

compare

compare

compare

compare

compareTrueFirst

compareFalseFirst

result