Java学习笔记18

Objects是Java 7新增的一个工具类,它提供了一些工具方法来操作对象,这些工具方法大多是“空指针”安全的。


Objects实现的方法如下:



在源码中Objects工具类中equals(Object,Object)是如何定义的:


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

通过以上程序不难发现当两个对象a、b都为null时,返回的也是true,而且保证了只有在其中一个对象a 不为null的情


况下去比较对象a与对象b是否相等。通过以上方法可以避免NullPointerException的异常。


OK,我们看看以下程序:

class User {
	
    private String name;
    private int age;
    
    public User(String name,int age){
    	this.name=name;
    	this.age=age;
    }
    
    protected String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    
    @Override
    public String toString() {
    	return "name="+name+"\nage="+age;
    }


}
public class Main {
	private static User user1;
	private static User user2;
	public static void main(String[] args) {
		System.out.println(Objects.equals(user1, user2));
		System.out.println(user1.equals(user2));
	}

}

输出结果:

true
Exception in thread "main" java.lang.NullPointerException
at code2.Main.main(Main.java:37)


当user1和user2都为null时,执行Objects的equals(Object,Object)方法时得到true,当执行Object的equals(Object)时,


抛出NullPointerException异常。


接着我们来看看deepEquals(Object, Object)方法在源码中是如何定义的:


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

在上面程序中,可以看出,如果两个对象的是相等,相等返回true,反之,判断其中一个是否为null,如果其中一个


为null的话返回false,反之执行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;
    }

先看看assert这个关键字,在Java中,assert这个关键字表示的是断言。当断言开启时(执行java -ea AssertFoo,默认是


不开启的:java AssertFoo)以上assert的用法是,当assert后面的boolean表达式为true时,继续执行,如果为false,程


序抛出AssertionError,并且终止执行。assert除了以上用法之外还可以按下面格式使用:


assert<boolean表达式> : <错误信息表达式>;


那么它的功能是,当后面的boolean表达式为true时,继续执行,反之抛出java.lang.AssertionError,并且输出错误信


息。


以上使用assert确保了e1不为null,以免当执行到eq=e1.equsls(e2)时抛出异常,接着看到在if语句中使用到了


instanceof关键字来判断是否是同一个类的实例,如果是的话,分别执行对应if下的语句。


如果if(e1 instanceof Object[] && e2 instanceof Object[])为 true时,执行以下方法:


 public static boolean deepEquals(Object[] a1, Object[] a2) {
        if (a1 == a2)
            return true;
        if (a1 == null || a2==null)
            return false;
        int length = a1.length;
        if (a2.length != length)
            return false;

        for (int i = 0; i < length; i++) {
            Object e1 = a1[i];
            Object e2 = a2[i];

            if (e1 == e2)
                continue;
            if (e1 == null)
                return false;

            // Figure out whether the two elements are equal
            boolean eq = deepEquals0(e1, e2);

            if (!eq)
                return false;
        }
        return true;
    }

在程序中分别判断了两个Object数组的长度是否,相等,并通过for循环对每个对象先通过==来判断它们的地址是否


相等,否则执行deepEquals0(Object , Object)方法来判断每个对象在堆中的内容是否相等。


接着我们看看以上每个if语句后的方法:

 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 boolean equals(short[] a, short 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 boolean equals(int[] a, int[] 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 boolean equals(long[] a, long[] 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 boolean equals(char[] a, char[] 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 boolean equals(float[] a, float[] 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 (Float.floatToIntBits(a[i])!=Float.floatToIntBits(a2[i]))
                return false;

        return true;
    }

 public static boolean equals(double[] a, double[] 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 (Double.doubleToLongBits(a[i])!=Double.doubleToLongBits(a2[i]))
                return false;

        return true;
    }

public static boolean equals(boolean[] a, boolean[] 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;
    }

现在我们可以发现,以上的方法都有一个相同点,都是判断数组的长度,以及每个元素是否相同。也就是


deepEquals0方法是对数组做深层次的比较。


我们看以下程序:

public class Main {
	public static void main(String[] args) {
		int[] i_int1=new int[]{1,2,3,4};
		int[] i_int2=new int[]{1,2,3,4};
		System.out.println(Objects.deepEquals(i_int1, i_int2));
		int[] i_int3=new int[]{1,2,3,5};
		int[] i_int4=new int[]{1,2,3,4};
		System.out.println(Objects.deepEquals(i_int3, i_int4));
	}
}

通过前面对deepEquals0方法的介绍,可以很快的得出以上程序的结果。

输出结果为:

true
false






转载请注明出处:http://blog.csdn.net/hai_qing_xu_kong/article/details/43926545    情绪控_ 

©️2020 CSDN 皮肤主题: 猿与汪的秘密 设计师: 上身试试 返回首页
实付0元
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值