前言

本博主将用CSDN记录软件开发求学之路上亲身所得与所学的心得与知识，有兴趣的小伙伴可以关注博主！
也许一个人独行，可以走的很快，但是一群人结伴而行，才能走的更远！让我们在成长的道路上互相学习，欢迎关注！

一、关于String的特性

⭕ String类：代表字符串，使用一对""引起来表示。
Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例实现。

⭕ String是一个final类，不可被继承。

⭕ String实现了两个接口：
● 实现了Serializable接口：表示字符串是支持序列化的。
● 实现了Comparable接口：表示String可以比较大小。

⭕ String内部定义了final char[] value用于存储字符串数据，对象的字符内容是存储在一个字符数组value[]中的。

⭕ String源码：

public final class String implements java.io.Serializable, Comparable<String>, CharSequence {
/** The value is used for character storage. */
private final char value[];
/** Cache the hash code for the string */
private int hash; // Default to 0

⭕ 字符串常量池中是不会存储相同内容的字符串的。

⭕ String：代表不可变的字符序列，它们的值在创建之后不能更改，简称：不可变性。
体现：
● 当对字符串重新赋值时，需要重写指定内存区域赋值，不能使用原有的value进行赋值。
● 当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。
● 当调用String的replace()方法修改指定字符或字符串时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。

代码演示1：

@Test
    public void test1(){
        String s1 = "abc";//字面量的定义方式
        String s2 = "abc";
        //比较s1和s2的地址值
        System.out.println(s1 == s2);//true
        
        
        
        s1 = "hello";
        //比较s1和s2的地址值
        System.out.println(s1 == s2);//false
        System.out.println(s1);//hello
        System.out.println(s2);//abc


        String s3 = "abc";
        s3 += "def";
        System.out.println(s3);//abcdef
        System.out.println(s2);//abc


        String s4 = "abc";
        String s5 = s4.replace('a', 'm');
        System.out.println(s4);//abc
        System.out.println(s5);//mbc
}

代码演示2：

//面试题：体现了String的不可变性
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
    }
}

二、String的实例化方式

1、两种实例方式

⭕通过字面量定义的方式。
通过字面量的方式（区别于new+构造器）给一个字符串赋值，此时的字符串值声明在字符串常量池中。

⭕通过new + 构造器的方式
问题：String s = new String("abc");方式创建对象，在内存中创建了几个对象？

一共两个:

一个是堆空间中new结构，

另一个是char[]对应的常量池中的数据："abc"

2、代码演示

代码演示1：

//测试：
@Test
public void test1(){
        //通过字面量定义的方式：此时的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

}

内存图解1：

代码演示2：

//Person类
public class Person {
    public String name;
    public  int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person() {
    }

}
public void test1(){
 
        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
        

        p1.name = "Jerry";
        System.out.println(p2.name);//Tom
}

内存图解2：

三、String的拼接问题

1、概述

⭕常量与常量的拼接结果在常量池。且常量池中不会存在相同内容的常量。

⭕ 如果与拼接的对象里，只要其中有一个是变量，结果就在堆中。

⭕ 如果拼接的结果调用intern()方法，返回值就在常量池中。

2、代码演示

代码演示1：

      @Test
    public void test1(){
        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 = s6.intern();//返回值得到的s8使用的常量值中已经存在的“javaEEhadoop”
        System.out.println(s3 == s8);//true
    }

代码演示2：

 @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
    }

3、String使用陷阱

⭕ String s1 = "a";
说明：在字符串常量池中创建了一个字面量为"a"的字符串。

⭕ s1 = s1 + "b";
说明：实际上原来的"a"字符串对象已经丢弃了，现在在堆空间中产生了一个字符串s1+"b"（也就是"ab")。如果多次执行这些改变串内容的操作，会导致大量副本字符串对象存留在内存中，降低效率。如果这样的操作放到循环中，会极大影响程序的性能。

⭕ String s2 = "ab";
说明：直接在字符串常量池中创建一个字面量为"ab"的字符串。

⭕ String s3 = "a" + "b";
说明：s3指向字符串常量池中已经创建的"ab"的字符串。

⭕ String s4 = s1.intern();
说明：堆空间的s1对象在调用intern()之后，会将常量池中已经存在的"ab"字符串赋值给s4。

