今天的主角是：String。说到String，在Java里，真的是无处不在，只要是你看到的文字，背后就有它工作的身影。

String也常出现在各大厂，各论坛的经典面试题中，熟练掌握它，已经成为一个高级技师的必备技能。



1. 从源码角度认识String.

看过很多文章，一上来就说String是不可变类，我不喜欢背书式的学东西，学习一个技术点最好的方法就是阅读源码。

我这边用的是JDK1.8，String类位于java.lang包中，先看看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>
* ......................
*/
有没有被这一大坨给吓到，没事，我来给你们精简下：

1. String表示字符串。
2. String是不可变的，String类的修饰符是final，这只能保证它不能被继承，主要还是因为它提供的函数除了构造器和静态工厂函数，剩下的写函数内部都会新创建一个String对象，对String做任何change性质的操作都会重新生成一个新的对象。
3. StringBuilder和StringBuffer可以实现可变的字符串，内部使用了char[]数组作为缓冲区。
4. 使用String类的时候，需要注意编码问题。
5. String提供了equals和hashCode函数（注意不是重写，String不继承于Object类），它的作用主要是当String对象调用equals()方法时，其比较的是两个字符串的内容是否相同，而不是指向字符串的地址。
String类实现了java.io.Serializable, Comparable<String>, CharSequence这三个接口，代表String是可序列化，可比较大小的。



2. 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;
    }
上面是String类中的compare代码，我们先来看一个例子:

String a = "abc";
String b = "abcd";
String c = "1";
// 输出 -1
System.out.println(a.compareTo(b));
// 输出 48
System.out.println(a.compareTo(c));
比较方式：

* 如果第一个字符和参数的第一个字符不等，结束比较，返回这个不相等位置字符的ASCII码差值，比如"abc"与"1"，'a'的ASCII码值为97，'1'的ASCII码值为49，所以返回 97 - 49 = 48。

* 如果第一个字符和参数的第一个字符相等，则以第二个字符和参数的第二个字符作比较，依此类推，直至比较的字符或被比较的字符有一方全比较完，这时就比较字符的长度。



3. 字符串常量池。

前面的JVM那篇博客中有讲过，Java中的常量池，分为两种形态：静态常量池和运行时常量池。
所谓静态常量池，即*.class文件中的常量池，class文件中的常量池不仅仅包含字符串(数字)字面量，还包含类、方法的信息，占用class文件绝大部分空间。
而运行时常量池，则是jvm虚拟机在完成类装载操作后，将class文件中的常量池载入到内存中，并保存在方法区中，我们常说的常量池，就是指方法区中的运行时常量池。
字符串的分配和其他对象分配一样，是需要消耗高昂的时间和空间的，而且字符串在我们的程序中使用的非常频繁。不过这个事情，JVM已经给我们考虑好了，在实例化字符串的时候进行了一些优化：每当我们创建字符串常量时，JVM会首先检查字符串常量池，如果该字符串已经存在常量池中，那么就直接返回常量池中的实例引用。如果字符串不存在常量池中，就会实例化该字符串并且将其放到常量池中，由于String字符串的不可变性我们可以十分肯定常量池中一定不存在两个相同的字符串。



4. 几个例子分析String内存模型。

(1) 例子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。当执行第2条语句时，JVM还是要检测这个字面量，JVM通过查找常量池，发现内容为"abc"字符串对象存在，于是将已经存在的字符串对象的引用返回给变量s2，这里不会重新创建新的字符串对象。

画个草图帮助大家理解下：





(2) 例子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'。
---------------------
【转，仅作分享，，侵删】
作者：况众文
原文：https://blog.csdn.net/u014294681/article/details/85169691
版权声明：本文为博主原创文章，转载请附上博文链接！

看一看。

今天也要加油鸭