String

首选在认识String之前介绍一下JVM内存模型

元空间

1.元空间中存储的是常量，静态变量 和类原信息。java6和6之前,常量池是存放在方法区（永久 代）中的。Java7，将常量池是存放到了堆中。
Java8之后，取消了整个永久代区域，取而代之的是元空间。运行时常量池和静态常量池存放在元空间中，而字符串常量池依然存放在堆中。
所以在java8之后，字符串常量池存在堆当中。

运行时常量池

 1.方法区(元空间)一部分，存放编译器生成的各种字面量和符号引用，
 这部分内容将在类加载后进入方法区的运行常量池，一般来说，除了保存Class文件中描述的符号引用外，还会把翻译出来的直接引用也存储到运行时常量池中。
 运行时常量池具备动态性，也就是并非预置入Class才能进入方法区的运行时常量池。运行期间也可能将新的常量放入池中

字符串常量池

 本质上是一个HashSet<String>,这是一个纯运行的结构，而且是惰性维护，注意它指存储String对象的引用，而不存储String对象的内容。根据引用可以得到具体的对象

CLass常量池

主要存放两大类:字面量和符号引用。加载CLass文件时，
CLass文件中String对象会进入字符串常量池(这里的进入是指放入字符串的引用，字符串本身还是在堆中)，别的大都会进行运行时常量池

String源码分析

**
 * The {@code String} class represents character strings. All
 * string literals in Java programs, such as {@code "abc"}, are
 * implemented as instances of this class.
 * <p>
 * Strings are constant; their values cannot be changed after they
 * are created. String buffers support mutable strings.
 * Because String objects are immutable they can be shared. For example:
 * <blockquote><pre>
 *     String str = "abc";
 * </pre></blockquote><p>
 * is equivalent to:

分析String注释大致如下：
1.String表示字符串
2.String是不可变的，String类的修饰符是final,这里只能保证不能被继承主要还是因为它提供的 函数除了构造器和静态工厂函数，剩下的写函数内部都会新创建一个String对象，对String做任何change性质的操作都会重新生成一个新的对象。
3. 使用String类的时候，需要注意编码问题
4. String提供了equals和hashCode函数(注意不是重写,String不继承Object类)，的作用主要是当String对象调用equals()方法时，其比较的是两个字符串的内容是否相同，而不是指向字符串的地址。

String比较大小方法

public int compare(String s1, String s2) {
        int n1 = s1.length();
        int n2 = s2.length();
        int min = Math.min(n1, n2);
        for (int i = 0; i < min; i++) {
            char c1 = s1.charAt(i);
            char c2 = s2.charAt(i);
            if (c1 != c2) {
                c1 = Character.toUpperCase(c1);
                c2 = Character.toUpperCase(c2);
                if (c1 != c2) {
                    c1 = Character.toLowerCase(c1);
                    c2 = Character.toLowerCase(c2);
                    if (c1 != c2) {
                        // No overflow because of numeric promotion
                        return c1 - c2;
                    }
                }
            }
        }
        return n1 - n2;
    }

字符串常量池

JVAV中的常量池分为两种形态:静态常量池和运行常量池
所谓静态常量池，即*.class文件中的常量池不仅仅包含字符串(数字)字面量，还包含类，方法的信息，占用class文件绝大部分空间
运行时常量池，则是jvm虚拟机在完成类装载操作后，将class文件中的常量池载入到内存中，并保存在方法区中，我们常说的常量池，就是指方法区中的运行时常量池。

字符串的分配和其他对象分配是一样，是需要消耗高昂的时间和空间的，而且字符串在我们的程序中使用非常的频繁，不过JVM已经考虑好了，在实例字符串的时候会进行一些优化：每当我们创建字符串常量时,JVM首先会检查字符串常量池，如果该字符串已经存在在常量池中，那么就直接返回常量池中的实例引用,如果字符串不存在在字符串常量池中，就会实例化改字符串并且将其放到字符串常量池中。 由于String字符串中的不可变性我们可以十分肯定常量池中一定不存在两个相同的字符串

4.举例说明

举例说明1-常量池

String s1 = "abc";
String s2 = "abc";
// 输出 true
System.out.println("s1 == s2 : " + (s1 == s2));
// 输出 true
System.out.println("s1.equals(s2) : " + (s1.equals(s2)));

分析：执行第一条语句时，JVM检测"abc"这个字面量，JVM通过字符串常量池检查找不到内容为"abc"的字符串对象存在，那么就创建这个字符串对象，然后将创建好的对象放入到常量池中，并且将引用返回给变量s1，当执行第二条语句时，JVM还是要检测这个字面量，JVM通过查找常量池，发现内容"abc"字符串对象存在。于是将存在的字符串对象的引用返回给变量s2,这里不会重新创建新的字符串对象
如下图:
举例说明2-常量池 new String

