Objects源码解析。

/**
 * 该类由static用于对对象进行static实用方法组成。
 * 这些实用程序包括用于计算对象的哈希码的null -safe或null方法，
 * 为对象返回一个字符串，并比较两个对象。
 *
 * @since 1.7
 */
public class Objects {
    /**
     * 通过私有化构造器强化不可实例化的能力。
     */
    private Objects() {
        throw new AssertionError("No java.util.Objects instances for you!");
    }

    /**
     * 如果参数彼此相等，则返回true，否则返回false。
     * 因此，如果两个参数都为空，则返回true;如果恰好一个参数为空，则返回false。
     * 否则，相等通过使用第一个参数的equals方法来确定。
     *
     * @param a 一个对象
     * @param b 与 a进行比较的一个对象
     * @return  如果参数相等，则为真，否则为假
     */
    public static boolean equals(Object a, Object b) {
        return (a == b) || (a != null && a.equals(b));
    }

    /**
     * 如果参数彼此深度相等，则返回true，否则返回false。
     * 两个空值是完全相等的。如果两个参数都是数组，则使用Arrays.deepEquals中的算法来确定相等性。
     * 否则，相等通过使用第一个参数的equals方法来确定。
     *
     * @param a 一个对象
     * @param b 与 a进行比较的对象，用于深度相等
     * @return  如果两个参数相等，则为真，反之为假
     */
    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);
    }

    /**
     *  返回非空参数的哈希码，空参数返回0。
     * @param o 一个对象
     * @return  非空参数的哈希码，空参数的哈希码为0
     */
    public static int hashCode(Object o) {
        return o != null ? o.hashCode() : 0;
    }

    /**
     * 为输入值序列生成哈希码。
     * 散列代码的生成就好像所有的输入值都放在一个数组中，然后通过调用Arrays.hashCode(Object[])对该数组进行散列处理一样。
     *
     * 此方法对于在包含多个字段的对象上实现Object.hashCode()非常有用。
     * 例如，如果一个对象有三个字段x、y和z，可以这样写:
     * @Override
     * public int hashCode() {
     *  return Objects.hash(x, y, z);
     * }
     *
     * 警告：当提供单个对象引用时，返回的值不等于该对象引用的哈希码。 该值可以通过调用hashCode(Object)来计算。
     *
     * @param values    要散列的值
     * @return  输入值序列的哈希值
     */
    public static int hash(Object... values) {
        return Arrays.hashCode(values);
    }

    /**
     * 返回对非空参数调用toString的结果，对空参数调用“null”的结果。
     * @param o 一个对象
     * @return  调用非空参数的toString和空参数的“null”的结果
     */
    public static String toString(Object o) {
        return String.valueOf(o);
    }

    /**
     *  如果第一个参数不为空，则返回对第一个参数调用toString的结果，否则返回第二个参数。
     * @param o 一个对象
     * @param nullDefault   如果第一个参数为空，则返回
     * @return  如果第一个参数不是null，则调用toString，否则调用第二个参数。
     */
    public static String toString(Object o, String nullDefault) {
        return (o != null) ? o.toString() : nullDefault;
    }

    /**
     * 如果参数相同，则返回0，否则返回c.compare(a, b)。
     * 因此，如果两个参数都为null，则返回0。
     *
     * 注意，如果其中一个参数为null，则可能抛出NullPointerException，这取决于比较器为null值选择的排序策略(如果有的话)。
     * @param a 一个对象
     * @param b 要与 a进行比较的对象
     * @param c Comparator，比较前两个参数
     * @param <T>   正在比较的对象的类型
     * @return  如果参数相同，返回0，否则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 Foo(Bar bar) {
     *      this.bar = Objects.requireNonNull(bar);
     *  }
     * @param obj   检查无效的对象引用
     * @param <T>   引用的类型
     * @return  obj，如果不为空
     */
    public static <T> T requireNonNull(T obj) {
        if (obj == null)
            throw new NullPointerException();
        return obj;
    }

    /**
     * 检查指定的对象引用是否为空，如果为空则抛出一个自定义的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");
     *  }
     * @param obj   检查无效的对象引用
     * @param message   在抛出NullPointerException时使用的详细信息
     * @param <T>   引用的类型
     * @return
     */
    public static <T> T requireNonNull(T obj, String message) {
        if (obj == null)
            throw new NullPointerException(message);
        return obj;
    }

    /**
     * 如果提供的引用是非空的，则返回true，否则返回false。
     * @param obj   要针对空值检查的引用
     * @return  如果提供的引用是非空的，则为真，否则为假
     */
    public static boolean isNull(Object obj) {
        return obj == null;
    }

    /**
     * 检查指定的对象引用是否为空，如果为空则抛出一个自定义的NullPointerException。
     *
     * 与requireNonNull(Object, String)不同，此方法允许将消息创建延迟到执行空检查之后。
     * 虽然在非空情况下这可能会带来性能优势，但在决定调用此方法时，
     * 应注意创建消息提供者的成本低于直接创建字符串消息的成本。
     * @param obj   检查无效的对象引用
     * @param messageSupplier   在抛出NullPointerException时使用的详细信息的提供者
     * @param <T>   引用的类型
     * @return  obj，如果不为空
     */
    public static <T> T requireNonNull(T obj, Supplier<String> messageSupplier) {
        if (obj == null)
            throw new NullPointerException(messageSupplier.get());
        return obj;
    }
}