Objects    14种方法

用于计算对象的哈希代码，返回对象的字符串，比较两个对象，以及检查索引或子范围值是否超出范围

范围检查 (返回int)

1.Objects.checkFromIndexSize(int fromIndex,int  size,int  length)

int a = Objects.checkFromIndexSize(4, 8, 12);

System.out.println(a);

结果为：4

int a = Objects.checkFromIndexSize(4, 8, 11);

System.out.println(a);

结果为：Range [4, 4 + 8) out of bounds for length 11

检查是否在子范围从 fromIndex （包括）到 fromIndex + size （不包括）是范围界限内 0 （包括）到 length （不包括）。

2.Objects.checkFromToIndex​(int fromIndex, int toIndex, int length)

检查是否在子范围从 fromIndex （包括）到 toIndex （不包括）是范围界限内 0 （包括）到 length （不包括）。

3.Objects.checkIndex​(int index, int length)

检查 index是否在 0 （含）到 length （不包括）范围内。

两个对象作比较

1.public static <T> int compare(T a, T b, Comparator<? super T> c)

此方法用于比较a，b两个对象如果a，b两个对象指向同一引用地址，返回0；否则调用c的compare方法进行比较，c的compare方法中传入的两个参数就分别是a，b。 源代码：

public static <T> int compare(T a, T b, Comparator<? super T> c) {
    return (a == b) ? 0 :  c.compare(a, b);
}

测试代码：

public class Demo1 implements Comparator<Demo1> {
    private String data;
    public Demo1() {
    }
    public Demo1(String data) {
        this.data = data;
    }
    public static void main(String[] args) {
        Demo1 test1 = new Demo1("测试代码Test1");
        Demo1 test2 = new Demo1("测试代码Test2");
        Demo1 test3 = new Demo1("测试代码Test1");
        int a = Objects.compare(test1, test1, new Demo1());
        System.out.println(a);
        int b = Objects.compare(test1, test3, new Demo1());
        System.out.println(b);
        int c = Objects.compare(test1, test2, new Demo1());
        System.out.println(c);
    }
    @Override
    public int compare(Demo1 o1, Demo1 o2) {
        if (o1.data == o2.data)
            return 1;
        return 2;
    }
}
输出：0  1  2

2.public static boolean deepEquals(Object a, Object b)

此方法用于比较a，b两个对象是否深度相等，为什么要叫深度相等？因为a，b两个对象都可以为数组。由于Java中Object类是一切类的基类，所以Object o = new Object[10]的代码是被允许的。所以传入的对象可以是一个数组。如果传入的对象是数组，要比较两个对象是否深度相等，就要比较两个数组对应下标的元素是否都相等。如果传入的对象有一个不是数组，就直接调用a对象的equals方法传入b对象比较两对象是否相等。 下面我们来看下源码：

public static boolean deepEquals(Object a, Object b) {
    //如果a和b指向同一地址，则a和b是同一对象，返回true。
    if (a == b)
        return true;
    //如果a或b中有一对象为空，则a和b不是同一类型对象，返回false。这样也避免了当a为空或者b为空时调用equals方法造成的空指针引用异常。
    else if (a == null || b == null)
        return false;
    //否则，调用Arrays类的deepEquals0方法对a，b进行深度比较。
    else
        return Arrays.deepEquals0(a, b);
}

我们跳到Arrays类的deepEquals0方法进行分析，虽然有很多的判断语句，但是逻辑基本相同，我们就分析其中几个：

static boolean deepEquals0(Object e1, Object e2) {
    //因为之后要调用e1的equals方法，所以e1不能为空。
    assert e1 != null;
    //定义返回值。
    boolean eq;
    //这个if是用于判断引用数据类型数组的，如果e1，e2都是引用数据类型数组的话，就调用Arrays类的deepEquals方法判断两数组是否相等。之后的基本数据类型的判断流程也一样。
    if (e1 instanceof Object[] && e2 instanceof Object[])
        eq = deepEquals ((Object[]) e1, (Object[]) e2);
    else if (e1 instanceof byte[] && e2 instanceof byte[])
        eq = equals((byte[]) e1, (byte[]) e2);
    else if (e1 instanceof short[] && e2 instanceof short[])
        eq = equals((short[]) e1, (short[]) e2);
    else if (e1 instanceof int[] && e2 instanceof int[])
        eq = equals((int[]) e1, (int[]) e2);
    else if (e1 instanceof long[] && e2 instanceof long[])
        eq = equals((long[]) e1, (long[]) e2);
    else if (e1 instanceof char[] && e2 instanceof char[])
        eq = equals((char[]) e1, (char[]) e2);
    else if (e1 instanceof float[] && e2 instanceof float[])
        eq = equals((float[]) e1, (float[]) e2);
    else if (e1 instanceof double[] && e2 instanceof double[])
        eq = equals((double[]) e1, (double[]) e2);
    else if (e1 instanceof boolean[] && e2 instanceof boolean[])
        eq = equals((boolean[]) e1, (boolean[]) e2);
    //如果e1和e2不全为数组，就调用e1的equals方法。
    else
        eq = e1.equals(e2);
    //返回判断的结果。
    return eq;
}

3.public static boolean equals(Object a, Object b) {

        return (a == b) || (a != null && a.equals(b));

    }

返回 true如果参数相等，彼此 false其他，相比于对象直接调用equals避免了空指针异常的现象

判断传入参数是否为空

1.public static boolean isNull(Object obj) {

        return obj == null;

    }

返回 true则是null ，否则返回 false   对象创建时有了引用地址就不为空，除非给它赋值NULL

2.public static boolean nonNull(Object obj) {

        return obj != null;

    }

返回 true则是非空， null返回 false 

3.public static <T> T requireNonNull(T obj) {

    if (obj == null)

        throw new NullPointerException();

    return obj;

}

检查指定的对象引用是否为 null ，是则抛出异常

4.public static <T> T requireNonNull(T obj, String message) {

        if (obj == null)

            throw new NullPointerException(message);

        return obj;

}

检查指定的对象引用是否为null ，如果是，则抛出自定义的NullPointerException

5.public static <T> T requireNonNull(T obj, Supplier<String> messageSupplier) {

        if (obj == null)

            throw new NullPointerException(messageSupplier == null ?

                                           null : messageSupplier.get());

        return obj;

}

检查指定的对象引用是否为null ，如果是，则抛出自定义的NullPointerException

6.public static <T> T requireNonNullElse(T obj, T defaultObj) {

    return (obj != null) ? obj : requireNonNull(defaultObj, "defaultObj");

}

如果它是非 null ，则返回第一个参数，否则返回非 null第二个参数

直接返回调用的结果toString

1.public static String toString(Object o) {

        return String.valueOf(o);

}

返回调用的结果 toString对于非 null参数输出哈系数（Person@2d363fb3）， "null"则直接输出null

public static String valueOf(Object obj) {

        return (obj == null) ? "null" : obj.toString();

}

2.public static String toString(Object o, String nullDefault) {

        return (o != null) ? o.toString() : nullDefault;

}

如果第一个参数不是 null ，则返回在第一个参数上调用 toString的结果，否则返回第二个参数