欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

Java常用类-----java.util.Objects工具类详解

程序员文章站 2022-03-27 20:24:10
java.util.Objects工具类详解简介Objects 与 Object 区别构造函数常用方法equalsdeepEquals简介Objects 与 Object 区别Object 是 Java 中所有类的基类,位于java.lang包。Objects 是 Object 的工具类,位于java.util包。  java.util.Objects由 Java 7 引入的 ,包含static实用程序方法,用于操作对象或在操作前检查某些条件。  需要注意的是:这个类用关键字final修饰不...

简介

Objects 与 Object 区别

  1. Object 是 Java 中所有类的基类,位于java.lang包。
  2. Objects 是 Object 的工具类,位于java.util包。

  java.util.Objects由 Java 7 引入的 ,包含static实用程序方法,用于操作对象或在操作前检查某些条件。

  需要注意的是:这个类用关键字final修饰不能被继承,拥有私有的构造函数。
问题描述:

  用户希望使用静态工具方法实现非空验证、比较等操作。

适用场景:

  它在流处理中相当有用,实用程序包括null或null方法,用于计算对象的哈希代码,返回对象的字符串,比较两个对象,以及检查索引或子范围值是否超出范围。

构造函数

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

  可以看到Objects类中只有一个构造函数,并且声明为private,构造函数中抛出一个AssertionError。因此这个类不可以实例化

常用方法

equals

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

  这里Objects.equals方法中已经做了非空判断,所以不会抛出空指针异常,它是null-save空指针安全的。
  如果两个参数相等,返回true,否则返回false。 因此,如果这两个参数是null ,返回true,如果只有一个参数为null ,返回false, 否则,通过使用第一个参数的equals方法确定相等性。

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

  若两个都是null值的字符串或者数组比较,返回true。如果两个参数都是数组,则使用Arrays.deepEquals中的算法来确定相等性,在参数数组的循环中,递归调用deepEquals0,直到出现不相同的元素, 或者循环结束;否则,通过使用第一个参数的equals方法确定相等性。
  注:该方法在数组比较中尤其有用,当我们在业务中需要判断两个复杂类型,比如使用了泛型的列表对象List、或者通过反射得到的对象,不清楚对象的具体类型时可以直接使用此方法来解决。
测试:

public static void main(String[] args) {
        String[] arr1 = new String[]{"123"};
        String[] arr2 = new String[]{"124"};
        int[] arr3 = new int[]{1,2,3};
        int[] arr4 = new int[]{1,2,3};
        String s1 = "100";
        int s2 = 100;
        boolean b1 = Objects.deepEquals(arr1,arr2);
        boolean b2 = Objects.deepEquals(arr3,arr4);
        boolean b3 = Objects.deepEquals(s1,s2);
        System.out.println("字符串数组比较结果:"+b1);
        System.out.println("整型数组比较结果:"+b2);
        System.out.println("字符串和整型比较结果:"+b3);
    }

结果为:
Java常用类-----java.util.Objects工具类详解
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;
    }

  若参数是基本类型的数组,则根据该类型调用Arrays.equals方法。Arrays工具类依照八种基本类型对equals方法做了重载。

hashCode

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

  判断引用o所指对象是否为null,不为null,则返回o所指对象的hasCode方法执行结果,为null,返回0。

hash

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

  为一系列的输入值生成哈希码,该方法的参数是可变参数。它将所有的输入值都放到一个数组,然后调用Arrays.hashCode(Object[])方法来实现哈希码的生成。
  警告:当提供的参数是单个对象的引用时,返回值不等于该对象引用的散列码。这个值可以通过调用hashCode(Object)方法来计算。
public static int hashCode(Object a[ ])实现方法如下:

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

toString

toString(Object o)

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

  返回指定对象的字符串表示形式。如果参数为null,则返回字符串“null”。
  String.valueOf(Object obj)方法的内部实现:

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

  Object.toString()方法的内部实现:

public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

toString(Object o, String nullDefault)

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

  若第一个参数不是 null ,则返回在第一个参数上调用 toString的结果,否则返回第二个参数。

compare

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

  注意:若其中一个参数为null ,是否会抛出空指针异常NullPointerException取决于排序策略,如果有的话,则由Comparator来决定空值null。
代码实例:

        int num1 = 100;
        int num2 = 200;
        System.out.println(Objects.compare(num2, num1, new Comparator<Integer>() {

            @Override
            public int compare(Integer o1, Integer o2) {
                if (o1 - o2 > 0){
                    return 1;
                }else{
                    return -1;
                }
            }

        }));
        System.out.println(Objects.compare(new Object(), new Object(), new Comparator<Object>() {

            @Override
            public int compare(Object o1, Object o2) {
                return o1.hashCode() - o2.hashCode();
            }

        }));

requireNonNull

requireNonNull​(T obj)

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

  检查指定的对象引用是不是null 。若为null,则抛出空指针异常,否则返回对象本身。此方法主要用于在方法和构造函数中进行参数校验,如下所示:

 public Foo(Bar bar) {
     this.bar = Objects.requireNonNull(bar);
 }

  当我们通过带参的构造函数创建对象时,创建对象的同时就可以进行参数校验。

requireNonNull​(T obj, String message)

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

  该方法是requireNonNull的重载方法,当被校验的参数为null时,根据第二个参数message抛出自定义的NullPointerException 。
  注:此方法主要用于在具有多个参数的方法和构造函数中进行参数校验,如下所示:

public Foo(Bar bar, Baz baz) {
     this.bar = Objects.requireNonNull(bar, "bar must not be null");
     this.baz = Objects.requireNonNull(baz, "baz must not be null");
 }

isNull

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

  判空方法,如果参数为null则返回true,否则返回false。

nonNull

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

  判断非空方法,若参数是非空,返回true,否则返回false。

本文地址:https://blog.csdn.net/weixin_41758106/article/details/109264060