String、StringBuffer、StringBuilder的特性851376263

1.String

String类:字符串是常量，使用一对""引起来表示。他们的值在创建之后不能修改。
1.String声明为final的，不可被继承(保证所有JDK的程序员，用的都是一个相同的String类)。
2.String实现了Serializable接口，表示字符串时支持序列化的。
        实现了Comparable接口：表示String可以比较大小
3.String内部定义了final char[] value(字符数组)用于存储字符串数据
4.String:代表不可变的字符序列。简称：不可变性
体现：1.当对字符串重新赋值时，需要重写指定内存区域赋值，不能使用原有的value进行赋值
           2.当对现有的字符串进行连接( + )操作时，也需要重写指定内存区域赋值，不能使用原有的  value进行赋值
           3.当调用String的replace()方法修改指定字符或字符串时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值
5.通过字面量的方式(区别于new)给一个字符串赋值，此时的字符串值声明在字符串常量池中。
6.字符串常量池是不会存储相同内容的字符串的。

理解字符串的不可变性：

String str1 = "Hello";
String str2 = str1;
str1 = "world";
System.out.println(str2);//Hello

发现，“修改”str1之后，str2也没有发生变化，还是hello?
事实上，str1 = "world"这样的代码并不算“修改”字符串，而是如下：

源码分析：

 如何才可以使字符串可变：

    public void test1(){
        //体现1
        String s1 = "abc";//字面量的定义方式
        String s2 = "abc";
        s1 = "hello";
        System.out.println(s1 == s2);//比较s1和s2的地址值
        System.out.println(s1);//hello
        System.out.println(s2);//abc
        System.out.println("********************************");
        //体现2
        String s3 = "abc";
        s3 += "def";
        System.out.println(s3);//abcdef
        System.out.println(s2);//abc
        System.out.println("***********************************");
        //体现3
        String s4 = "abc";
        String s5 = s4.replace('a','m');
        System.out.println(s4);//abc
        System.out.println(s5);//mbc
    }

String的实例化方式：

方式一：直接赋值(通过字面量定义的方式)

String str = "hello world";

这种方式的"hello world"保存在常量池中。

方式二：通过new + 构造器的方式

String str = new String("hello");

这样的做法有两个缺点：

    1.如果使用String构造方法就会开辟两块堆内存空间，并且其中一块堆内存将成为垃圾空间(字符串常量"hello"也是一个匿名对象，用了一次之后就不再使用了，就成为垃圾空间，会被JVM自动回收掉)，

    2.字符串共享问题，同一个字符串可能会被存储多次，比较浪费空间。

这种方式创建的字符串，"hello world"没在常量池上，可以手动入池。 

public static void main(String[] args) {
    //该字符串常量并没有保存在对象池中
    String str1 = new String("hello");
    String str2 = "hello";
    System.out.println(str1 == str2);//false
    //手动入池
    String str1 = new String("hello").intern();
    String str2 = "hello";
    System.out.println(str1 == str2);//true
}

面试题：请解释String类中两种对象实例化的区别

        1.直接赋值：只会开辟一块堆内存空间，并且该字符串对象可以自动保存在对象池中以供下次使用。

        2.构造方法：会开辟两块堆内存空间，不会自动保存在对象池中，可以使用intern()方法手动入池。

综上，一般采用直接赋值的方式创建String对象。

方式三：通过char数组创建字符串

char[] data = {'h','e','l','l','o'};
String str = new String(data);

字符串常量池的理解： 

public static void main(String[] args) {
        String str = "hello";
        String str1 = "hello";
        String str2 = "hello";
        System.out.println(str == str1);//true
        System.out.println(str1 == str2);//true
}

JVM会对字符串创建一个字符串的常量池

当使用直接赋值创建字符串时，字面量是第一次出现，JVM就会创建一个String对象并且仍如常量池中，当字面量第二次或者对此被引用时，并不会创建新的对象，而是复用已有对象。 

 理解"池"

"池"是编程中的一种常见的，重要的提升效率的方式。我们会在未来的学习中遇到各种"内存池"，"线程池"，"数据库连接池"...

然而池这样的概念不是计算机独有，也是来自于生活中，举个例子：

现实生活中称为"绿茶"，在和高富帅谈着对象的同时，还可能和别的屌丝搞暧昧，这时候这个屌丝被称为"备胎"，那么为啥要有备胎？因为一旦和高富帅分手了，就可以立刻找备胎接盘。这样效率比较高。

如果这个女神，同时在和多个屌丝搞暧昧，那么这些备胎就称为备胎池。

在常量池中，复用已有对象，保证效率；效率高体现的淋漓尽致，可以无缝对接~

