String StringBuffer StringBuider

谈谈String、StringBuffer、StringBuilder

• String ：不可变的(所以线程安全)，每次对String的操作都会生成新的String对象，不仅效率低下，而且浪费大量内存空间
• StringBuilder ：可变类，线程不安全，效率三者中最高
• StringBuffer：可变类，线程安全(为每个修改字符串的方法加synchronized锁保证线程安全)

怎么选择？
如果确定字符串不可变且数据量小: 适用 String
数据量很大且频繁变更，且是单线程操作： 适用 StringBuilder
数据量很大且频繁变更，且是多线程操作：适用 StringBuffer

String

核心特点

String 是 不可变类，所有属性都是 final 的。
由于它的不可变性，类似拼接、裁剪字符串等动作，都会产生新的 String 对象，同时也保证了多线程的安全

String底层数据结构：
Java 9 之前char[]
Java 9 之后为了节约内存空间，改用 byte[]存储字符串
StringBuffer和StringBuilder也同样做了修改来节约内存空间

String实现了Serializable接口：表示字符串是支持序列化的。

实现了Comparable接口：表示String可以比较大小

String为什么定义为不可变的？

保证线程安全

保证连接的安全性，防止黑客攻击
在网络连接和数据库连接中字符串常常作为参数，例如，网络连接地址URL，文件路径path
如果字符串是可变的，黑客就有可能改变字符串的值从而发起攻击。

加快字符串处理速度
由于String是不可变的，保证了hashcode的唯一性，于是在创建对象时其hashcode就可以放心的缓存了，不需要重新计算。

两种创建字符串对象的方式对比

String str1 = “abc”;
String str2 = “abc”;
String str3 = “abc”;
String str4 = new String(“abc”);
String str5 = new String(“abc”);
String str6 = new String(“abc”);
System.out.println(s1==s2);//true
System.out.println(s4==s5);//false

s1s2s3指向同一个”abc“，所以相同
s4s5s6指向不同的字符串对象。所以不相同。

原理：
如果是采用new关键字新建一个字符串对象时，JVM首先在字符串常量池中查找有没有"abc"这个字符串对象

• 如果有，则不在池中创建"abc"字符串，直接在堆中创建一个"abc"字符串对象，指向池中字符串即可
• 如果没有，则首先在字符串池中开辟空间创建一个"abc"字符串，然后再在堆中创建一个"abc"字符串对象，再指向池中字符串。

如果不用new，则没有堆这个中介而已，直接在字符串常量池中创建字符串之后把引用返回给栈中的str。

String s=null和String s=""的区别

1、类型
null表示的是一个对象的值，并不是字符串。
""表示的是一个长度为0的空字符串

2、内存分配

• String str = null ;
  表示声明一个字符串对象的引用，但指向为null，也就是说还没有指向任何的内存空间(此时还没有为其分配内存空间,不能.isEmpty())；

• String str = "";
  表示声明一个字符串类型的引用，其值为""空字符串，这个str引用指向的是空字符串的内存空间 (已分配内存空间，可以.isEmpty())

5.常用方法

int length()：返回字符串的长度： return value.length
char charAt(int index)： 返回某索引处的字符return value[index]
boolean isEmpty()：判断是否是空字符串：return value.length == 0
String toLowerCase()：使用默认语言环境，将 String 中的所有字符转换为小写
String toUpperCase()：使用默认语言环境，将 String 中的所有字符转换为大写
String trim()：返回字符串的副本，忽略前导空白和尾部空白
boolean equals(Object obj)：比较字符串的内容是否相同
boolean equalsIgnoreCase(String anotherString)：与equals方法类似，忽略大小写
String concat(String str)：将指定字符串连接到此字符串的结尾。 等价于用“+”
int compareTo(String anotherString)：比较两个字符串的大小
String substring(int beginIndex)：返回一个从beginIndex到最后的新的字符串
String substring(int beginIndex, int endIndex) ：返回一个新字符串，左闭右开

boolean endsWith(String suffix)：测试此字符串是否以指定的后缀结束
boolean startsWith(String prefix)：测试此字符串是否以指定的前缀开始
boolean startsWith(String prefix, int toffset)：测试此字符串从指定索引开始的子字符串是否以指定前缀开始

boolean contains(CharSequence s)：当且仅当此字符串包含指定的 char 值序列时，返回 true
int indexOf(String str)：返回指定子字符串在此字符串中第一次出现处的索引
int indexOf(String str, int fromIndex)：返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始
int lastIndexOf(String str)：返回指定子字符串在此字符串中最右边出现处的索引
int lastIndexOf(String str, int fromIndex)：返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索