四、String常用方法

1、组1

序号	方法	作用
1	`int length()`	返回字符串的长度： `return value.length`
2	`char charAt(int index)`	返回某索引处的字符：`return value[index]`
3	`boolean isEmpty()`	判断是否是空字符串：`return value.length == 0`
4	`String toLowerCase()`	使用默认语言环境，将 `String` 中的所有字符转换为小写
5	`String toUpperCase()`	使用默认语言环境，将 `String` 中的所有字符转换为大写
6	`String trim()`	返回字符串的副本，忽略前导空白和尾部空白
7	`boolean equals(Object obj)`	比较字符串的内容是否相同
8	`boolean equalsIgnoreCase(String anotherString)`	与`equals`方法类似，忽略大小写
9	`String concat(String str)`	将指定字符串连接到此字符串的结尾，等价于用`“+”`
10	`int compareTo(String anotherString)`	比较两个字符串的大小
11	`String substring(int beginIndex)`	返回一个新的字符串，它是此字符串的从 `beginIndex`开始截取到最后的一个子字符串
12	`String substring(int beginIndex, int endIndex)`	返回一个新字符串，它是此字符串从`beginIndex`开始截取到endIndex(不包含)的一个子字符串

代码演示1-1：

    @Test
    public void test1() {
        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);//之路一
    }   
}

代码演示1-2：

   @Test
    public void test1() {
        String s1 = "HelloWorld";
        System.out.println(s1.length());//10
        System.out.println(s1.charAt(0));//H
        System.out.println(s1.charAt(9));//d
        System.out.println(s1.charAt(10));//报错
        String s5 = "";
        System.out.println(s1.isEmpty());//false
        System.out.println(s5.isEmpty());//true

        String s2 = s1.toLowerCase();
        //s1不可变的，仍然为原来的字符串
        System.out.println(s1);//HelloWorld
        //改成小写以后的字符串
        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-----
    }

2、组2

序号	方法	作用
13	`boolean endsWith(String suffix)`	测试此字符串是否以指定的后缀结束
14	`boolean startsWith(String prefix)`	测试此字符串是否以指定的前缀开始
15	`boolean startsWith(String prefix, int toffset)`	测试此字符串从指定索引开始的子字符串是否以指定前缀开始。
16	`boolean contains(CharSequences)`	当且仅当此字符串包含指定的char 值序列时，返回 `true`
17	`int indexOf(String str)`	返回指定子字符串在此字符串中第一次出现处的索引
18	`int indexOf(String str, int fromIndex)`	返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。
19	`int lastIndexOf(String str)`	返回指定子字符串在此字符串中最右边出现处的索引。
20	`int lastIndexOf(String str, int fromIndex)`	返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。

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

代码演示2-1

@Test
    public void test1(){
      String str1 = "hellowworld";
        boolean b1 = str1.endsWith("rld");
        System.out.println(b1);//true

        boolean b2 = str1.startsWith("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

        //什么情况下，indexOf(str)和lastIndexOf(str)返回值相同？
        //情况一：存在唯一的一个str。情况二：不存在str
    }

3、组3

序号	方法	作用
21	`String replace(char oldChar, char newChar)`	返回一个新的字符串，它是通过用 `newChar` 替换此字符串中出现的所有 `oldChar`得到的
22	`String replace(CharSequence target, CharSequence replacement`)	使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。
23	`String replaceAll(String regex,String replacement)`	使用给定的`replacement`替换此字符串所有匹配给定的正则表达式的子字符串。
24	`tring replaceFirst(String regex, String replacement)`	使用给定的`replacement` 替换此字符串匹配给定的正则表达式的第一个子字符串。
25	`boolean matches(String regex)`	告知此字符串是否匹配给定的正则表达式
26	`String[] split(String regex)`	根据给定正则表达式的匹配拆分此字符串
27	`String[] split(String regex, int limit)`	根据匹配给定的正则表达式来拆分此字符串，最多不超过`limit`个，如果超过了，剩下的全部都放到最后一个元素中。
28	`public static String join(CharSequence delimiter,CharSequence... elements)`	返回一个新的字符串，由`CharSequence elements`的副本组成，并附有指定的`delimiter的delimiter`