现在"转正的对象"被垃圾回收了；新对象可以无缝对接立马转正，少了个寻找的过程。

public static void main(String[] args) {
        String str = "hello";
        //有new就有新空间
        String str1 = new String("hello");
        String str2 = new String("hello");
        System.out.println(str == str1);//false
        System.out.println(str1 == str2);//false
}

面试题：String s = new String("abc")的方式创建对象，在内存中创建了几个对象？
       两个：一个是堆空间中new结构，另一个是char[]对应的常量池中的数据："abc"

 public void Test2(){
        //通过字面量定义的方式:此时的s1和s2的数据javaEE声明在方法区中的字符串常量池中。
        String s1 = "javaEE";
        String s2 = "javaEE";
        //通过new + 构造器的方式：此时的s3和s4保存的地址值，是数据在堆空间中开辟空间以后对应的地址值
        String s3 = new String("javaEE");
        String s4 = new String("javaEE");
        System.out.println(s1 == s2);//true
        System.out.println(s1 == s3);//false
        System.out.println(s1 == s4);//false
        System.out.println(s3 == s4);//false
        System.out.println("******************************************");
        Person p1 = new Person("Tom",12);
        Person p2 = new Person("Tom",12);
        System.out.println(p1.name.equals(p2.name));//true
        System.out.println(p1.name == p2.name);//true//通过字面量的方式赋值，所以是true!!!!!!!!!!!!
    }

public void Test3(){
        String s1 = "javaEE";
        String s2 = "hadoop";
        String s3 = "javaEEhadoop";
        String s4 = "javaEE" + "hadoop";
        String s5 = s1 + "hadoop";
        String s6 = "javaEE" + s2;
        String s7 = s1 + s2;
        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 = s5.intern();//返回值得到的s8使用的常量池已经存在的"javaEEhadoop"
        System.out.println(s3 == s8);//true
    }
 @Test
    public void test4(){
        String s1 = "javaEEhadoop";
        String s2 = "javaEE";
        String s3 = s2 + "hadoop";
        System.out.println(s1 == s3);//false
        final String s4 = "javaEE";//s4:常量
        String s5 = s4 + "hadoop";
        System.out.println(s1 == s5);//true
    }

 结论：
1.常量与常量的拼接结果在常量池。且常量池中不会存在相同内容的常量。
2.只要其中有一个是变量，结果就在堆中。
3.如果拼接的结果调用intern()方法，返回值就在常量池中 

一道有深度的面试题 

public class StringTest {
    String str = new String("good");
    char[] ch = {'t','e','s','t'};
    public void change(String str,char ch[]){
        str = "test ok";
        ch[0] = 'b';
    }
    public static void main(String[] args) {
        StringTest ex = new StringTest();
        ex.change(ex.str,ex.ch);
        System.out.println(ex.str);//good
        System.out.println(ex.ch);//best
    }
}

解析： 

1.涉及的知识：

关于变量的赋值：如果变量是基本数据类型，此时赋值的是变量所保存的数据值。

                             如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。

Java中的方法的值传递机制：所谓的值传递，就是将实参值的副本传入方法里，而参数本身不受影响。

2.面试题的解析：因为传值过程中，传给形参的是地址值，而通过String试图修改实参是行不通的，因为String有不可变性。而数组的内容是可以修改的，通过形参修改堆空间中的数组中的内容，实参也会改变，因为形参和实参指向对空间中的同一个内容

字符串比较相等(使用equals方法)：

 字符串是引用数据类型，比较内容相等时，使用equals方法；

public static void main(String[] args) {
        //因为在字符串常量池中只有一个"hello",所以两个引用的地址相同
        String str1 = "hello";
        String str2 = "hello";
        System.out.println(str1 == str2);//true

        //每一次new,实际上生成了两个对象,本博客中有详细解释
        String str3 = new String("hello");
        String str4 = new String("hello");
        System.out.println(str3 == str4);//false

        //使用equals方法比较实体内容
        String str5 = new String("hello");
        String str6 = new String("hello");
        System.out.println(str5.equals(str6));//true
}

关于使用equals方法的两种方式应该使用哪种？

方式一：str.equals("hello");

方式二："hello".equals(str);

 

 假设现在str是由用户输入的，要判断str内容是否是"hello"

方式一会导致空指针异常，所以常常使用方式二。 

注意事项："Hello"这样的字面值常量，本质上也是一个String对象，完全可以使用equals()等String类对象的方法。

String的常用方法及其测试

