Objects

 

/**
@since 1.7
 */
public final class Objects {
......
}

1.7出现的工具类，final修饰类不可继承，这个类断子绝孙了。

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

 构造器私有，该类不能创建对象。

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

 这个方法相当于 == （对象地址对比）和 equals() ，因为这里有一行代码为a != null，可以有效的防止后面空指针。

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.deepEquals0(a, b)这一段。

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

类型判断后进行转换，如果两个对象不是同一类型，肯定不相同。找个简单的看一眼

public static boolean equals(byte[] a, byte[] a2) {
        if (a==a2)
            return true;
        if (a==null || a2==null)
            return false;

        int length = a.length;
        if (a2.length != length)
            return false;

        for (int i=0; i<length; i++)
            if (a[i] != a2[i])
                return false;

        return true;
    }

判断地址是否相同，在判断是否为空，对比那个数组长度，最后在一个个元素对比。

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

 获取hashCode

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

 获取一组数据hashcode,一组的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;
    }

 对象变字符串

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

  如果传入的对象为空的话，返回你传入nullDefault参数

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

 如果对象相同，字典比较就是0，否则就按照你写的字典进行比较

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

  判断穿入对象是否为null

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

判断穿入对象是否为null，如果是的话抛出特定异常

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

判断对象是否为空，返回的是boolean值

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

  判断对象不等于null

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

 要求穿入的对象不能为空

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

@FunctionalInterface
public interface Supplier<T> {

    /**
     * Gets a result.
     *
     * @return a result
     */
    T get();
}

 这是个啥玩意呢？@FunctionalInterface标记在接口上，“函数式接口”是指仅仅只包含一个抽象方法的接口