Java String总结

本文内容：

从源码了解String
- String的内部实现
- String.valueOf与Integer.toString的区别
+运算符的重载
- +运算符的使用
- 在循环中使用+运算符
Switch对String的支持（Java8）
字符串常量池
实战解析
String、StringBuffer、StringBuilder的区别

从源码中了解String

在java中String是一个不可变对象。不可变类有一个缺点，对于每个不同的值，都需要生成一个新的对象。但同时又由于不可变类其域不可变，保证了其线程安全。

String的内部实现

public final class String
    implements java.io.Serializable, Comparable, CharSequence {    
    /** The value is used for character storage. */
    private final char value[];

    /** Cache the hash code for the string */
    private int hash; // Default to 0
  //省略String类中的方法...
}

String对字符串的存储经由内部一个final修饰的char数组，String内部提供会造成字符串修改的方法，无一例外的返回一个新的String对象。

String.valueOf与Interger.toString的区别

 public static String valueOf(int i) {
        return Integer.toString(i);
    }

这两者没用任何区别，String.valueOf内部实现还是Integer.toString。其他基本类型同理。

+运算符的重载

+运算符的使用

String str1 = "a";
String str2 = str1 + "b";

以上代码在编译后

   L0
    LINENUMBER 5 L0
    LDC "a"   //创建一个内容为"a"的字符串对象，并将其引用存入常量池
    ASTORE 1 
   L1
    LINENUMBER 6 L1
    NEW java/lang/StringBuilder
    DUP
    ALOAD 1
    INVOKESTATIC java/lang/String.valueOf (Ljava/lang/Object;)Ljava/lang/String;
    INVOKESPECIAL java/lang/StringBuilder. (Ljava/lang/String;)V
    LDC "b"
    INVOKEVIRTUAL java/lang/StringBuilder.append (Ljava/lang/String;)Ljava/lang/StringBuilder;
    INVOKEVIRTUAL java/lang/StringBuilder.toString ()Ljava/lang/String;
    ASTORE 2

可以看出，当有字符串对象参与+运算，会new出一个StringBuilder对象，接着调用append方法来不断添加字符。在这个过程中只生成了一个对象。

在循环中使用+运算符

String a = "";
for(int i = 0;i < 10;i++) {
        a += i;
}

  L0
    LINENUMBER 5 L0
    LDC ""
    ASTORE 1
   L1
    LINENUMBER 6 L1
    ICONST_0
    ISTORE 2
   L2
    GOTO L3
   L4  //循环体内部的代码
    LINENUMBER 7 L4
   FRAME APPEND [java/lang/String I]
    NEW java/lang/StringBuilder
    DUP
    ALOAD 1
    INVOKESTATIC java/lang/String.valueOf (Ljava/lang/Object;)Ljava/lang/String;
    INVOKESPECIAL java/lang/StringBuilder. (Ljava/lang/String;)V
    ILOAD 2
    INVOKEVIRTUAL java/lang/StringBuilder.append (I)Ljava/lang/StringBuilder;
    INVOKEVIRTUAL java/lang/StringBuilder.toString ()Ljava/lang/String;
    ASTORE 1

重点看循环体内部的代码，可以看到每次进入循环后多会new一个StringBuilder对象，会造成过多的开销。这也是不推荐在循环中生成字符串使用+号的原因。

Switch对String的支持(java 8)

代码就直接从网上找的

public class switchDemoString {
     public static void main(String[] args) {
         String str = "world";
         switch (str) {
         case "hello": 
              System.out.println("hello");
              break;
         case "world":
             System.out.println("world");
             break;
         default: break;
       }
    }
}

对编译后的文件进行反编译

public static void main(String args[]) {
       String str = "world";
       String s;
       switch((s = str).hashCode()) {
          case 99162322:
               if(s.equals("hello"))
                   System.out.println("hello");
               break;
          case 113318802:
               if(s.equals("world"))
                   System.out.println("world");
               break;
          default: break;
       }
  }

可以看出swtich本质上还是对int进行支持，但为了避免哈希值碰撞的问题，还会通过equals方法进行一次安全检查

字符串常量池

主要使用方法：

直接使用字面量（双引号）声明出的String对象会存入常量池。

不是字面量声明的String对象，可以使用String提供的intern方法。该方法会从字符串常量池中检查是否含有相同内容的对象，有则返回，没有则将该字符串对象加入常量池并返回。

字符串常量池中存放的都是对象的引用，在java中对象都存放在堆内存中。

当代码中出现字面量形式创建字符串时，JVM首先会检查字符串常量池中是否含有相同内容的字符串对象，如果有则返回该对象的引用。如果没有则创建新的字符串对象，然后将该对象的引用放入常量池，并返回该对象引用。

接下来分析这样一段代码

String a = "java";
String b = "java";
System.out.println((a == b));

true

声明并赋值变量a时，JVM首先检查常量池中是否有内容为java的对象存在（此处假设没有），那么会创建一个内容为java的对象，并存入常量池，然后返回该对象的引用。接着声明并赋值变量b，JVM在字符串常量池中发现有内容为java的对象存在，于是返回该对象的引用。

注：在JDK7版本中对常量池做了修改，所以JDK6与JDK7的代码运行结果可能有所不同。

将字符串常量池从Perm区移到了Java Heap区

实战解析

题目1

以下代码创建了几个对象

String a = new String("a")

该代码创建了两个对象，第一个为存在字符串常量池中的字符串对象，第二个在Java Heap中的String对象

题目2

    String a = "hello2"; 
    final String b = "hello";
    String d = "hello";
    String c = b + 2; 
    String e = d + 2;
    System.out.println((a == c));
    System.out.println((a == e));

true
false

当final变量是基本数据类型时，且其变量值在编译期间能确切知道，就会被当做编译时常量(constant variable)。其访问会按照Java语言对常量表达式的规定而做常量折叠。而"hello" + 2，编译成new StringBuilder("hello").append("2")，生产一个新的对象。

题目3

  public static void main(String[] args)  {
        String a = "hello2"; 
        final String b = getHello();
        String c = b + 2; 
        System.out.println((a == c));
 
    }
     
    public static String getHello() {
        return "hello";
    }

false

由于在编译期间无法确切知道变量b的值，所以编译时没进行常量折叠，最终由于+运算符的重载生成新的String对象c。

题目4

    final String a  = "a";
    final String b = "b";
    String c = a + b;
    System.out.println((c=="ab"));

true

String、StringBuffer、StringBuilder的区别

最后通过一张表格总结一下String、StringBuffer、StringBuilder的区别。其实很简单，从线程安全、可变性的两个维度做区分即可。

	可变(mutable)	不可变(Imutable)
线程安全	StringBuffer	String
线程不安全	StringBuilder

String由于是不可变对象，自然是线程安全的。StringBuffer内部通过synchronized锁实现了线程安全。而StringBuilder是线程不安全的。

参考资料

《Java String源码浅析》

《学会阅读Java字节码》

《Java总结篇系列：Java String》

《java中的字符串常量池》

《深入解析Strin#intern》