CompareBuilder (bus-all 5.6.2 API)

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

All Implemented Interfaces:: Builder<Integer>

public class CompareBuilder
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:: 5.6.2
Author:: Kimi Liu

Nested Class Summary
- Nested classes/interfaces inherited from interface org.aoju.bus.core.builder.Builder
  Builder.HashKey

Constructor Summary

Constructors
Constructor and Description

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

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

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`CompareBuilder`	`append(boolean[] left, boolean[] right)` 附加到builder的深层比较,两个boolean数组.
`CompareBuilder`	`append(boolean left, boolean right)` 附加到builder的深层比较,两个boolean值比较
`CompareBuilder`	`append(byte[] left, byte[] right)` 附加到builder的深层比较,两个byte数组.
`CompareBuilder`	`append(byte left, byte right)` 附加到builder的深层比较,两个byte值比较
`CompareBuilder`	`append(char[] left, char[] right)` 附加到builder的深层比较,两个char数组.
`CompareBuilder`	`append(char left, char right)` 附加到builder的深层比较,两个char值比较
`CompareBuilder`	`append(double[] left, double[] right)` 附加到builder的深层比较,两个double数组.
`CompareBuilder`	`append(double left, double right)` 附加到builder的深层比较,两个double值比较
`CompareBuilder`	`append(float[] left, float[] right)` 附加到builder的深层比较,两个float数组.
`CompareBuilder`	`append(float left, float right)` 附加到builder的深层比较,两个float值比较
`CompareBuilder`	`append(int[] left, int[] right)` 附加到builder的深层比较,两个int数组.
`CompareBuilder`	`append(int left, int right)` 附加到builder的深层比较,两个int值比较
`CompareBuilder`	`append(long[] left, long[] right)` 附加到builder的深层比较,两个long数组.
`CompareBuilder`	`append(long left, long right)` 附加到builder的深层比较,两个long值比较
`CompareBuilder`	`append(Object[] left, Object[] right)` 附加到builder的深层比较,两个Object数组使用==检查数组是否相同检查是否为null, null小于非null 检查数组长度,长度较短的数组小于长度较长的数组使用`append(Object, Object)`逐个元素检查数组内容
`CompareBuilder`	`append(Object[] left, Object[] right, Comparator<?> comparator)` 附加到builder的深层比较,两个Object数组使用==检查数组是否相同检查是否为null, null小于非null 检查数组长度,长度较短的数组小于长度较长的数组使用`append(Object, Object, Comparator)`逐个元素检查数组内容
`CompareBuilder`	`append(Object left, Object right)` 附加到builder的深层比较,两个Object数组使用==检查数组是否相同检查是否为null, null小于非null 检查数组长度,长度较短的数组小于长度较长的数组使用`append(Object, Object)`逐个元素检查数组内容
`CompareBuilder`	`append(Object left, Object right, Comparator<?> comparator)` 附加到builder的深层比较,两个Object数组使用==检查数组是否相同检查是否为null, null小于非null 检查数组长度,长度较短的数组小于长度较长的数组使用`append(Object, Object, Comparator)`逐个元素检查数组内容
`CompareBuilder`	`append(short[] left, short[] right)` 附加到builder的深层比较,两个short数组.
`CompareBuilder`	`append(short left, short right)` 附加到builder的深层比较,两个short值比较
`CompareBuilder`	`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)` 通过反射比较两个对象
`static int`	`reflectionCompare(Object left, Object right, boolean compareTransients, Class<?> reflectUpToClass, String... excludeFields)` 通过反射比较两个对象
`static int`	`reflectionCompare(Object left, Object right, Collection<String> excludeFields)` 通过反射比较两个对象
`static int`	`reflectionCompare(Object left, Object right, String... excludeFields)` 通过反射比较两个对象
`int`	`toComparison()` 返回一个负整数、一个正整数或零 builder判断左边小于、大于或等于右边

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

- Constructor Detail
  - CompareBuilder
```
public CompareBuilder()
```
    构造,构造后调用append方法增加比较项,然后调用toComparison()获取结果
- Method Detail
  - reflectionCompare
```
public static int reflectionCompare(Object left,
                                    Object right)
```
    通过反射比较两个Bean对象,对象字段可以为private 比较规则如下：
    - static字段不比较
    - Transient字段不参与比较
    - 父类字段参与比较
    如果被比较的两个对象都为null,被认为相同
    Parameters:
    
    left - 第一个对象
    
    right - 第二个对象
    
    Returns:
    
    当left小于、等于或大于right时，为负整数、零或正整数
  - reflectionCompare
