关于java中的==，equals()

时间：2024-06-27 18:35:44

1. 先从一道面试题说起

请问下面的

public class Demo {

    public static void main(String args[]){

        String a = "a" + "b" + 1;

        String b = "ab1";

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

    }

}

要了解这个问题，需要回答下面的几个问题：

  1. 关于“ ==”是做什么的？
  2. equals 呢？
  3. a和b在内存中是什么样的？
  4. 编译时优化方案。

2. 关于==

在Java语言中，“”就是对比两个内存单元的内容是否一样。

如果是原始类型byte，boolean，short，char，int，long，float，double，就是直接比较它们的值。

如果是引用，比较的就是引用的值，“引用的值”可以被认为对象的逻辑地址。如果两个引用发生“”操作，就是比较相应的两个对象的地址值是否一样。换句话说，如果两个引用所保存的对象是同一个对象，则返回true，否则返回false（如果引用指向的是null，其实这也是一个jvm赋予给它的某个指定的值）。

看下面的代码：

public class Demo {

    public static void main(String args[]){

        List<String> a = null;

        List<String> b = null;

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

    }

}

  // 输出结果

  true

3. 关于“equals()”方法

“equals()”方法，首先是在Object类中被定义的，它的定义中就是使用“==”方式来匹配的。

//equals在Object类中的源码

public boolean equals(Object obj) {

    return (this == obj);

}

也就是说，如果不去重写equals()方法，并且对应的类其父类中没有重写过equals()方法，那么默认的equals()操作就是对比对象的地址。

equals()方法之所以存在，是希望子类去重写这个方法，实现对比值的功能。

3. a和b在内存中是什么样的？

a和b在内存中是指向同一块内存空间的。这就得益于Java的编译时优化方案。

我们用反编译软件jd-gui看看编译后的代码是怎么样的？

import java.io.PrintStream;

public class Demo

{

  public static void main(String[] args)

  {

    String a = "ab1";

    String b = "ab1";

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

  }

}

看到这里结果应该就一目了然了。JVM会把常量叠加在编译时进行优化，因为常量叠加得到的是固定的值，无须运行时再进行计算，所以会这样优化。

看到这里别着急，JVM只会优化它可以帮你优化的部分，它并不是对所有的内容都可以优化。例如，就拿上面叠加字符串来说，如果几个字符串叠加出现了变量，即在编译时还不确定具体的值是多少，那么JVM是不会去做这样的编译时合并的。

如果上面的这段话你理解了，我们再来看一个例子：

public class Demo {

    public static void main(String args[]){

        String a = "a";

        final String c ="a";

        String b = a + "b";

        String d = c + "b";

        String e = getA() + "b";

        String compare = "ab";

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

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

        System.out.println( e == compare);

    }

    private static String getA(){

        return "a";

    }

}

//输出结果：

false

true

false

根据我们上面的解释，判断bcompare和ecompare输出结果为false，这个比较容易理解，因为a和getA()并不是一个常量，编译时并不会对此进行优化，我们用jd-gui可靠编译后的代码：

import java.io.PrintStream;

public class Demo

{

  public static void main(String[] args)

  {

    String a = "a";

    String c = "a";

    String b = a + "b";

    String d = "ab";

    String e = getA() + "b";

    String compare = "ab";

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

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

    System.out.println(e == compare);

  }

  private static String getA()

  {

    return "a";

  }

}

从编译后的代码，我们可以验证我们的结论，b和e并没有被JVM优化。

比较奇怪的是变量d，被JVM优化了。区别在于对叠加的变量c有一个final修饰符。从定义上强制约束了c是不允许被改变的，由于final不可变，所以编译器自然认为结果是不可变的。

4. 内存中的字符串（详细解释）

字符串对象内部是用字符数组存储的，那么看下面的例子：

String m = "hello,world";

String n = "hello,world";

String u = new String(m);

String v = new String("hello,world");

这些语句会发生什么事情？大概是这样的：

  1. 会分配一个11长度的char数组，并在常量池分配一个由这个char数组组成的字符串，然后由m去引用这个字符串。
  2. 用n去引用常量池里边的字符串，所以和m引用的是同一个对象
  3. 生成一个新的字符串，单内部的字符数组引用着m内部的字符数组。
  4. 同样会生成一个新的字符串，但内部的字符数组引用常量池里边的字符串内部的字符数组，意思是和u是同样的字符数组。

我们使用图来表示的话，情况就大概是这样的：

关于java中的==，equals()

结论就是，m和n是同一个对象，但m，u，v都是不同的对象，但都使用了同样的字符数组，并且用equal判断的话也会返回true。

我们可以使用反射修改字符数组来验证一下效果：

public class Demo {

    public static void main(String args[]) throws NoSuchFieldException, IllegalAccessException {

        String m = "hello,world";

        String n = "hello,world";

        String u = new String(m);

        String v = new String("hello,world");

        Field f = m.getClass().getDeclaredField("value");

        f.setAccessible(true);

        char[] cs = (char[]) f.get(m);

        cs[0] = 'H';

        String p = "Hello,world";

        System.out.println(m.equals(p));

        System.out.println(n.equals(p));

        System.out.println(u.equals(p));

        System.out.println(v.equals(p));

    }

}

//输出结果：

true

true

true

true

从上面的例子可以看到，经常说的字符串是不可变的，其实和其他final类没有什么区别，还是引用不可变的意思。虽然String类不开放value，但同样是可以通过反射进行修改。

5. 关于String中的intern方法

public class Demo {

    public static void main(String args[]){

        String a = "a";

        String b = a + "b";

        String c = "ab";

        String d = new String(b);

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

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

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

        System.out.println(b.intern() == d.intern());

    }

}

//输出结果

false

false

true

true

String引用所指向的对象，它们存储在常量池中，同一个值的字符串保证全局唯一。

如何保证全局唯一呢？ 当调用intern()方法时，JVM会在这个常量池中通过equals()方法查找是否存在等值的String，如果存在，则直接返回常量池中这个String对象的地址；若没有找到，则会创建等值的字符串，然后再返回这个新创建空间的地址。只要是同样的字符串，当调用intern()方法时，都会得到常量池中对应String的引用，所以两个字符串通过intern()操作后用等号是可以匹配的。

相关文章