java中的"=="和 "equal" 的区别?

1. "==" 的含义？

基本数据类型（也称原始数据类型） ：byte,short,char,int,long,float,double,boolean。他们之间的比较，应用双等号（==）,比较的是他们的值。

引用数据类型（类）：当他们用（==）进行比较的时候，比较的是他们在内存中的存放地址（确切的说，是堆内存地址）。

 

注：对于第二种类型，除非是同一个new出来的对象，他们的比较后的结果为true，否则比较后结果为false。因为每new一次，都会重新开辟堆内存空间。

2."equal" 的含义 ？

JAVA当中所有的类都是继承于Object这个超类的，在Object类中定义了一个equals的方法，这个方法的初始行为是比较对象的内存地址，但在一些类库当中这个方法被复写了，如String、Integer、Date。在这些类当中equals有其自身的实现，而不再是比较类在堆内存中的存放地址了。 

所以说，对于引用数据类型之间进行equals比较，在没有覆写equals方法的情况下，他们之间的比较还是内存中的存放位置的地址值，跟双等号（==）的结果相同；如果被复写，按照复写的要求来。

String类中被复写的equals()方法其实是比较两个字符串的内容。下面我们通过实际代码来看看String类的比较。

public class Main {
    public static void main(String[] args) {
        String str1 = "hello";
        String str2 = "hello";
        System.out.println(str1 == str2); //结果true
        System.out.println(str1.equals(str2)); //结果true
    }
}

public class Main {

    public static void main(String[] args) {
        String str1 = "Hello";
        String str2 = new String("Hello");
        String str3 = str2; // 引用传递
        String str4 = new String("Hello");
        System.out.println(str1 == str2); // 结果false
        System.out.println(str1 == str3); // 结果false
        System.out.println(str2 == str3); // 结果true
        System.out.println(str2 == str4); // 结果false
        System.out.println(str1.equals(str2)); // 结果true
        System.out.println(str1.equals(str3)); // 结果true
        System.out.println(str2.equals(str3)); // 结果true
        System.out.println(str2.equals(str4)); // 结果true
    }
}

3.对象比较

public class Student {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

重写equal方法之前（比较的是栈内存中的对象的引用地址，因为默认所有对象是继承Object类的equals方法，比较的是两个对象的引用地址，所以两个新new出来的对象equals是不相等的，返回false）

public class Main {
    public static void main(String[] args) {
        Student stu1 = new Student("zhangsan",18);
        Student stu2 = new Student("zhangsan",18);
        System.out.println(stu1 == stu2);//结果false
        System.out.println(stu1.equals(stu2));//结果false
    }
}

重写equal方法之后（因为你重写了equals方法，就会按照你自己的重写规则来比较两个对象是否相等，以下实例是说如果两个对象的名字和年龄相等，我就认为是同一个人，就返回true（虽然有点不太符合实际））

  

@Override
public boolean equals(Object obj) {
    if(this==obj){
        return true;
    }
    if(obj instanceof Student){
         Student b = (Student)obj;//强制转换
        // 判断两个对象的属性值是否相等
        if(!this.name.equals(b.name)){
            return false;
        }
        else if(this.age!=b.age){
            return false;
        }
        return true;
    }else{
        return false;
    }
}

public class Main {
    public static void main(String[] args) {
        Student stu1 = new Student("zhangsan",18);
        Student stu2 = new Student("zhangsan",18);
        System.out.println(stu1 == stu2);//结果false
        System.out.println(stu1.equals(stu2));//结果true
    }
}

总结： 
“==”比较的是值【变量(栈)内存中存放的对象的(堆)内存地址】 
equal应该用于比较两个对象的值是否相同【不是比地址】，而Object类中的equals方法就是比较的地址，所以才需要重写equals方法来比较对象的值是否相同。可以看看object类的equals方法比较的是地址：

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

【特别注意】Object类中的equals方法和“==”是一样的，没有区别，而String类，Integer类等等一些类，是重写了equals方法，才使得equals和“==不同”，所以，当自己创建类时，自动继承了Object的equals方法，要想实现不同的等于比较，必须重写equals方法。
 

"=="比"equal"运行速度快,因为"=="只是比较引用.