CompareToBuilder (bus-all 3.6.5 API)

java.lang.Object
- org.aoju.bus.core.builder.CompareToBuilder

All Implemented Interfaces:: Builder<Integer>

public class CompareToBuilder
extends Object
implements Builder<Integer>

/** 用于构建 Comparable.compareTo(Object) 方法的辅助工具

在Bean对象中，所有相关字段都参与比对，继承的字段不参与。使用方法如下：

 public class MyClass {
   String field1;
   int field2;
   boolean field3;

   ...

   public int compareTo(Object o) {
     MyClass myClass = (MyClass) o;
     return new CompareToBuilder()
       .appendSuper(super.compareTo(o)
       .append(this.field1, myClass.field1)
       .append(this.field2, myClass.field2)
       .append(this.field3, myClass.field3)
       .toComparison();
   }
 }

字段值按照顺序比较，如果某个字段返回非0结果，比较终止，使用toComparison()返回结果，后续比较忽略。

也可以使用reflectionCompare 方法通过反射比较字段，使用方法如下：

 public int compareTo(Object o) {
   return CompareToBuilder.reflectionCompare(this, o);
 }

Since:: JDK 1.8
Version:: 3.6.5
Author:: Kimi Liu

Constructor Summary

Constructors
Constructor and Description

CompareToBuilder()
构造，构造后调用append方法增加比较项，然后调用toComparison()获取结果

Constructors
Constructor and Description
`CompareToBuilder()` 构造，构造后调用append方法增加比较项，然后调用`toComparison()`获取结果

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`CompareToBuilder`	`append(boolean[] left, boolean[] right)` 附加到builder的深层比较,两个boolean数组.
`CompareToBuilder`	`append(boolean left, boolean right)` 附加到builder的深层比较,两个boolean值比较
`CompareToBuilder`	`append(byte[] left, byte[] right)` 附加到builder的深层比较,两个byte数组.
`CompareToBuilder`	`append(byte left, byte right)` 附加到builder的深层比较,两个byte值比较
`CompareToBuilder`	`append(char[] left, char[] right)` 附加到builder的深层比较,两个char数组.
`CompareToBuilder`	`append(char left, char right)` 附加到builder的深层比较,两个char值比较
`CompareToBuilder`	`append(double[] left, double[] right)` 附加到builder的深层比较,两个double数组.
`CompareToBuilder`	`append(double left, double right)` 附加到builder的深层比较,两个double值比较
`CompareToBuilder`	`append(float[] left, float[] right)` 附加到builder的深层比较,两个float数组.
`CompareToBuilder`	`append(float left, float right)` 附加到builder的深层比较,两个float值比较
`CompareToBuilder`	`append(int[] left, int[] right)` 附加到builder的深层比较,两个int数组.
`CompareToBuilder`	`append(int left, int right)` 附加到builder的深层比较,两个int值比较
`CompareToBuilder`	`append(long[] left, long[] right)` 附加到builder的深层比较,两个long数组.
`CompareToBuilder`	`append(long left, long right)` 附加到builder的深层比较,两个long值比较
`CompareToBuilder`	`append(Object[] left, Object[] right)` 附加到builder的深层比较,两个Object数组使用==检查数组是否相同检查是否为null， null小于非null 检查数组长度，长度较短的数组小于长度较长的数组使用`append(Object, Object)`逐个元素检查数组内容
`CompareToBuilder`	`append(Object[] left, Object[] right, Comparator<?> comparator)` 附加到builder的深层比较,两个Object数组使用==检查数组是否相同检查是否为null， null小于非null 检查数组长度，长度较短的数组小于长度较长的数组使用`append(Object, Object, Comparator)`逐个元素检查数组内容
`CompareToBuilder`	`append(Object left, Object right)` 附加到builder的深层比较,两个Object数组使用==检查数组是否相同检查是否为null， null小于非null 检查数组长度，长度较短的数组小于长度较长的数组使用`append(Object, Object)`逐个元素检查数组内容
`CompareToBuilder`	`append(Object left, Object right, Comparator<?> comparator)` 附加到builder的深层比较,两个Object数组使用==检查数组是否相同检查是否为null， null小于非null 检查数组长度，长度较短的数组小于长度较长的数组使用`append(Object, Object, Comparator)`逐个元素检查数组内容
`CompareToBuilder`	`append(short[] left, short[] right)` 附加到builder的深层比较,两个short数组.
`CompareToBuilder`	`append(short left, short right)` 附加到builder的深层比较,两个short值比较
`CompareToBuilder`	`appendSuper(int superCompareTo)` 附加到 builder compareTo(Object) 超类的结果。
`Integer`	`build()` 返回一个负整数、一个正整数或零 builder判断左边小于、大于或等于右边。
`static int`	`reflectionCompare(Object left, Object right)` 通过反射比较两个Bean对象，对象字段可以为private。比较规则如下： static字段不比较 Transient字段不参与比较父类字段参与比较
`static int`	`reflectionCompare(Object left, Object right, boolean compareTransients)` Compares two `Object`s via reflection.
`static int`	`reflectionCompare(Object left, Object right, boolean compareTransients, Class<?> reflectUpToClass, String... excludeFields)` Compares two `Object`s via reflection.
`static int`	`reflectionCompare(Object left, Object right, Collection<String> excludeFields)` Compares two `Object`s via reflection.
`static int`	`reflectionCompare(Object left, Object right, String... excludeFields)` Compares two `Object`s via reflection.
`int`	`toComparison()` 返回一个负整数、一个正整数或零 builder判断左边小于、大于或等于右边。

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

- Constructor Detail
  - CompareToBuilder
```
public CompareToBuilder()
```
    构造，构造后调用append方法增加比较项，然后调用toComparison()获取结果
- Method Detail
  - reflectionCompare
```
public static int reflectionCompare(Object left,
                                    Object right)
```
    通过反射比较两个Bean对象，对象字段可以为private。比较规则如下：
    - static字段不比较
    - Transient字段不参与比较
    - 父类字段参与比较
    如果被比较的两个对象都为null，被认为相同。
    Parameters:
    
    left - 第一个对象
    
    right - 第二个对象
    
    Returns:
    
    a negative integer, zero, or a positive integer as left is less than, equal to, or greater than right
    
    Throws:
    
    NullPointerException - if either (but not both) parameters are null
    
    ClassCastException - if right is not assignment-compatible with left
  - reflectionCompare
```
public static int reflectionCompare(Object left,
                                    Object right,
                                    boolean compareTransients)
```
    Compares two Objects via reflection.
    
    Fields can be private, thus AccessibleObject.setAccessible is used to bypass normal access control checks. This will fail under a security manager unless the appropriate permissions are set.
    - Static fields will not be compared
    - If compareTransients is true, compares transient members. Otherwise ignores them, as they are likely derived fields.
    - Superclass fields will be compared
    If both left and right are null, they are considered equal.
    Parameters:
    
    left - left-hand object
    
    right - right-hand object
    
    compareTransients - whether to compare transient fields
    
    Returns:
    
    a negative integer, zero, or a positive integer as left is less than, equal to, or greater than right
    
    Throws:
    
    NullPointerException - if either left or right (but not both) is null
    
    ClassCastException - if right is not assignment-compatible with left
  - reflectionCompare
```
public static int reflectionCompare(Object left,
                                    Object right,
                                    Collection<String> excludeFields)
```
    Compares two Objects via reflection.
    
    Fields can be private, thus AccessibleObject.setAccessible is used to bypass normal access control checks. This will fail under a security manager unless the appropriate permissions are set.
    - Static fields will not be compared
    - If compareTransients is true, compares transient members. Otherwise ignores them, as they are likely derived fields.
    - Superclass fields will be compared
    If both left and right are null, they are considered equal.
    Parameters:
    
    left - left-hand object
    
    right - right-hand object
    
    excludeFields - Collection of String fields to exclude
    
    Returns:
    
    a negative integer, zero, or a positive integer as left is less than, equal to, or greater than right
    
    Throws:
    
    NullPointerException - if either left or right (but not both) is null
    
    ClassCastException - if right is not assignment-compatible with left
    
    Since:
    
    2.2.0
  - reflectionCompare
```
public static int reflectionCompare(Object left,
                                    Object right,
                                    String... excludeFields)
```
    Compares two Objects via reflection.
    
    Fields can be private, thus AccessibleObject.setAccessible is used to bypass normal access control checks. This will fail under a security manager unless the appropriate permissions are set.
    - Static fields will not be compared
    - If compareTransients is true, compares transient members. Otherwise ignores them, as they are likely derived fields.
    - Superclass fields will be compared
    If both left and right are null, they are considered equal.
    Parameters:
    
    left - left-hand object
    
    right - right-hand object
    
    excludeFields - array of fields to exclude
    
    Returns:
    
    a negative integer, zero, or a positive integer as left is less than, equal to, or greater than right
    
    Throws:
    
    NullPointerException - if either left or right (but not both) is null
    
    ClassCastException - if right is not assignment-compatible with left
    
    Since:
    
    2.2.0
  - reflectionCompare
```
public static int reflectionCompare(Object left,
                                    Object right,
                                    boolean compareTransients,
                                    Class<?> reflectUpToClass,
                                    String... excludeFields)
```
    Compares two Objects via reflection.
    
    Fields can be private, thus AccessibleObject.setAccessible is used to bypass normal access control checks. This will fail under a security manager unless the appropriate permissions are set.
    - Static fields will not be compared
    - If the compareTransients is true, compares transient members. Otherwise ignores them, as they are likely derived fields.
    - Compares superclass fields up to and including reflectUpToClass. If reflectUpToClass is null, compares all superclass fields.
    If both left and right are null, they are considered equal.
    Parameters:
    
    left - left-hand object
    
    right - right-hand object
    
    compareTransients - whether to compare transient fields
    
    reflectUpToClass - last superclass for which fields are compared
    
    excludeFields - fields to exclude
    
    Returns:
    
    a negative integer, zero, or a positive integer as left is less than, equal to, or greater than right
    
    Throws:
    
    NullPointerException - if either left or right (but not both) is null
    
    ClassCastException - if right is not assignment-compatible with left
  - appendSuper
```
public CompareToBuilder appendSuper(int superCompareTo)
```
    附加到 builder compareTo(Object) 超类的结果。
    
    Parameters:
    
    superCompareTo - 调用 super.compareTo(Object)结果
    
    Returns:
    
    this - object
  - append
```
public CompareToBuilder append(Object left,
                               Object right)
```
    附加到builder的深层比较,两个Object数组
    1. 使用==检查数组是否相同
    2. 检查是否为null， null小于非null
    3. 检查数组长度，长度较短的数组小于长度较长的数组
    4. 使用append(Object, Object)逐个元素检查数组内容
    Parameters:
    
    left - 数值
    
    right - 数值
    
    Returns:
    
    this - object
  - append
```
public CompareToBuilder append(Object left,
                               Object right,
                               Comparator<?> comparator)
```
    附加到builder的深层比较,两个Object数组
    1. 使用==检查数组是否相同
    2. 检查是否为null， null小于非null
    3. 检查数组长度，长度较短的数组小于长度较长的数组
    4. 使用append(Object, Object, Comparator)逐个元素检查数组内容
    Parameters:
    
    left - 数值
    
    right - 数值
    
    comparator - 用来比较数值元素的比较器.
    
    Returns:
    
    this - object
  - append
```
public CompareToBuilder append(long left,
                               long right)
```
    附加到builder的深层比较,两个long值比较
    
    Parameters:
    
    left - 数值
    
    right - 数值
    
    Returns:
    
    this - object
  - append
```
public CompareToBuilder append(int left,
                               int right)
```
    附加到builder的深层比较,两个int值比较
    
    Parameters:
    
    left - 数值
    
    right - 数值
    
    Returns:
    
    this - object
  - append
```
public CompareToBuilder append(short left,
                               short right)
```
    附加到builder的深层比较,两个short值比较
    
    Parameters:
    
    left - 数值
    
    right - 数值
    
    Returns:
    
    this - object
  - append
```
public CompareToBuilder append(char left,
                               char right)
```
    附加到builder的深层比较,两个char值比较
    
    Parameters:
    
    left - 数值
    
    right - 数值
    
    Returns:
    
    this - object
  - append
```
public CompareToBuilder append(byte left,
                               byte right)
```
    附加到builder的深层比较,两个byte值比较
    
    Parameters:
    
    left - 数值
    
    right - 数值
    
    Returns:
    
    this - object
  - append
```
public CompareToBuilder append(double left,
                               double right)
```
    附加到builder的深层比较,两个double值比较
    
    Parameters:
    
    left - 数值
    
    right - 数值
    
    Returns:
    
    this - object
  - append
```
public CompareToBuilder append(float left,
                               float right)
```
    附加到builder的深层比较,两个float值比较
    
    Parameters:
    
    left - 数值
    
    right - 数值
    
    Returns:
    
    this - object
  - append
```
public CompareToBuilder append(boolean left,
                               boolean right)
```
    附加到builder的深层比较,两个boolean值比较
    
    Parameters:
    
    left - 数值
    
    right - 数值
    
    Returns:
    
    this - object
  - append
```
public CompareToBuilder append(Object[] left,
                               Object[] right)
```
    附加到builder的深层比较,两个Object数组
    1. 使用==检查数组是否相同
    2. 检查是否为null， null小于非null
    3. 检查数组长度，长度较短的数组小于长度较长的数组
    4. 使用append(Object, Object)逐个元素检查数组内容
    Parameters:
    
    left - 数组
    
    right - 数组
    
    Returns:
    
    this - object
  - append
```
public CompareToBuilder append(Object[] left,
                               Object[] right,
                               Comparator<?> comparator)
```
    附加到builder的深层比较,两个Object数组
    1. 使用==检查数组是否相同
    2. 检查是否为null， null小于非null
    3. 检查数组长度，长度较短的数组小于长度较长的数组
    4. 使用append(Object, Object, Comparator)逐个元素检查数组内容
    Parameters:
    
    left - 数组
    
    right - 数组
    
    comparator - 用来比较数组元素的比较器.
    
    Returns:
    
    this - object
  - append
```
public CompareToBuilder append(long[] left,
                               long[] right)
```
    附加到builder的深层比较,两个long数组.
    1. 使用==检查数组是否相同
    2. 检查是否为null， null小于非null
    3. 检查数组长度，长度较短的数组小于长度较长的数组
    4. 使用append(long, long)逐个元素检查数组内容
    Parameters:
    
    left - 数组
    
    right - 数组
    
    Returns:
    
    this - object
  - append
```
public CompareToBuilder append(int[] left,
                               int[] right)
```
    附加到builder的深层比较,两个int数组.
    1. 使用==检查数组是否相同
    2. 检查是否为null， null小于非null
    3. 检查数组长度，长度较短的数组小于长度较长的数组
    4. 使用append(int, int)逐个元素检查数组内容
    Parameters:
    
    left - 数组
    
    right - 数组
    
    Returns:
    
    this - object
  - append
```
public CompareToBuilder append(short[] left,
                               short[] right)
```
    附加到builder的深层比较,两个short数组.
    1. 使用==检查数组是否相同
    2. 检查是否为null， null小于非null
    3. 检查数组长度，长度较短的数组小于长度较长的数组
    4. 使用append(short, short)逐个元素检查数组内容
    Parameters:
    
    left - 数组
    
    right - 数组
    
    Returns:
    
    this - object
  - append
```
public CompareToBuilder append(char[] left,
                               char[] right)
```
    附加到builder的深层比较,两个char数组.
    1. 使用==检查数组是否相同
    2. 检查是否为null， null小于非null
    3. 检查数组长度，长度较短的数组小于长度较长的数组
    4. 使用append(char, char)逐个元素检查数组内容
    Parameters:
    
    left - 数组
    
    right - 数组
    
    Returns:
    
    this - object
  - append
```
public CompareToBuilder append(byte[] left,
                               byte[] right)
```
    附加到builder的深层比较,两个byte数组.
    1. 使用==检查数组是否相同
    2. 检查是否为null， null小于非null
    3. 检查数组长度，长度较短的数组小于长度较长的数组
    4. 使用append(byte, byte)逐个元素检查数组内容
    Parameters:
    
    left - 数组
    
    right - 数组
    
    Returns:
    
    this - object
  - append
```
public CompareToBuilder append(double[] left,
                               double[] right)
```
    附加到builder的深层比较,两个double数组.
    1. 使用==检查数组是否相同
    2. 检查是否为null， null小于非null
    3. 检查数组长度，长度较短的数组小于长度较长的数组
    4. 使用append(double, double)逐个元素检查数组内容
    Parameters:
    
    left - 数组
    
    right - 数组
    
    Returns:
    
    this - object
  - append
```
public CompareToBuilder append(float[] left,
                               float[] right)
```
    附加到builder的深层比较,两个float数组.
    1. 使用==检查数组是否相同
    2. 检查是否为null， null小于非null
    3. 检查数组长度，长度较短的数组小于长度较长的数组
    4. 使用append(float, float)逐个元素检查数组内容
    Parameters:
    
    left - 数组
    
    right - 数组
    
    Returns:
    
    this - object
  - append
```
public CompareToBuilder append(boolean[] left,
                               boolean[] right)
```
    附加到builder的深层比较,两个boolean数组.
    1. 使用==检查数组是否相同
    2. 检查是否为null， null小于非null
    3. 检查数组长度，长度较短的数组小于长度较长的数组
    4. 使用append(boolean, boolean)逐个元素检查数组内容
    Parameters:
    
    left - 数组
    
    right - 数组
    
    Returns:
    
    this - object
  - toComparison
```
public int toComparison()
```
    返回一个负整数、一个正整数或零 builder判断左边小于、大于或等于右边。
    
    Returns:
    
    比较结果
    
    See Also:
    
    build()
  - build
```
public Integer build()
```
    返回一个负整数、一个正整数或零 builder判断左边小于、大于或等于右边。
    
    Specified by:
    
    build in interface Builder<Integer>
    
    Returns:
    
    最终的比较结果为整数
    
    Since:
    
    3.0
    
    See Also:
    
    toComparison()

Class CompareToBuilder

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

CompareToBuilder

Method Detail

reflectionCompare

reflectionCompare

reflectionCompare

reflectionCompare

reflectionCompare

appendSuper

append

append

append

append

append

append

append

append

append

append

append

append

append

append

append

append

append

append

append

append

toComparison

build