代码演示3-1

  @Test
    public void test1(){
        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.println(strs[i]);
        }
        /**
         * hello
         * world
         * java
         */
        System.out.println();
        str2 = "hello.world.java";
        String[] strs2 = str2.split("\\.");
        for (int i = 0; i < strs2.length; i++) {
            System.out.println(strs2[i]);
        }
        /**
         * hello
         * world
         * java
         */

    }

五、String与char[ ]、byte[ ]的转换

1、String与char[ ]

⭕ char[]–>String：调用String的构造器

序号	构造器	作用
1	`String(char[])`	用字符数组中的全部字符创建字符串对象
2	`String(char[]，int offset，int length)`	用字符数组中的部分字符创建字符串对象

⭕ String–>char[]：调用String的toCharArray()

序号	方法	作用
1	`public char[] toCharArray()`	将字符串中的全部字符存放在一个字符数组中的方法。
2	`public void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)`	提供了将指定索引范围内的字符串存放到数组中的方法。

代码演示

    @Test
    public void test17(){
        String str1 = "abc123";  //题目： a21cb3

        char[] charArray = str1.toCharArray();
        for (int i = 0; i < charArray.length; i++) {
            System.out.println(charArray[i]);
        }
        /**
         * a
         * b
         * c
         * 1
         * 2
         * 3
         */

        char[] arr = new char[]{'h','e','l','l','o'};
        String str2 = new String(arr);
        System.out.println(str2);//hello
    }

2、String与byte[ ]

⭕ 编码：String–>byte[]:调用String的getBytes()

序号	方法	作用
1	`public byte[] getBytes()`	使用平台的默认字符集将此 `String` 编码为`byte` 序列，并将结果存储到一个新的`byte` 数组中。
2	`public byte[] getBytes(String charsetName)`	使用指定的字符集将此`String` 编码到 `byte` 序列，并将结果存储到新的 `byte` 数组。

⭕ 解码：byte[]–>String:调用String的构造器

序号	构造器	作用
1	`String(byte[])`	通过使用平台的默认字符集解码指定的 `byte` 数组，构造一个新的 `String`
2	`String(byte[]，int offset，int length)`	用指定的字节数组的一部分,即从数组起始位置`offset`开始取`length`个字节构造一个字符串对象

⭕ 注意：解码时，要求解码使用的字符集必须与编码时使用的字符集一致，否则会出现乱码。

代码演示：

@Test
    public void test1() 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]

        //使用gbk字符集进行编码。
        byte[] gbks = str1.getBytes("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);
        //出现乱码。原因：编码集和解码集不一致！
        System.out.println(str3);//abc123�й�


        String str4 = new String(gbks, "gbk");
        没有出现乱码。原因：编码集和解码集一致！
        System.out.println(str4);//abc123中国

        String str = "中";
         -128~127
        System.out.println(str.getBytes("ISO8859-1").length);//1
        System.out.println(str.getBytes("GBK").length);//2
        System.out.println(str.getBytes("UTF-8").length);//3
        
         乱码，表示不了中文
        System.out.println(new String(str.getBytes("ISO8859-1"),"ISO8859-1"));//?
        System.out.println(new String(str.getBytes("GBK"), "GBK"));//中
        System.out.println(new String(str.getBytes("UTF-8"), "UTF-8"));//中
    }

六、String、StringBuffer、StringBuilder

1、概述

1.1 String(JDK1.0)

⭕ 不可变的字符序列；

⭕ 底层使用char[]存储

1.2 StringBuffer(JDK1.0)

⭕ 可变的字符序列；

⭕ 线程安全的，效率低；

⭕ 底层使用char[]存储，可以对字符串内容进行增删，此时不会产生新的对象。

⭕ 很多方法与String相同。

⭕ 作为参数传递时，方法内部可以改变值。

⭕ StringBuffer类不同于String，其对象必须使用构造器生成。有三个构造器：

序号	构造器	作用
1	`StringBuffer()`	初始容量为16的字符串缓冲区
2	`StringBuffer(int size)`	构造指定容量的字符串缓冲区
3	`StringBuffer(String str)`	将内容初始化为指定字符串内容

1.3 StringBuilder(JDK 5.0)

⭕ 可变的字符序列

⭕ jdk5.0新增的，线程不安全的，效率高；底层使用char[]存储。

