java double equels_深入理解Java的==和equals

关系操作符==

关系操作符== ，适用于所有的基本数据类型，同时也适用于对象。

== 用于基本数据类型，比较的是数据的值

Java中有8种基本数据类型，其中有4种整型(int ,short,long,byte)、2种浮点类型(float,double)、1种用于表示Unicode编码的字符单元的字符类型char和1种用于表示真值的boolean类型。

下面对基本数据类型进行相等性测试：

public class Test {

public static void main(String[] args) {

boolean b1 = true;

boolean b2 = true;

System.out.println("b1 == b2: "+(b1==b2));

char c1 = 'c';

char c2 = 'c';

System.out.println("c1 == c2: "+(c1==c2));

byte by1 = 1;

byte by2 =1;

System.out.println("by1 == by2: "+(by1==by2));

short sh1 = 2;

short sh2 =2;

System.out.println("sh1 == sh2: "+(sh1==sh2));

int n1 = 1;

int n2 =1;

System.out.println("n1 == n2: "+(n1==n2));

long l1 = 1L;

long l2 = 1L;

System.out.println("l1 == l2: "+(l1==l2));

float f1 =1F;

float f2 = 1F;

System.out.println("f1 == f2: "+(f1==f2));

double d1 = 3.14;

double d2 = 3.14;

System.out.println("d1 == d2: "+(d1==d2));

}

}

结果如下:

b1 == b2: true

c1 == c2: true

by1 == by2: true

sh1 == sh2: true

n1 == n2: true

l1 == l2: true

f1 == f2: true

d1 == d2: true

上面的测试都是对同一类型的值进行比较(如 by1与by2都是byte类型的整数)

如果，我们对不同类型的数字进行比较会得出什么结果？

public class Test {

public static void main(String[] args) {

int n= 100;

byte b = 100;

long l = 100L;

short s = 100;

System.out.println("n==b: "+ (n==b));

System.out.println("b==l: "+ (b==l));

System.out.println("l==s: "+(l==s));

float f1 = 3.14F;

float f2 =100F;

double d1 = 3.14;

double d2 = 100;

System.out.println("f1==d1: "+(f1==d1));

System.out.println("f2==n: "+(f2==n));

System.out.println("d2==n:"+(d2==n));

}

}

结果：

n==b: true

b==l: true

l==s: true

f1==d1: false

f2==n: true

d2==n:true

结论：

1、不同类型的整数之间可以进行相等性比较。

2、不同类型的小数之间不要使用==比较，因为精度不同。

3、 整数和小数可以进行相等性比较，整数会自动转成相应的浮点类型。

== 用于对象，比较的是对象的引用

先看个下面这个例子，创建两个字符串对象s1和s2，然后进行相等性比较。

public class Test {

public static void main(String[] args) {

String s1 = new String("abc");

String s2 = new String("abc");

System.out.println(s1 == s2);

}

}

结果： false

虽然s1和s2的值相等，但是s1和s2的引用却是不同时的，这是两个对象，因此返回false。

接下来看个奇怪的问题：

public class Test {

public static void main(String[] args) {

String s1 = "abc";

String s2 = "abc";

System.out.println(s1 == s2);

}

}

你猜出正确结果吗？

你可能会想，这不是生成了两个字符串吗，一定是不相等的。

输出结果是：

true

这是为什么？

原因是：在java中，字符串是不可修改的，是不可变的。修改字符串实际是将变量引用了新的字符串。不可变字符串有个优点：编译器可以让字符串共享。

上面的代码可以这么理解：当创建s1时，存储池放置了一个字符串，当创建s2时，发现创建的是同样的字符串，就不再放入字符串了，因为这样会重复，所以s2就直接引用了存储池中已经存在的字符串。

如果s1改变了，那么存储池就会再放入一个新字符串，这时候，s1，s2指向的字符串地址就不一样了。

==用于包装器对象

public class Test {

public static void main(String[] args) {

Integer a =1000;

Integer b=1000;

System.out.println(a==b);

Integer c =100;

Integer d=100;

System.out.println(c==d);

}

}

运行结果:

false

true

出现这种现象的原因是：自动装箱规范要求boolean、byte、char<=127,介于-128～127之间的short和int被包装到固定的对象中。

