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

发表于 | 分类于

描述

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

实现

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

构造函数

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

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

equals

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

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

1
2
3
4
//Object
public boolean equals(Object obj) {
       return (this == obj);
   }

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

deepEquals

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

1
2
3
4
5
6
7
8
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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
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

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

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

hash

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

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

Arrays.hashCode

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

1
2
3
4
5
6
7
8
9
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

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

String.valueOf

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

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

toString(Object o, String nullDefault)

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

带缺省值的toString函数。

compare

1
2
3
public static <T> int compare(T a, T b, Comparator<? super T> c) {
       return (a == b) ? 0 :  c.compare(a, b);
   }
1
2
//Comparator接口方法
int compare(T o1, T o2);

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

requireNonNull(T obj)

1
2
3
4
5
public static <T> T requireNonNull(T obj) {
       if (obj == null)
           throw new NullPointerException();
       return obj;
   }

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

requireNonNull(T obj, String message)

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

自定义了异常的信息。

requireNonNull(T obj, Supplier< String > messageSupplier)

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

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

isNull

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

比较简单的判空处理。

nonNull

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

非空判断。

小结

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