二.JAVA基础 String

基础

String类声明为final，不可被继承（成员方法隐式指定为final），内部使用final修饰的char类数组value[]存储数据，其他成员变量都是final修饰。初始化后不能再引用其它数组，且值无法改变。

不可变的好处：

1.缓存hash值：String用作HashMap的key，不可变特性使得hash值也不可变，因此只需要计算一次。
2.String Pool：如果一个String对象已经创建，就会从String Pool中取得引用。
3.安全：String作为不可变参数。
4.线程安全：不可变性可以在多个线程中安全使用。

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence{

    /** The value is used for character storage. */
    private final char value[];

    /** The offset is the first index of the storage that is used. */
    private final int offset;

    /** The count is the number of characters in the String. */
    private final int count;

    /** Cache the hash code for the string */
    private int hash; // Default to 0
    }

内部方法如substring、concat、replace，都是重新生成一个新的字符串对象进行操作，原始字符串没有改变。

字符串常量池

减少内存开销和创建相同字符串的时间，但是需要时间遍历池中对象。
静态常量池：*.class文件中，包含字符串字面量，类、方法的信息。
运行时常量池：jvm完成类装载后，将class文件中的常量池载入到内存中，并保存在方法区中。我们常说的常量池指方法区中的运行时常量池。

两种创建方式

1.使用”“创建字符串，String a = “a”，编译期就已经确定存储到字符串常量池中，但不一定创建对象。步骤为：首先检查该字符串是否在常量池中，如果在，返回常量池中这个实例的引用，如果不在，实例化该字符串并放入常量池。在栈中创建s指向该常量池的实例的地址。所以，常量池中不存在两个相同的字符串。
2.使用s = new String(“”)，运行期创建。步骤为：首先查看池中是否有相同值的字符串，如果有，拷贝一份到堆中，返回堆中的地址给栈中的引用s（虽然内容创建在堆中，但内部的value指向JVM常量池中的value），多次new出的对象地址不一样；如果没有，在常量池中创建该字符串（编译期），再在堆中创建一份（运行期），返回堆中的地址给s。

细节

1.字符串常量进行连接”a”+”b”，在编译期就能确定，会在常量池直接创建”ab”字符串常量。
2.包含变量(s1)的字符串连接”a”+s1，运行期才创建对象，存在堆中。
3.对String a = “a”不一定创建对象，而有可能是指向一个已经创建的对象，new才能保证一定创建新对象。
4.==，作用于基本数据类型比较值是否相等，作用于引用类型如String，比较所指向对象的地址（是不是一个对象）。
5.equals，不能作用于基本数据类型。不重写的情况下比较引用类型的变量指向的对象地址；String、Double、Date重写equals，比较指向的对象的内容是否相等。
6.”a”+”b”，+连接的是字符串常量，编译后得到的是”ab”字符串常量，对引用字符串变量，以最左边的字符串为参数创建StringBuilder对象，依次对右边进行append操作，最后toString转换成String对象。
eg：String s = “x” + “y” + z + “a” + “b” + c;实质上是String s = new StringBuilder(“xy”).append(z).append(“a”).append(“b”).append(c).toString();
当使用+连接多个字符串时，产生了一个StringBuilder对象，一个String对象，效率低下。
而如果String s = “x” + “y”，相当于String s = “xy”，只创建了一个对象。
7.String、StringBuilder、StringBuffer
（1）后两个是可变字符串对象。
（2）String由于对象不可变，线程安全。后两个方法和功能是一样的，区别StringBuffer的方法大都采用synchronized修饰，所以是线程安全的，而StringBuilder没有此修饰，不是线程安全的。
（3）当字符串想加或改动少时，String str = “a”效率高；较多时，使用StringBuilder，多线程采用StringBuffer。
8.关于new创建了几个对象：在类加载过程中，在运行时常量池中创建了”“对象，而执行过程中只创建了一个String对象。所以涉及到了两个对象，而执行过程只有一个。

        String s1 = "abc";     
        //在字符串池创建了一个对象  
        String s2 = new String("abc");  
        //创建了两个对象，一个存放在字符串池中，一个存在与堆区中
        String s3 = new String("abc");  
        //字符串池中已经存在“abc”对象，所以只在堆中创建了一个对象

        System.out.println(s2==s3);  
        //false   s2和s3栈区的地址不同，指向堆区的不同地址；  
        System.out.println(s2.equals(s3));  
        //true  s2和s3的值相同  
        System.out.println(s1==s3));  
        //false 存放的地区多不同，一个栈区，一个堆区  
        System.out.println(s1.equals(s3));  
        //true  值相同  

        final String str4 = "b";  
        String str5 = "a" + str4;  
        String str6 = "ab";  
        System.out.println(str5 == str6);  
        //true str4为常量变量，编译期会被优化 

String.inter()

保证相同内容的字符串变量引用相同的内存对象

String s1 = new String("aaa");
String s2 = new String("aaa");
System.out.println(s1 == s2);           // false
String s3 = s1.intern();
System.out.println(s1.intern() == s3);  // true

s3通过intern取得一个对象引用，首先把s1引用的对象放到字符串常量池中，然后返回这个对象的引用。
参考关于intern的详解