Java源码阅读------Objects

描述

这个类用于处理对象实例，包含一系列的静态方法，是Object的工具类，位于java.util包中。

实现

实现很简单，相关的方法都比较常用。

构造函数

这个构造函数应该是不能用的，因为类中全是静态方法，所以创建实例是没有用的。

	private Objects() {
        throw new AssertionError("No java.util.Objects instances for you!");
    }

equals

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

这里有equals方法，Object中也有equals方法，我们比较一下。

	//Object
	public boolean equals(Object obj) {
        return (this == obj);
    }

Object中的方法是比较另一个类与自身是否相等，Objects中的是Object之间的比较，Object中的可能会有Object自身空指针的异常，但是使用Objects就不会发生这种问题。

deepEquals

深度相等，这个往往是在我们无法确定比较对象的类型时使用，比如对数组或者List等。

	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);
    }

这里如果两个Object同为null也返回True，如果真是list的话就调用Arrays.deepEquals0来比较。

Arrays.deepEquals0

来简单的看看Arrays.deepEquals0

	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;
    }

对应的equals有多个函数，分别实现对不同类型数组的详细比较。

hashCode

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

获取相应Object的hashCode，加了非空判断。

hash

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

这里的’…‘表示数据的变长处理，实际上传入的就是一个Object[]数组。也就是对一个数组进行hashCode处理。

Arrays.hashCode

在简单的看看Arrays.hashCode的处理。

	public static int hashCode(Object a[]) {
        if (a == null)
            return 0;
        int result = 1;
        for (Object element : a)
            result = 31 * result + (element == null ? 0 : element.hashCode());

        return result;
    }

循环处理数组中元素的hashCode。

toString

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

String.valueOf

	public static String valueOf(Object obj) {
        return (obj == null) ? "null" : obj.toString();
    }

先判空在调用的Object的toString方法。

toString(Object o, String nullDefault)

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

带缺省值的toString函数。

compare

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

//Comparator接口方法
int compare(T o1, T o2);

比较函数，可以自定义Comparator接口中的compare方法实现。

requireNonNull(T obj)

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

非空处理，在获取实例前先进行非空检查。

requireNonNull(T obj, String message)

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

自定义了异常的信息。

requireNonNull(T obj, Supplier< String > messageSupplier)

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

public interface Supplier<T> {
    T get();
}

这里的messageSupplier是优化的方式，在异常之前是不需要建立信息对象的，在出现异常后再进行创建，使用Supplier接口而不是使用字符常量。

isNull

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

比较简单的判空处理。

nonNull

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

非空判断。

小结

这个类定义了许多的常用方法，可以帮助我们简化平时的相关工作，类的实现很简单也很实用，我们可以利用这些函数而不用自己写。