一个例子

 

public class TestString{
    public static void main(String[] args){
            String a = "a";
            String b = a+"b";
            String c = "ab";
            String d = "a" + "b";
            System.out.println(c == d);           //true!!!!
            System.out.println(c == d.intern());  //true
            System.out.println(b == c);           //false
            System.out.println(b.intern() == c);  //true!!!
            System.out.println(b == c.intern());  //false
            System.out.println(b == d);           //false
    }
 }

 

 

 

结果分析:

c==d是true,是因为d="a"+"b"是两个常量String的对象相加,返回的String对象就是常量String;

b==c是false,是因为b=a+“b”,java 重载了“+”,反编译java字节码可以发现“+”其实是调用了StringBuilder 所以使用了+”其实是生成了一个新的对象;

b.intern() == c 是true, 因为,如果常量池中存在当前字符串,就会直接返回当前字符串;如果常量池中没有此字符串,会将此字符串放入常量池中后,再返回

后续把上面的猜想挨着验证;

 

先编译:javac TestString.java;

在使用cfr-0.137.jar将java反编译:java -jar cfr-0.137.jar TestString.class --stringbuilder false ;
反编译结果如下:

 

/*
 * Decompiled with CFR 0.137.
 */
import java.io.PrintStream;

public class TestString {
    public static void main(String[] arrstring) {
        String string = "a";
        String string2 = new StringBuilder().append(string).append("b").toString();
        String string3 = "ab";
        String string4 = "ab";
        System.out.println(string3 == string4);
        System.out.println(string3 == string4.intern());
        System.out.println(string2 == string3);
        System.out.println(string2.intern() == string3);
        System.out.println(string2 == string3.intern());
        System.out.println(string2 == string4);
    }
}

 

可以看到,两个字符串相加,如果其中一个不是常量字符串(即不是通过变量名引用的字符串如"LuoTiany"),那么编译器编译后,JVM执行就会通过new StringBuilder对象操作,如果在一个循环中,就会产生多个StringBuilder对象,所以字符串相加,尽量使用StringBuilder对象的append(异步)或StringBuffer对象的append(同步);

 

使用javap -c TestString.class反编译结果如下(javap反编译参数):

Compiled from "TestString.java"
public class TestString {
  public TestString();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: ldc           #2                  // String a
       2: astore_1
       3: new           #3                  // class java/lang/StringBuilder
       6: dup
       7: invokespecial #4                  // Method java/lang/StringBuilder."<init>":()V
      10: aload_1
      11: invokevirtual #5                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      14: ldc           #6                  // String b
      16: invokevirtual #5                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      19: invokevirtual #7                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
      22: astore_2
      23: ldc           #8                  // String ab
      25: astore_3
      26: ldc           #8                  // String ab
      28: astore        4
      30: getstatic     #9                  // Field java/lang/System.out:Ljava/io/PrintStream;
      33: aload_3
      34: aload         4
      36: if_acmpne     43
      39: iconst_1
      40: goto          44
      43: iconst_0
      44: invokevirtual #10                 // Method java/io/PrintStream.println:(Z)V
      47: getstatic     #9                  // Field java/lang/System.out:Ljava/io/PrintStream;
      50: aload_3
      51: aload         4
      53: invokevirtual #11                 // Method java/lang/String.intern:()Ljava/lang/String;
      56: if_acmpne     63
      59: iconst_1
      60: goto          64
      63: iconst_0
      64: invokevirtual #10                 // Method java/io/PrintStream.println:(Z)V
      67: getstatic     #9                  // Field java/lang/System.out:Ljava/io/PrintStream;
      70: aload_2
      71: aload_3
      72: if_acmpne     79
      75: iconst_1
      76: goto          80
      79: iconst_0
      80: invokevirtual #10                 // Method java/io/PrintStream.println:(Z)V
      83: getstatic     #9                  // Field java/lang/System.out:Ljava/io/PrintStream;
      86: aload_2
      87: invokevirtual #11                 // Method java/lang/String.intern:()Ljava/lang/String;
      90: aload_3
      91: if_acmpne     98
      94: iconst_1
      95: goto          99
      98: iconst_0
      99: invokevirtual #10                 // Method java/io/PrintStream.println:(Z)V
     102: getstatic     #9                  // Field java/lang/System.out:Ljava/io/PrintStream;
     105: aload_2
     106: aload_3
     107: invokevirtual #11                 // Method java/lang/String.intern:()Ljava/lang/String;
     110: if_acmpne     117
     113: iconst_1
     114: goto          118
     117: iconst_0
     118: invokevirtual #10                 // Method java/io/PrintStream.println:(Z)V
     121: getstatic     #9                  // Field java/lang/System.out:Ljava/io/PrintStream;
     124: aload_2
     125: aload         4
     127: if_acmpne     134
     130: iconst_1
     131: goto          135
     134: iconst_0
     135: invokevirtual #10                 // Method java/io/PrintStream.println:(Z)V
     138: return
}

 上面如果看不懂,可以在这里找,javap编译后二进制指令代码详解:http://www.blogjava.net/DLevin/archive/2011/09/13/358497.html#Post

 

 

JVM内存中的常量池的位置

@Test
    public void constantPool(){
        List<String> list = new ArrayList<String>();
        int i=0;
        while(true){
            list.add(String.valueOf(i++).intern());
        }
    }

在执行的时候先设置VM启动参数:

在原来的VM options :-ea 后面追加-Xmx128m -Xms64m -Xmn32m -Xss16m -XX:-UseGCOverheadLimit;

这里的-XX:-UseGCOverheadLimit关闭GC占用时间过长时报的异常,-Xmx等参数见:https://www.cnblogs.com/theRhyme/p/9120705.html

执行上面的单元测试,等了数十秒:

说明在Java8中,字符串常量池在JVM的堆中。参考:https://blog.csdn.net/u014039577/article/details/50377805

 

为什么String被设计为不可变?

https://www.cnblogs.com/wuchanming/p/9201103.html

  • 安全首要原因是安全,不仅仅体现在你的应用中,而且在JDK中,Java的类装载机制通过传递的参数(通常是类名)加载类,这些类名在类路径下,想象一下,假设String是可变的,一些人通过自定义类装载机制分分钟黑掉应用。如果没有了安全,Java不会走到今天
  • 性能 string不可变的设计出于性能考虑,当然背后的原理是string pool,当然string pool不可能使string类不可变,不可变的string更好的提高性能
  • 线程安全当多线程访问时,不可变对象是线程安全的,不需要什么高深的逻辑解释,如果对象不可变,线程也不能改变它。