因此，在比较两个包装器对象时调用equals方法。

equals方法

equals方法适用于对象，而不能用于基本数据类型。

自定义类的实例对象equals操作

class Person{}

public class Test {

public static void main(String[] args) {

Person p1 = new Person();

Person p2 = new Person();

System.out.println(p1.equals(p2));

}

}

结果是：

false

Java中所有类都默认继承Object,而Object类中的equals方法会判断两个对象是否具有相同的引用。如果两个对象具有相同的引用，它们一定是相等的。因此，两个对象的equals操作默认是比较引用。

Object类中的equals源码如下所示：

public boolean equals(Object obj) {

return (this == obj);

}

字符串的equals操作

public class Test {

public static void main(String[] args) {

String s1 = "noshower";

String s2 = "noshower";

System.out.println(s1.equals(s2));

}

}

结果如下：

true

String的equals方法重写了，覆盖了Object类的equals方法。它的源码如下：

public boolean equals(Object anObject) {

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;

}

从源码中可以看出String类的equals方法，先是比较两个变量是否指向同一个引用，如果是，直接返回相等。如果不是，就要判断equals括号内的变量，是否是String的实例，如果不是直接返回不相等。如果是String的实例,就比较两个变量代表的字符串长度是否相等，如果不相等就返回不相等的结果。如果长度相等，就把字符串转成char数组，比较每个字符是否相等。如果都相等，就返回相等的结果。如果有一个字符不相等，就返回不相等的结果。

由此我们可以得出，String的equals方法对相同引用的变量和不同引用，但是值相等的变量，都返回true。

我们再来看一个有趣的问题：

public class Test {

public static void main(String[] args) {

String s = "noshower";

System.out.println(s+"2" == "noshower2");

System.out.println("noshower2".equals(s+"2"));

}

}

结果如下：

false

true

这是为什么呢？

如果两个字符串放置在同一个位置上，它们必然相等。但是，完全有可能将内容相同的多个字符串的拷贝放置在不同的位置上。所以s+"2" 与"noshower2"放置在不同的位置。

实际上，只有字符串常量是共享的，而+或substring等操作产生的结果并不是共享的。

因此，千万千万不要用==测试字符串的相等性

基本类型的包装类equals

这里只举例Integer包装类，因为其他包装类的实现逻辑都是一样的。都是先比较某个变量是不是这个包装类的实例，如果不是，返回false。否则，比较值是否相等。如果相等，就返回true。否则返回false。

public class Test {

public static void main(String[] args) {

Integer n1 =new Integer(47);

Integer n2 =new Integer(47);

System.out.println(n1==n2);

System.out.println(n1.equals(n2));

}

}

结果如下：

false

true

不是同一个引用，所以==返回false。值相等，所以equals返回true。

Integer类equals方法源码如下：

public boolean equals(Object obj) {

if (obj instanceof Integer) {

return value == ((Integer)obj).intValue();

}

return false;

}

正如我上面所说的，先比较是不是同一个类型，再比较值是否相等。

其他几个包装类就不一一讲述了。这里贴上，它们的equals源码。

Short

public boolean equals(Object obj) {

if (obj instanceof Short) {

return value == ((Short)obj).shortValue();

}

return false;

}

Long

public boolean equals(Object obj) {

if (obj instanceof Long) {

return value == ((Long)obj).longValue();

}

return false;

}

Byte

public boolean equals(Object obj) {

if (obj instanceof Byte) {

return value == ((Byte)obj).byteValue();

}

return false;

}

Float

public boolean equals(Object obj) {

return (obj instanceof Float)

&& (floatToIntBits(((Float)obj).value) == floatToIntBits(value));

}

Double

public boolean equals(Object obj) {

return (obj instanceof Double)

&& (doubleToLongBits(((Double)obj).value) ==

doubleToLongBits(value));

}

Character

public boolean equals(Object obj) {

if (obj instanceof Character) {

return value == ((Character)obj).charValue();

}

return false;

}

Boolean

public boolean equals(Object obj) {

if (obj instanceof Boolean) {

return value == ((Boolean)obj).booleanValue();

}

return false;

}

完毕！！