注：indexOf和lastIndexOf方法如果未找到都是返回-1

替换：
String replace(char oldChar, char newChar)：返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有oldChar 得到的。
String replace(CharSequence oldStr, CharSequence newStr)：返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有oldChar 得到的。
String replaceAll(String regex, String replacement)：使用给定的 replacement 替换此字符串所匹配给定的正则表达式的子字符串。
String replaceFirst(String regex, String replacement)：使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。

//正则表达式
匹配:
boolean matches(String regex)：告知此字符串是否匹配给定的正则表达式。
切片：
String[] split(String regex)：根据给定正则表达式的匹配拆分此字符串。
String[] split(String regex, int limit)：根据匹配给定的正则表达式来拆分此字符串，最多不超过limit个，如果超过了，剩下的全部都放到最后一个元素中。
注意：.$|* 等转义字符，必须得加 \\，如split("\\.")
多个分隔符，可以用 | 作为连字符。

字符串构造原理

字符串拼接总的原则：

• 常量与常量的拼接结果在常量池
• 只要其中有一个是变量，结果就在堆中

以String s= s1 + s2这行代码为例，这行代码实际在jvm中会被拆解为以下几个步骤：

String s1="kk"
String s2="silu"
String s= s1 + s2
//String s= s1 + s2在jvm中会被拆解为以下几个步骤：
StringBuilder s = new StringBuilder(); 
s.append(s1);
s.append(s2);
s.toString();  
return s

可以看到，拼接操作的底层其实使用了StringBuilder，因为String s= s1 + s2中，+左右两边是变量，所以需要new StringBuilder进行拼接。

举例：

    public static void test1() {
        String s1 = "a" + "b" + "c";  // 得到 abc的常量池
        String s2 = "abc"; // 常量池已经有abc，直接将常量池中abc的地址返回
        System.out.println(s1 == s2); // true，因为都指向字符串常量池中的“abc”
        System.out.println(s1.equals(s2)); // true
    }

	public static void test2() {
        String s1 = "kk";
        String s2 = "silu";
        String s3 = "kksilu";
        String s4 = "kk" + "silu";    
     
        String s5 = s1 + "silu";
        String s6 = "kk" + s2;
        String s7 = s1 + s2;
   //如果连接符‘+’前后出现了变量，相当于在堆空间中new String() 得到的对象，
   
        System.out.println(s3 == s4); // true
        System.out.println(s3 == s5); // false
        System.out.println(s3 == s6); // false
        System.out.println(s3 == s7); // false
        System.out.println(s5 == s6); // false
        System.out.println(s5 == s7); // false
        System.out.println(s6 == s7); // false

        String s8 = s6.intern();//intern方法：判断字符串常量池中是否存在kksilu，若存在，则直接返回字符串常量池中的kksilu的引用，若不存在，则在字符串常量池中生成一份kksilu并返回其地址
        System.out.println(s3 == s8); // true
    }

String a = "abc";
String b = "a" + "b" + "c";  // 经过编译器优化成了String str = “abc”
(a == b) ? true  // 字符串常量池，字面量相同的引用也相同

String c = "abcd";
String d = a + "d";  // 经过编译器优化成了StringBuilder
(c == d) ? false

new String(“ab”)会创建几个对象

会创建两个对象

• new关键字在堆空间中创建一个new String(“ab”)对象
• 字符串常量池中会创建一个”ab“对象

new String(“a”) + new String(“b”) 会创建几个对象

创建6个对象

• 对象1：new StringBuilder()
• 对象2：堆空间中的new String(“a”)
• 对象3：常量池的 a
• 对象4：堆空间中的new String(“b”)
• 对象5：常量池的 b
• 对象6：调用toString(),在堆中会创建一个 new String(“ab”)

new String(“a”) + new String(“b”) 和new String(“ab”)的最大区别？
当字符串常量池之前没有"ab"时，前者不会在常量池中生成“ab”，但后者会生成

intern方法

intern方法确保字符串在内存里只会存在一个，不会重复，这样可以节约内存空间，加快字符串操作任务的执行速度。
具体做法：

• 当常量池中`存在某个字符串对象的引用时，则直接返回这个对象的引用，不重复创建新的字符串对象
• 当常量池中不存在某个字符串对象的引用，将这个字符串对象的引用加入常量池。