Java中=,==，和equals()的用法

Java中=,==，和equals()的用法

首先是=的用法

“=”在表示的是赋值的意思
在基本类型的使用中，是将"=“后面的值赋值给”=“前面的元素

例如:

public class A {
    public static void main(String[] args) {
        int a,b;
        a=100;
        System.out.println(a);//100

        b=a;
        a=200;
        System.out.println(a);//200
        System.out.println(b);//100

    }
}

我们在基本类型的赋值过程中可以发现，在定义变量a的值之后，将将b=a，此时传过去的是值。所以对a重新赋值是不会影响参数b的。

而引用类型传递的是地址而不是值
例如：

public class C {
    public static void main(String[] args) {
        Map<String,Integer>map1=new HashMap<>();
        map1.put("A",100);
        System.out.println(map1);//A=100

        Map<String,Integer>map2=new HashMap<>();
        map2=map1;
        map1.put("A",200);
        System.out.println(map1);//A=200
        System.out.println(map2);//A=200
    }
}

在上面代码中我们发现，在打印出A的值，map2=map1之后再重新打印map1和map2的值。这时即使是先赋值后改变map1的值，map2的值也随之修改。就是因为此时修改的是地址，而map1和map2共用一个地址，才会造成map2的值发生改变。

但是在使用String类型时，也会出现和基本类型的情况，这是什么原因？

例如：

public class B {
    public static void main(String[] args) {
        String a,b;
        a="A";
        System.out.println(a);//A

        b=a;
        a="A1";
        System.out.println(a);//A1
        System.out.println(b);//A
    }
}

这时我们发现，String是引用类型，但是b并没有跟着a的值走，这是因为String是特殊的引用类型，在赋值上面和基本类型有相同的效果。

==的用法

==代表的是相等，在基本类型中比较的是值相等，在引用类型比较的是地址是否相等

在基本类型中

例如：

public class A {
    public static void main(String[] args) {
        int a=1;
        int b=2;
        System.out.println(a);//1
        System.out.println(b);//2
        System.out.println(a==b);//false
    }
}

此时a==b比较的是值相等

在引用类型中

例如：

public class B {
    public String name;
    public int id;

    public String getName() {
        return name;
    }

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public static void main(String[] args) {
        B b1=new B();
        b1.setName("小明");
        b1.setId(1);

        System.out.println(b1);//B@1b6d3586
        B b2=new B();
        System.out.println(b1);//B@1b6d3586
        System.out.println(b2);//B@4554617c
        System.out.println(b1==b2);//false

        B b3=new B();
        b3.setName("小明");
        b3.setId(1);
        System.out.println(b1==b3);//false
    }

}

在这个实例当中，打印对象实际上是打印地址， b1==b2实际上比较的是两者的地址，由于是新建了两个对象，开了两个堆也就是两个不同的地址，自然也就不会相等。

那么引用类型如何比较值相等呢？
我们采用equals（）方法

public class C {
    public String name;
    public int id;

    public String getName() {
        return name;
    }

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }


    public static void main(String[] args) {
        C c1=new C();
        c1.setName("小明");
        c1.setId(1);
        System.out.println(c1);//C@1b6d3586

        C c2=new C();
        c2=c1;
        System.out.println(c1.equals(c2));//false
    }
}

此时将c2的内容赋值给c1，而此时equals比较的是两者的值，自然也就相等了。

这也就引出了我们的equals方法
equals方法用于将字符串与指定的对象进行比较
String类中重写了equals（）方法，用于比较两个字符串是否相等

也就是说equals（）方法适用两个引用类型之间进行比较

例如：

public class D {
    public static void main(String[] args) {
        String a="a";
        String b=a;
        System.out.println(a.equals(b));//true
    }
}

此时两者的值是相等的

扩展：new Integer()和Integer.valueOf()的区别

new Integer()每次都会新建一个对象
Integer.valueOf()每次都会使用缓存池中的对象，多次调用时取的是同一个对象的引用

其中，第一个为false是因为开了两个对象，也就是开了两个堆，比较两个地址肯定不相等

第二个两者引用的都是同一个缓存池中对象的引用，所以比较两个的地址一定相等