String s1 = new String("abc");
String s2 = new String("abc");
// 输出 false
System.out.println("s1 == s2 : " + (s1 == s2));
// 输出 true
System.out.println("s1.equals(s2) : " + (s1.equals(s2)));

分析:第一s1创建了2个对象，一个在常量池中，一个在堆中，引用s1存放在栈中，第二s2尼，由于此时"abc"字符串对象已经存在于常量池中，所以s2只会在堆中创建1个对象，因为堆中的地址不同，所以s1==s2为false

(3) 例子3 - “abc"与"ab” + “c”。

String s1 = "ab" + "c";
String s2 = "abc";
// 输出 true
System.out.println("s1 = s2 : " + (s1 == s2));

分析：第一行s1会在常量池中创建1个对象，因为常量的值在编译器就被优化了，这边"ab"和"c"都是常量，所以s1的值在编译期就确定了，编译后的效果相当于 String s1 = “abc”。所以内存图和例子1是一样的。

(4) 例子4 - 拘留字符串。

String s1 = "ab";
String s2 = "bc";
String s3 = s1 + s2;
String s4 = "abcd";
// 输出false
System.out.println(s3 == s4);

分析：第一行s1，创建了1个对象，在常量池中，并把引用返回给变量s1。第二行s2，创建了一个对象，在常量池中，并把引用返回给变量s2。第三行s3，JVM首先会在堆中创建一个StringBuilder对象，同时用s1指向的拘留字符串对象完成初始化，然后调用append方法完成对s2所指向的拘留字符串的合并，接着调用StringBuilder的toString()方法在堆中创建一个String对象，最后将刚生成的String对象的堆地址存放在局部变量s3中。而第四行s4，创建了1个对象，在常量池中，并把引用返回给变量s4。所以s3 == s4 为false。所以一共创建了5个对象。

5. 聊聊String.intern()。

存在于.class文件中的常量池，在运行期被JVM装载，并且可以扩充。String的intern()方法就是扩充常量池的一个方法；当一个String实例str调用intern()方法时，Java查找常量池中是否有相同Unicode的字符串常量，如果有，则返回其的引用，如果没有，则在常量池中增加一个Unicode等于str的字符串并返回它的引用。

String s0 = "abcd";
String s1 = new String("abcd");
String s2 = new String("abcd");
// 输出 false
System.out.println(s0 == s1);
s1.intern();
s2 = s2.intern();
// 输出 false
System.out.println(s0 == s1);
// 输出 true
System.out.println(s0 == s1.intern());
// 输出 true
System.out.println(s0 == s2);

分析：第一行s0，在常量池中创建1个对象，并且将引用返回给s0。第二行，创建2个对象，一个在堆中，一个在常量池中。第三行，创建了1个对象，在堆中。s0 == s1为false不再赘述。再看看s1.intern()，虽然执行了intern()，拿到了常量池里"abcd"的引用，但是没有赋值给s1，所以s0 == s1还是为false。而s0 = s1.intern()，返回true，因为都是指向"abcd"在常量池中的引用。最后一行s0 == s2，为true，因为中间有句：s2 = s2.intern()，s2的引用已经直接指向了常量池中"abcd"的引用了。

6. StringBuffer与StringBuilder的原理。

JDK的实现中StringBuffer与StringBuilder都继承自AbstractStringBuilder，对于多线程的安全与非安全看到StringBuffer中方法前面的一堆synchronized就大概了解了。

这里大致讲讲AbstractStringBuilder的实现原理：我们知道使用StringBuffer等无非就是为了提高java中字符串连接的效率，因为直接使用+进行字符串连接的话，jvm会创建多个String对象，因此造成一定的开销。AbstractStringBuilder中采用一个char数组来保存需要append的字符串，char数组有一个初始大小，当append的字符串长度超过当前char数组容量时，则对char数组进行动态扩展，也即重新申请一段更大的内存空间，然后将当前char数组拷贝到新的位置，因为重新分配内存并拷贝的开销比较大，所以每次重新申请内存空间都是采用申请大于当前需要的内存空间的方式，这里是2倍。

7. 最后讲讲String使用的一些性能优化。

(1) 使用StringBuilder/StringBuffer(同步)。

(2) 使用intern()。

(3) subString()方法的内存泄漏，关于这一点，在JDK的1.7及以后就已经解决了！在1.7之前，subString()方法截取字符串只是移动了偏移量，截取之后的字符串实际上还是原来的大小。现在，当使用subString()方法截取字符串时会把截取后的字符串拷贝到新对象。

(4) String.split()方法使用简单，功能强大，支持正则表达式，但是，在性能敏感的系统中频繁的使用这个方法是不可取的，StringTokenizer类是JDK中提供的专门用来处理字符串分割的工具类。

(5) charAt(int index) 返回指定索引处的 char 值，时间复杂度0(1)哦。功能和indexOf()相反，效率却一样高。

(6) 字符串前后辍判断，startsWith(String prefix)与endsWith(String suffix)效率远低于charAt(index) == ‘s’。