Java常用库类及其示例——Objects

Objects类包含static实用程序方法，用于操作对象或在操作前检查某些条件。 这些实用程序包括null或null方法，用于计算对象的哈希代码，返回对象的字符串，比较两个对象，以及检查索引或子范围值是否超出范围。

checkFromIndexSize

详细信息

 public static
    int checkFromIndexSize(int fromIndex, int size, int length) {
        return Preconditions.checkFromIndexSize(fromIndex, size, length, null);
    }

参数
fromIndex：子范围（包括）的下限
size：子范围的大小
length：界限（不包括）的上限
功能
判断子范围【fromIndex（包括）->fromIndex+size（不包括）】是否在界限范围【0（包括）->length（不包括）】内
结果
返回 fromIndex 的值
异常 IndexOutOfBoundsException
产生条件：子范围越界
下列任一项为真，判定为子范围越界：
1、fromIndex < 0
2、size < 0
3、fromIndex + size > length ，考虑到整数溢出
4、length < 0 ，这是前者的不平等所暗示的

代码实现

 int fromIndex = 4;
        int size = 6;
        int length = 10;
        int a = Objects.checkFromIndexSize(fromIndex,size,length);
        System.out.println(a);

//结果：4

checkFromToIndex​

详细信息

public static
    int checkFromToIndex(int fromIndex, int toIndex, int length) {
        return Preconditions.checkFromToIndex(fromIndex, toIndex, length, null);
    }

参数
fromIndex：子范围（包括）的下限
toIndex：子范围（不包括）的上限
length：界限（不包括）的上限
功能
判断子范围【fromIndex（包括）->toIndex（不包括）】是否在界限范围【0（包括）->length（不包括）】内
结果
返回fromIndex的值
异常 IndexOutOfBoundsException
产生条件：子范围越界
下列任一项为真，判定为子范围越界：
1、fromIndex < 0
2、fromIndex > toIndex
3、toIndex > length
4、length < 0 ，这是前者的不平等所暗示的

代码实现

  int fromIndex = 2;
        int toIndex = 6;
        int length = 10;
        int a = Objects.checkFromToIndex(fromIndex,toIndex,length);
        System.out.println(a);

//结果：2

checkIndex

详细信息

 public static
    int checkIndex(int index, int length) {
        return Preconditions.checkIndex(index, length, null);
    }

参数
index：该数
length：界限（不包括）的上限
功能
判断 index 是否在界限范围【0（包括）->length（不包括）】内
结果
返回 index 的值
异常 IndexOutOfBoundsException
产生条件：子范围越界
下列任一项为真，判定为子范围越界：
1、index < 0
2、index >= length
3、length < 0 ，这是前者的不平等所暗示的

代码实现

	 int index = 6;
	 int length = 10;
	 int a = Objects.checkIndex(index,length);
	 System.out.println(a);

//结果：6

compare

详细信息

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

参数
T：参数类型
a：一个物体
b： 要与 a进行比较的对象
c：比较前两个参数的 Comparator
功能
如果参数相同则返回0，否则返回c.compare(a, b) 。 因此，如果两个参数都是null则返回0。
请注意，如果其中一个参数为null ， NullPointerException可能会或可能不会抛出null ，具体取决于既定的规则（如果有）， Comparator选择具有null值。

结果
如果参数相同返回 0，否则为 c.compare(a, b) 。

代码实现

	 int a = 10;
	 int b = 10;
 	 int compare = Objects.compare(a, b, new Comparator<Integer>() {
 		 public int compare(Integer a, Integer b) {
    		return 999;
 		}
 	 });
 	System.out.println(" compare = "+ compare);

//结果： compare = 0

        int a = 10;
        int b = 20;
        int compare = Objects.compare(a, b, new Comparator<Integer>() {
            public int compare(Integer a, Integer b) {
                return 999;
            }
        });
        System.out.println(" compare = "+ compare);
    
//结果：  compare = 999

deepEquals

详细信息

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

参数
a ：一个物体
b ：与 a进行比较的对象，用于深度相等
功能
如果参数非常相等，返回true，否则返回false。
两个null值非常相等；
如果两个参数都是数组，则使用Arrays.deepEquals中的算法来确定相等性；
否则，通过使用第一个参数的equals方法确定相等性。
结果
如果参数彼此非常相等返回true，否则为 false

代码实现

		String[][] a1 = {{"z","h","a","n","g"}, {"s","a","n"}};
        String[][] a2 = {{"z","h","a","n","g"}, {"s","a","n"}};
        System.out.println(Objects.deepEquals(a1,a2));


//结果：true

equals

详细信息

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

参数
a：一个对象
b：要与 a进行比较以获得相等性的对象
功能
如果参数相等则返回 true，否则返回false。 因此，如果这两个参数是null ， 返回true；
如果只有一个参数为null ， 返回false。
否则，通过使用第一个参数的equals方法确定相等性。
结果
如果参数彼此相等返回true，否则为 false

代码实现

        String[][] a1 = {{"z","h","a","n","g"}, {"s","a","n"}};
        String[][] a2 = {{"z","h","a","n","g"}, {"s","a","n"}};
        System.out.println(Objects.equals(a1,a2));
    
//结果：false

To be continued……