String类的所有修改操作的内部都是创建一个新的字符串，字符串的不可变性！！无法修改原字符串！！

 public void test1(){
        String s1 = "HelloWorld";
        System.out.println(s1.length());//10
        System.out.println(s1.charAt(0));//H
        System.out.println(s1.isEmpty());//false
        String s2 = s1.toLowerCase();
        System.out.println(s1);//HelloWorld//s1是不可变的，仍然为原来的字符串
        System.out.println(s2);//helloworld//改成小写以后的字符串
        String s3 = "  he  llo  world  ";
        String s4 = s3.trim();
        System.out.println("-----" + s3 + "-----");//-----  he  llo  world  -----
        System.out.println("-----" + s4 + "-----");// -----he  llo  world-----
}
public void test2(){
        String s1 = "HelloWorld";
        String s2 = "helloworld";
        System.out.println(s1.equals(s2));//false
        System.out.println(s1.equalsIgnoreCase(s2));//true
        String s3 = "abc";
        String s4 = s3.concat("def");
        System.out.println(s4);//abcdef
        String s5 = "abc";
        String s6 = new String("abe");
        System.out.println(s5.compareTo(s6));//-2
        String s7 = "开关电源适配器";
        String s8 = s7.substring(2);
        System.out.println(s7);//开关电源适配器
        System.out.println(s8);//电源适配器
        String s9 = s7.substring(2,5);
        System.out.println(s9);//电源适
 }

 

 public void test3(){
        String str1 = "helloworld";
        boolean b1 = str1.endsWith("rld");
        System.out.println(b1);//true
        boolean b2 = str1.endsWith("He");
        System.out.println(b2);//false
        boolean b3 = str1.startsWith("ll",2);
        System.out.println(b3);//true
        String str2 = "wor";
        System.out.println(str1.contains(str2));//true
        System.out.println(str1.indexOf("lol"));//-1
        System.out.println(str1.indexOf("lo",5));//-1
        String str3 = "hellorworld";
        System.out.println(str3.lastIndexOf("or"));//7
        System.out.println(str3.lastIndexOf("or",6));//4
    }

字符串分割方法(String[] split()) :

使用特殊字符要使用转义字符。特殊字符有 * ^ : | . \

1、单个符号作为分隔符

特殊符号*
.split("\\*");
特殊符号^
.split("\\^");
特殊符号:
.split("\\:");
特殊符号|
.split("\\|");
特殊符号.
.split("\\.");
特殊符号\
.split("\\");

2、多个符号作为分隔符

String str = "abc^123#456";
.split("\\^|#");
输出：
abc
123
456

3、split表达式，其实就是一个正则表达式。*  ^ | 等符号在正则表达式中属于一种有特殊含义的字符，如果使用此种字符作为分隔符，必须使用转义符即\\加以转义。

如果使用多个分隔符则需要借助 | 符号，如2所示，但需要转义符的仍然要加上分隔符进行处理

此方法测试详见另一篇博客：自动装箱与自动拆箱 

与正则表达式有关的方法的测试

public void test4(){
        String str1 = "北京尚硅谷教育北京";
        String str2 = str1.replace('北','东');
        System.out.println(str1);//北京尚硅谷教育北京
        System.out.println(str2);//  东京尚硅谷教育东京
        String str3 = str1.replace("北京","上海");
        System.out.println(str3);//上海尚硅谷教育上海
        String str = "12hello34world5java7891mysql456";
        //把字符串中的数字替换成,，如果结果中开头和结尾有,的话去掉
        String string = str.replaceAll("\\d+",",").replaceAll("^,|,$","");
        System.out.println(string);//hello,world,java,mysql
        str = "12345";
        //判断str字符串中是否全部由数字组成，既由1-n个数字组成
        boolean matches = str.matches("\\d+");
        System.out.println(matches);//true
        String tel = "0571-4534289";
        //判断这是否是一个杭州的固定电话
        boolean result = tel.matches("0571-\\d{7,8}");
        System.out.println(result);//true
        str = "hello|world|java";
        String[] strs = str.split("\\|");
        for(int i = 0;i < strs.length;i++){
            System.out.print(strs[i]);//hello world java
        }
    }

 /*
    String 与 char[]之间的转换
    String --> char[]:调用String的toCharArray()
    char[] --> String:调用String的构造器
    */
    @Test
    public void test2(){
        String str1 = "abc123";
        char[] charArray = str1.toCharArray();
        for(int i = 0;i < charArray.length;i++){
            System.out.println(charArray[i]);
        }
        char[] arr = new char[]{'h','e','l','l','o'};
        String str2 = new String(arr);
        System.out.println(str2);
    }