```
public static int reflectionCompare(Object left,
                                    Object right,
                                    boolean compareTransients)
```
    通过反射比较两个对象
    
    Parameters:
    
    left - 左边的对象
    
    right - 右边的对象
    
    compareTransients - 是否比较属性
    
    Returns:
    
    当left小于、等于或大于right时，为负整数、零或正整数
  - reflectionCompare
```
public static int reflectionCompare(Object left,
                                    Object right,
                                    Collection<String> excludeFields)
```
    通过反射比较两个对象
    
    Parameters:
    
    left - 左边的对象
    
    right - 右边的对象
    
    excludeFields - 要排除的字符串字段的集合
    
    Returns:
    
    当left小于、等于或大于right时，为负整数、零或正整数
  - reflectionCompare
```
public static int reflectionCompare(Object left,
                                    Object right,
                                    String... excludeFields)
```
    通过反射比较两个对象
    
    Parameters:
    
    left - 左边的对象
    
    right - 右边的对象
    
    excludeFields - 要排除的字符串字段
    
    Returns:
    
    当left小于、等于或大于right时，为负整数、零或正整数
  - reflectionCompare
```
public static int reflectionCompare(Object left,
                                    Object right,
                                    boolean compareTransients,
                                    Class<?> reflectUpToClass,
                                    String... excludeFields)
```
    通过反射比较两个对象
    
    Parameters:
    
    left - 左边的对象
    
    right - 右边的对象
    
    compareTransients - 是否比较属性
    
    reflectUpToClass - 比较字段的最后一个超类
    
    excludeFields - 要排除的字符串字段
    
    Returns:
    
    当left小于、等于或大于right时，为负整数、零或正整数
  - appendSuper
```
public CompareBuilder appendSuper(int superCompareTo)
```
    附加到 builder compareTo(Object) 超类的结果
    
    Parameters:
    
    superCompareTo - 调用 super.compareTo(Object)结果
    
    Returns:
    
    this - object
  - append
```
public CompareBuilder 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 CompareBuilder 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 CompareBuilder append(long left,
                             long right)
```
    附加到builder的深层比较,两个long值比较
    
    Parameters:
    
    left - 数值
    
    right - 数值
    
    Returns:
    
    this - object
  - append
```
public CompareBuilder append(int left,
                             int right)
```
    附加到builder的深层比较,两个int值比较
    
    Parameters:
    
    left - 数值
    
    right - 数值
    
    Returns:
    
    this - object
  - append
```
public CompareBuilder append(short left,
                             short right)
```
    附加到builder的深层比较,两个short值比较
    
    Parameters:
    
    left - 数值
    
    right - 数值
    
    Returns:
    
    this - object
  - append
```
public CompareBuilder append(char left,
                             char right)
```
    附加到builder的深层比较,两个char值比较
    
    Parameters:
    
    left - 数值
    
    right - 数值
    
    Returns:
    
    this - object
  - append
```
public CompareBuilder append(byte left,
                             byte right)
```
    附加到builder的深层比较,两个byte值比较
    
    Parameters:
    
    left - 数值
    
    right - 数值
    
    Returns:
    
    this - object
  - append
```
public CompareBuilder append(double left,
                             double right)
```
    附加到builder的深层比较,两个double值比较
    
    Parameters:
    
    left - 数值
    
    right - 数值
    
    Returns:
    
    this - object
  - append
```
public CompareBuilder append(float left,
                             float right)
```
    附加到builder的深层比较,两个float值比较
    
    Parameters:
    
    left - 数值
    
    right - 数值
    
    Returns:
    
    this - object
  - append
```
public CompareBuilder append(boolean left,
                             boolean right)
```
    附加到builder的深层比较,两个boolean值比较
    
    Parameters:
    
    left - 数值
    
    right - 数值
    
    Returns:
    
    this - object
  - append
```
public CompareBuilder 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 CompareBuilder 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 CompareBuilder 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 CompareBuilder 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 CompareBuilder 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 CompareBuilder 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 CompareBuilder 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 CompareBuilder 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 CompareBuilder 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 CompareBuilder append(boolean[] left,
                             boolean[] right)
```
    附加到builder的深层比较,两个boolean数组.
    1. 使用==检查数组是否相同
    2. 检查是否为null, null小于非null
    3. 检查数组长度,长度较短的数组小于长度较长的数组
    4. 使用append(boolean, boolean)逐个元素检查数组内容
    Parameters:
    
    left - 数组
    
    right - 数组
    
    Returns:
    
    比较器
  - 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 CompareBuilder

Nested Class Summary

Nested classes/interfaces inherited from interface org.aoju.bus.core.builder.Builder

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

CompareBuilder

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