java中的==和equals详解

1. equals

equals比较的时候如果是引用类型（除了String类型），那么使用的是object中的equals方法，比较的是地址是否一样；
如果是String类型的对象，那么String类重写了Object中的equals方法，首先比较地址是否一样，一样的话返回true，不一样再比较是否是为同种类型，不是同类型就返回false，同类型之后再看内容是否一样；内容一样返回true，不一样返回false
如果是基本数据类型对应的包装部类，使用的equals也不是Object中的equals方法，而是重新了这个方法，首先比较的是否是同类型，不是同类型，直接返回false，是同类型再比较内容是否一致，一致返回true。

2. ==

==比较的是地址，引用类型（除了String类型）的时候，只要不是同一个对象那么不是一个地址，String类型的时候如果new出来两个对象，那么也是不同地址，如果不new，那么就是同一个地址，因为都是存放在字符串常量池中，如果是基本数据类型，都是放在常量池中，所以地址都是一样的。

例子如下：

package demo;

import jdk.nashorn.internal.ir.CallNode;

public class Test {
    public static void main(String[] args) {
        Student a1 = new Student("a1");
        Student a2 = new Student("a1");
        Teacher b1 = new Teacher("a1");
        String s1 = new String("a1");
        String s2 = new String("a1");
        String s6 = new String("1");
        String s3 = "ccc";
        String s4 = "ccc";
        String s5 = "a1";
        int i1 = 1;
        int i2 = 1;
        System.out.println(s1.equals("a1"));//true;因为s1是String类型的有自己的equals方法，先判断地址是否一样，不一一样再看参数是否为String，是的话比较的就是内容是否一样
        System.out.println(a1.equals("a1"));//false;因为a1是Student类型的使用Object类的equals方法，比较的是地址
        System.out.println(a1.equals(a2));//false;因为a1是Student类型的使用Object类的equals方法，比较的是地址，这里new了两个对象，显然地址不一样。
        System.out.println(a1.equals(b1));//false；因为a1是Student类型的使用Object类的equals方法，比较的是地址，这里new了两个对象，显然地址不一样。
        System.out.println(a2.equals(b1));//false;因为a2是Student类型的使用Object类的equals方法，比较的是地址，这里new了两个对象，显然地址不一样。
        System.out.println(s1.equals(a1));//false；因为s1是String类型的使用Object类的equals方法，首先判断a1是否是s1同一个对象，不是的话判断这个参数a1是否为String类型的，如果不是那么返回false，如果是，那么就比较他们之间的内容是否一样
        System.out.println(s1.equals(s1));//ture；因为s1是String类型的使用Object类的equals方法，首先判断s1是否是s1同一个对象；这里是同一个对象，所以返回true；
        System.out.println(s1.equals(b1));//false；因为s1是String类型的使用Object类的equals方法，首先判断b1是否是s1同一个对象；这里不是同一个对象，继续判断参数是否为String类型，这里不是，所以返回false
        System.out.println(s1.equals(s2));//true；因为s1是String类型的使用Object类的equals方法，首先判断s2是否是s1同一个对象；这里不是同一个对象，继续判断参数是否为String类型，这里是String类型，继续判断内容是否一样，内容一样所以是true；
        System.out.println(s1.equals(s5));//true；因为S1是String类型的使用Object类的equals方法，首先判断S5是否是跟s1为同一个对象，不是，继续判读参数是否为String类型，是，然后比较内容一样返回true。
        System.out.println(a1 == a1);//true;因为==比较的是地址，都是a1这个对象，只是值不同
        System.out.println(a1 == a2);//false；new两个对象，所以地址不同
        System.out.println(s1 == s2);//false；new两个对象，所以地址不同
        System.out.println(s3 == s4);//true;因为没有new对象，都是保存在字符串常量池中，所以地址都是一样的。
        System.out.println(i1 == i2);//true;因为是基本数据类型，保存在常量池中，所以地址都是一样的。
    }

}

包装类的==和equals

