小白学java——Objects类的方法总结
作者：互联网
Objects 14种方法
用于计算对象的哈希代码，返回对象的字符串，比较两个对象，以及检查索引或子范围值是否超出范围
范围检查 (返回int)
1.Objects.checkFromIndexSize(int fromIndex,int size,int length)
int a = Objects.checkFromIndexSize(4, 8, 12);
System.out.println(a);
结果为：4
int a = Objects.checkFromIndexSize(4, 8, 11);
System.out.println(a);
结果为：Range [4, 4 + 8) out of bounds for length 11
检查是否在子范围从 fromIndex （包括）到 fromIndex + size （不包括）是范围界限内 0 （包括）到 length （不包括）。
2.Objects.checkFromToIndex(int fromIndex, int toIndex, int length)
检查是否在子范围从 fromIndex （包括）到 toIndex （不包括）是范围界限内 0 （包括）到 length （不包括）。
3.Objects.checkIndex(int index, int length)
检查 index是否在 0 （含）到 length （不包括）范围内。
两个对象作比较
1.public static <T> int compare(T a, T b, Comparator<? super T> c)
此方法用于比较a，b两个对象如果a，b两个对象指向同一引用地址，返回0；否则调用c的compare方法进行比较，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 class Demo1 implements Comparator<Demo1> {
private String data;
public Demo1() {
}
public Demo1(String data) {
this.data = data;
}
public static void main(String[] args) {
Demo1 test1 = new Demo1("测试代码Test1");
Demo1 test2 = new Demo1("测试代码Test2");
Demo1 test3 = new Demo1("测试代码Test1");
int a = Objects.compare(test1, test1, new Demo1());
System.out.println(a);
int b = Objects.compare(test1, test3, new Demo1());
System.out.println(b);
int c = Objects.compare(test1, test2, new Demo1());
System.out.println(c);
}
@Override
public int compare(Demo1 o1, Demo1 o2) {
if (o1.data == o2.data)
return 1;
return 2;
}
}
输出：0 1 2
2.public static boolean deepEquals(Object a, Object b)
此方法用于比较a，b两个对象是否深度相等，为什么要叫深度相等？因为a，b两个对象都可以为数组。由于Java中Object类是一切类的基类，所以Object o = new Object[10]的代码是被允许的。所以传入的对象可以是一个数组。如果传入的对象是数组，要比较两个对象是否深度相等，就要比较两个数组对应下标的元素是否都相等。如果传入的对象有一个不是数组，就直接调用a对象的equals方法传入b对象比较两对象是否相等。 下面我们来看下源码：
public static boolean deepEquals(Object a, Object b) {
//如果a和b指向同一地址，则a和b是同一对象，返回true。
if (a == b)
return true;
//如果a或b中有一对象为空，则a和b不是同一类型对象，返回false。这样也避免了当a为空或者b为空时调用equals方法造成的空指针引用异常。
else if (a == null || b == null)
return false;
//否则，调用Arrays类的deepEquals0方法对a，b进行深度比较。
else
return Arrays.deepEquals0(a, b);
}
我们跳到Arrays类的deepEquals0方法进行分析，虽然有很多的判断语句，但是逻辑基本相同，我们就分析其中几个：
static boolean deepEquals0(Object e1, Object e2) {
//因为之后要调用e1的equals方法，所以e1不能为空。
assert e1 != null;
//定义返回值。
boolean eq;
//这个if是用于判断引用数据类型数组的，如果e1，e2都是引用数据类型数组的话，就调用Arrays类的deepEquals方法判断两数组是否相等。之后的基本数据类型的判断流程也一样。
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);
//如果e1和e2不全为数组，就调用e1的equals方法。
else
eq = e1.equals(e2);
//返回判断的结果。
return eq;
}
3.public static boolean equals(Object a, Object b) {
return (a == b) || (a != null && a.equals(b));
}
返回 true如果参数相等，彼此 false其他，相比于对象直接调用equals避免了空指针异常的现象
判断传入参数是否为空
1.public static boolean isNull(Object obj) {
return obj == null;
}
返回 true则是null ，否则返回 false 对象创建时有了引用地址就不为空，除非给它赋值NULL
2.public static boolean nonNull(Object obj) {
return obj != null;
}
返回 true则是非空， null返回 false
3.public static <T> T requireNonNull(T obj) {
if (obj == null)
throw new NullPointerException();
return obj;
}
检查指定的对象引用是否为 null ，是则抛出异常
4.public static <T> T requireNonNull(T obj, String message) {
if (obj == null)
throw new NullPointerException(message);
return obj;
}
检查指定的对象引用是否为null ，如果是，则抛出自定义的NullPointerException
5.public static <T> T requireNonNull(T obj, Supplier<String> messageSupplier) {
if (obj == null)
throw new NullPointerException(messageSupplier == null ?
null : messageSupplier.get());
return obj;
}
检查指定的对象引用是否为null ，如果是，则抛出自定义的NullPointerException
6.public static <T> T requireNonNullElse(T obj, T defaultObj) {
return (obj != null) ? obj : requireNonNull(defaultObj, "defaultObj");
}
如果它是非 null ，则返回第一个参数，否则返回非 null第二个参数
直接返回调用的结果toString
1.public static String toString(Object o) {
return String.valueOf(o);
}
返回调用的结果 toString对于非 null参数输出哈系数（Person@2d363fb3）， "null"则直接输出null
public static String valueOf(Object obj) {
return (obj == null) ? "null" : obj.toString();
}
2.public static String toString(Object o, String nullDefault) {
return (o != null) ? o.toString() : nullDefault;
}
如果第一个参数不是 null ，则返回在第一个参数上调用 toString的结果，否则返回第二个参数
标签：java,int,Object,Objects,小白学,null,e1,public,e2 来源： https://www.cnblogs.com/se7en0420/p/15361561.html