/*
    String 与 byte[]之间的转换
    编码：String --> byte[]:调用String的getBytes()
    解码: byte[] --> String:调用String的构造器
    编码：字符串 --> 字节(看得懂 --> 看不懂的二进制数据)
    解码：编码的逆过程，字节 --> 字符串 (看不懂的二进制数据 --> 看的懂)
    说明：解码时，要求解码使用的字符集必须与编码时使用的编码集一致，否则会出现乱码。
     */
    @Test
    public void test3() throws UnsupportedEncodingException {
        String str1 = "abc123中国";
        byte[] bytes = str1.getBytes();//使用默认的字符集，进行转换
        System.out.println(Arrays.toString(bytes));//[97, 98, 99, 49, 50, 51, -28, -72, -83, -27, -101, -67]
        byte[] gbks = str1.getBytes("gbk");//使用了gbk字符集进行编码
        System.out.println(Arrays.toString(gbks));//[97, 98, 99, 49, 50, 51, -42, -48, -71, -6]
        String str2 = new String(bytes);//使用默认的字符集，进行解码
        System.out.println(str2);//abc123中国
        String str3 = new String(gbks);//abc123�й�//乱码
        System.out.println(str3);//出现乱码，原因：编码集和解码集不一致！
        String str4 = new String(gbks,"gbk");
        System.out.println(str4);//abc123中国
    }

由于String不可变，若需要大量修改字符串内容时，使用两个sb类

StringBuffer：线程安全

StringBuilder：线程不安全

这两个类和String八竿子打不着，两种不同的类型，千万不要混为一谈。

String -> StringBuilder：调用StringBuilder的append或者通过构造方法传入String对象

StringBuilder -> String：调用StringBuilder的toString

public static void main(String[] args) {
    //String -> StringBuilder
    //通过构造方法将String -> StringBuilder
    StringBuilder sb = new StringBuilder("hello");
    //调用append方法将String -> StringBuilder
    sb.append("world");
    sb.append("！！！");
    String ret = sb.toString();
    System.out.println(ret);//helloworld！！！
}

StringBuilder具备一些String不具备的方法(因为StringBuilder内容可改，String内容无法修改)

a.reverse() - 反转

b.delete(int start,int end) - 删除指定范围的内容

c.insert(int start,插入的数据)

String、StringBuffer、StringBuilder三者的异同？
String:不可变的字符序列：底层使用char[]存储
StringBuffer:可变的字符序列：线程安全的，效率低；底层使用char[]存储
StringBuilder:可变的字符序列：JDK5.0新增的，线程不安全的，效率高；底层使用char[]存储

源码分析：

String str = new String();//char[] value = new char[0];
String str1 = new String("abc");//char[] value = new char[]{'a','b','c'};
StringBuffer sb1 = new StringBuffer();//char[] value = new char[16];底层创建了一个长度是16的数组。
sb1.append('a');//value[0] = 'a';
sb1.append('b');//value[1] = 'b';
StringBuffer sb2 = new StringBuffer("abc");//char[] value = new char["abc".length() + 16];

​​​问题1. System.out.println(sb2.length());//3
问题2. 扩容问题：如果要添加的数据底层数组盛不下了，那就需要扩容底层的数组。
         默认情况下，扩容为原来容量的2倍 + 2，同时将原有的数组中的元素复制到新的数组中
指导意义：开发中建议大家使用：StringBuffer(int capacity)或StringBuilder(int capacity)

面试题：String、StringBuffer和StringBuilder的异同？
相同点：底层都是通过char数组实现的
不同点：

1. String对象一旦创建，其值是不能修改的，如果要修改，会重新开辟内存空间来存储修改之后的对象；而StringBuffer和StringBuilder对象的值是可以被修改的；
2. StringBuffer几乎所有的方法都使用synchronized实现了同步，线程比较安全，在多线程系统中可以保证数据同步，但是效率比较低；而StringBuilder 没有实现同步，线程不安全，在多线程系统中不能使用 StringBuilder，但是效率比较高。
3. 如果我们在实际开发过程中需要对字符串进行频繁的修改，不要使用String，否则会造成内存空间的浪费；当需要考虑线程安全的场景下使用 StringBuffer，如果不需要考虑线程安全，追求效率的场景下可以使用 StringBuilder。            

public void test1(){
        StringBuffer sb1 = new StringBuffer("abc");
        sb1.setCharAt(0,'m');
        System.out.println(sb1);//mbc
    }

对比String、StringBuffer、StringBuilder三者的效率:

从高到低排列：StringBuilder > StringBuffer > String

String str = "hello";
str += "world";
str += "!!!";

产生了多少个对象？

可以发现，只有一个对象；在这个过程中，JVM没有那么笨，当发现有字符串的"+"时，JVM会将字符串转为StringBuilder类