API--13--Objects类

2024-03-17 19:30:46

https://blog.csdn.net/ijwddd/article/details/80557759?

https://blog.csdn.net/hyEnA_Tiger/article/details/79525639?

https://blog.csdn.net/sinat_39525464/article/details/88975399?

https://blog.csdn.net/lkforce/article/details/56289349?

https://blog.csdn.net/qq_29769851/article/details/84543291

========================================================

Object 工具类

我们可以看到Objects类是Final的，即不可以被其他类继承，
并且它里面的方法都是static的。说明这是一个工具类
Objects的构造方法是private的，通常的private构造方法出现在单例模式中，但是后面的代码段中并没有出现与常规单例模式所对应的private static的Objects对象，因此，开发者这样写的目的就是不允许用户自己声明Object类，构造方法中唯一一行代码便是抛出异常也应证了这个想法。

API 方法

1.equals：两个对象的相等

public static boolean equals(Object a, Object b) {
    return (a == b) || (a != null && a.equals(b));
}

equals是一个static的方法，返回的值是两个函数是否相等的真值。满足真值需要两个条件之一：

1.两个变量引用了相同的对象
2.如果a非空，则通过其equals(b)方法返回判定值。
3.这里需要额外提一点，就是a中的equals可能被重写，可能会出现即便b是null，也还是返回true的情况。

2.deepEquals方法

deepEquals主要针对数组对象

Objects类源码

    public static boolean deepEquals(Object a, Object b) {
if (a == b)
    return true;
else if (a == null || b == null)
    return false;
else
    return Arrays.deepEquals0(a, b);
}

Arrays源码

static boolean deepEquals0(Object e1, Object e2) {
        assert e1 != null;
        boolean eq;
        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);
        else
            eq = e1.equals(e2);
        return eq;
    }

1）首先它比较两个对象是否是同一个对象；
2）如果不是，再判断它们是否是矩阵，对于矩阵的每个元素，它们是否是同一个对象
3）最后调用==Arrays.deepEquals0(a, b);==方法

3.hashCode与hash

这两个方法就是分别针对单个Object与多个Object对象来获取哈希码

public static int hashCode(Object o) {
    return o != null ? o.hashCode() : 0;
}

public static int hash(Object... values) {
    return Arrays.hashCode(values);
}

4.toString方法

java里面定义了两个toString方法：

public static String toString(Object o) {
    return String.valueOf(o);
}

public static String toString(Object o, String nullDefault) {
    return (o != null) ? o.toString() : nullDefault;
}

第二个重载方法是当对象为空时，返回一个默认的字符串nullDefault。否则遇到空字符串的时候直接返回 “null”。

5.compare 比较

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

调用对象c的比较方法，返回a与b的比较值。当然a与b指向一个对象时就默认相等。

6.isNull与nonNull

孪生兄弟，不解释。

public static boolean isNull(Object obj) {
        return obj == null;
    }

public static boolean nonNull(Object obj) {
        return obj != null;
    }

7. requireNonNull

检查输入的指针是否为null。

public static <T> T requireNonNull(T obj) {
    if (obj == null)
        throw new NullPointerException();
    return obj;
}
public static <T> T requireNonNull(T obj, String message) {
    if (obj == null)
        throw new NullPointerException(message);
    return obj;
}

1.如果对象为Null ，则抛出异常，否则返回这个对象本身

重载方法相当于之前toString中的重载方法，不同的是这次的默认字符串用于抛出异常。

案例;


import java.util.Objects;

public class test01 {

    public static void main(String[] args) {

        String str=null;
        
        System.out.println(Objects.requireNonNull(str,"参数为null!!!"));
    }

}

设计原理:Fail-fast

这里涉及到一个很重要的编程思想, 就是 Fail-fast思想, 翻译过来就是, 让错误尽可能早的出现,
不要等到我们很多工作执行到一半之后才抛出异常, 这样很可能使得一部分变量处于异常状态, 出现更多的错误. 这也是 requireNonNull 这个方法的设计思想, 让错误尽早出现. 使用这个方法, 我们明确的抛出异常, 发生错误时,我们立刻抛出异常.

应用:

检查指定的对象引用不是null并抛出一个自定义的NullPointerException（如果是）。该方法主要用于在具有多个参数的方法和构造函数中进行参数验证，如下所示：

 public Foo(Bar bar, Baz baz) {
     this.bar = Objects.requireNonNull(bar, "bar must not be null");
     this.baz = Objects.requireNonNull(baz, "baz must not be null");
 }
requireNonNull系列

requireNonNull系列

 public static <T> T requireNonNull(T obj, Supplier<String> messageSupplier) {
        if (obj == null)
            throw new NullPointerException(messageSupplier.get());
        return obj;
    }

码农公寓