代码演示：

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

        StringBuffer sb2 = new StringBuffer();
        System.out.println(sb2.length());//0
    }

注意：作为参数传递的话，方法内部String不会改变其值，StringBuffer和StringBuilder 会改变其值。

2、源码分析

    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的数组。
    System.out.println(sb1.length());//0
    sb1.append('a');//value[0] = 'a';
    sb1.append('b');//value[1] = 'b';

    StringBuffer sb2 = new StringBuffer("abc");//char[] value = new char["abc".length() + 16];
    System.out.println(sb2.length());//3

⭕ 扩容问题:如果要添加的数据底层数组盛不下了，那就需要扩容底层的数组。默认情况下，扩容为原来容量的 2倍 + 2，同时将原有数组中的元素复制到新的数组中。

⭕ 开发中建议大家使用：StringBuffer(int capacity) 或 StringBuilder(int capacity)

3、StringBuffer的常用方法

序号	方法	作用
1	`StringBuffer append(xxx)`	提供了很多的`append()`方法，用于进行字符串拼接
2	`StringBuffer delete(int start,int end)`	删除指定位置的内容
3	`StringBuffer replace(int start,int end, String str)`	把`[start,end)`位置替换为`str`
4	`StringBuffer insert(int offset, xxx)`	在指定位置插入xxx
5	`StringBuffer reverse()`	把当前字符序列逆转
6	`public int indexOf(String str)`	返回字符串`str`的索引
7	`public String substring(int start,int end)`	返回一个从`start`开始到`end`索引结束的左闭右开区间的子字符串
8	`public int length()`	获取长度
9	`public char charAt(int n )`	获取指定位置的字符
10	`public void setCharAt(int n ,char ch)`	将指定位置的字符设置为`ch`

总结：

总结	方法
增	`append(xxx)`
删	`delete(int start,int end)`
改	`setCharAt(int n ,char ch) / replace(int start, int end, String str)`
查	`charAt(int n )`
插	`insert(int offset, xxx)`
长度	`length()`
遍历	`for() + charAt() / toString()`

注意：

⭕ 当append()和insert()时，如果原来value数组长度不够，可扩容。

⭕ 如上这些方法支持方法链操作

代码演示1：

 @Test
    public void test6(){
        StringBuffer s1 = new StringBuffer("abc");
        s1.append(1);
        s1.append('1');
        System.out.println(s1);//abc11
        String s2 = s1.substring(1, 3);
        System.out.println(s1);//abc11
        System.out.println(s1.length());//5
        System.out.println(s2);//bc
        s1.delete(2,4);
        System.out.println(s1);//ab1
        s1.replace(2,4,"hello");
        System.out.println(s1);//abhello
        s1.insert(2,false);
        System.out.println(s1);//abfalsehello
        s1.reverse();
        System.out.println(s1);//olleheslafba

    }

代码演示2：

    @Test
    public void test1() {
        String str = null;
        StringBuffer sb = new StringBuffer();
        sb.append(str);
        System.out.println(sb.length());//4
        System.out.println(sb);//null
        StringBuffer sb1 = new StringBuffer(str);
        System.out.println(sb1);//报错
    }

4、对比String、StringBuffer、StringBuilder三者的效率：

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

代码演示：

    @Test
    public void test3(){
        //初始设置
        long startTime = 0L;
        long endTime = 0L;
        String text = "";
        StringBuffer buffer = new StringBuffer("");
        StringBuilder builder = new StringBuilder("");
        //开始对比
        startTime = System.currentTimeMillis();
        for (int i = 0; i < 20000; i++) {
            buffer.append(String.valueOf(i));
        }
        endTime = System.currentTimeMillis();
        System.out.println("StringBuffer的执行时间：" + (endTime - startTime));//StringBuffer的执行时间：4

        startTime = System.currentTimeMillis();
        for (int i = 0; i < 20000; i++) {
            builder.append(String.valueOf(i));
        }
        endTime = System.currentTimeMillis();
        System.out.println("StringBuilder的执行时间：" + (endTime - startTime));//StringBuilder的执行时间：3

        startTime = System.currentTimeMillis();
        for (int i = 0; i < 20000; i++) {
            text = text + i;
        }
        endTime = System.currentTimeMillis();
        System.out.println("String的执行时间：" + (endTime - startTime));//String的执行时间：1284

    }