package test;

public class print1 {
    public static void main(String[] args) {
        System.out.println("================Byte=============");
        byte by=1;
        byte by2=1;
        Byte b=10;
        Byte b2=10;
        System.out.println((b==b2));//true
        System.out.println((b.equals(b2)));//true
        System.out.println(by==by2);


        System.out.println("================Short=============");
        Short s=10;
        Short s2=10;
        Short s3=133;
        Short s4=133;
        System.out.println((s==s2)+","+(s3==s4));//true,false
        System.out.println(s.equals(s2) + "," + s3.equals(s4));//true,true

        System.out.println("================Integer=============");
        Integer age = 10;
        Integer age2 = 10;
        Integer age3 = 133;
        Integer age4 = 133;
        System.out.println((age == age2) + "," + (age3 == age4));//true,false
        System.out.println(age.equals(age2) + "," + age3.equals(age4));//true,true

        System.out.println("================Long=============");
        Long l = 10L;
        Long l2 = 10L;
        Long l3 = 133L;
        Long l4 = 133L;
        System.out.println((l == l2) + "," + (l3 == l4));//true,false
        System.out.println(l.equals(l2) + "," + l3.equals(l4));//true,true

        System.out.println("================Float=============");
        Float f = 10f;
        Float f2 = 10f;
        Float f3 = 133f;
        Float f4 = 133f;
        System.out.println((f == f2) + "," + (f3 == f4));//false,false
        System.out.println(f.equals(f2) + "," + f3.equals(f4));//true,true

        System.out.println("================Double=============");
        Double num = 10d;
        Double num2 = 10d;
        Double num3 = 133d;
        Double num4 = 133d;
        System.out.println((num == num2) + "," + (num3 == num4));//false,false
        System.out.println(num.equals(num2) + "," + num3.equals(num4));//true,true

        System.out.println("=================Byte,Short,Integer,Long,相同值之间的对比=============");
        System.out.println(b.equals(age));//false;Byte的equals方法首先判断是否为Byte类型，如果不是就返回false，是的话再比较值相同的话就true
        System.out.println(age.equals(age4));//false；Byte的equals方法首先判断是否为Byte类型，不是所以返回的是false
        System.out.println(s4.equals(age4));//false
        System.out.println(age.equals(l));//false

        System.out.println("=================float和double");
        float fl=0.1f;
        double db=1.0/10;
        System.out.println(fl);//0.1
        System.out.println(db);//0.1
//        最好完全避免使用浮点数进行比较，因为会精度丢失，如果想要进行计算然后比较就可以使用BigDecimal 数据工具类进行比较。
        System.out.println(fl==db);//false
        float dl1=231212121212f;
        float dl2=dl1+1;
        System.out.println(dl1);//2.31212122E11
        System.out.println(dl2);//2.31212122E11
        System.out.println(dl1==dl2);//true
    }
}
/*
执行结果：
================Byte=============
true
true
true
================Short=============
true,false
true,true
================Integer=============
true,false
true,true
================Long=============
true,false
true,true
================Float=============
false,false
true,true
================Double=============
false,false
true,true
=================Byte,Short,Integer,Long,相同值之间的对比=============
false
false
false
false
=================float和double
0.1
0.1
false
2.31212122E11
2.31212122E11
true
 */

String类中的equal()方法源码

    public boolean equals(Object anObject) {
    //判断是否是同一个对象，如果是的话就返回true
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

Object类中的equals方法源码

   public boolean equals(Object obj) {
        return (this == obj);
    }

java基本数据类型对应的包装类的equals方法源码：

其他的包装类的equals和下面的差不多，都是先比较是否为同一个类型，然后再比较值。

Byte

   public boolean equals(Object obj) {
        if (obj instanceof Byte) {
            return value == ((Byte)obj).byteValue();
        }
        return false;
    }

Short

 public boolean equals(Object obj) {
        if (obj instanceof Short) {
            return value == ((Short)obj).shortValue();
        }
        return false;
    }