• 【JAVA学习笔记】49 - String类，StringBuffer类，StringBuilder类（重要）

    项目代码

    https://github.com/yinhai1114/Java_Learning_Code/tree/main/IDEA_Chapter13/src/com/yinhai/wrapper_/string_

    https://github.com/yinhai1114/Java_Learning_Code/tree/main/IDEA_Chapter13/src/com/yinhai/wrapper_/stringbuffer_

    https://github.com/yinhai1114/Java_Learning_Code/tree/main/IDEA_Chapter13/src/com/yinhai/wrapper_/stringbuilder_

    目录

    项目代码

    String类

    一、String入门

    二、创建String对象的两种方式

    练习

    1.

    2.

    3.intern方法

    4.

    5.

    6.字符串的特性常量池

    7. 字符串特性常量相加

    8.字符串特性变量相加

    9.

    10.数组传递，字符串引用，多看！

    三、String类的常用方法 

     StringBuffer类

    一、基本介绍

    类结构图              ​编辑

     二、String和StringBuffer的对比

    三、StringBuffer的构造器

    四、String和StringBuffer的互相转化

    五、StringBuffer常用方法

    练习

    1.

    2. 

    StringBuilder类

    一、基本介绍

    类结构图

    三个String、StringBuffer 和StringBuilder的比较

    效率测试

    三个String、StringBuffer 和StringBuilder的使用原则

    String类

    一、String入门


    1. String对象用于保存字符串，也就是一组字符序列

    2.字符串常量对象是用双引号括起的字符序列。例如: "你好"、 "12.97"、 "boy"等

    3.字符串的字符使用Unicode字符编码，一个字符（不区分字母还是汉字）占两个字节

    4.String类较常用构造器

            String s1 = new String();

            String s2 = new String(String original);

            String s3 = new String(char[] a):

            String s4 = new String(char[] a,int startindex,int count)

    5. String 类实现了接口 Serializable[String 可以串行化:可以在网络传输]

                                接口 Comparable [String 对象可以比较大小]

    6. String 是final 类，不能被其他的类继承

    7. String 有属性 private final char value[]; 用于存放字符串内容 //字符串本质还是char类型数组

    8. 一定要注意：value 是一个final类型， 不可以修改(地址不可以修改)：即value不能指向新的地址，但是单个字符内容是可以变化

    1. public class String01 {
    2.     public static void main(String[] args) {
    3.         //1.String 对象用于保存字符串，也就是一组字符序列
    4.         //2. "jack" 字符串常量, 双引号括起的字符序列
    5.         //3. 字符串的字符使用Unicode字符编码，一个字符(不区分字母还是汉字)占两个字节
    6.         //4. String 类有很多构造器，构造器的重载
    7.         //   常用的有 String  s1 = new String(); //
    8.         //String  s2 = new String(String original);
    9.         //String  s3 = new String(char[] a);
    10.         //String  s4 =  new String(char[] a,int startIndex,int count)
    11.         //String s5 = new String(byte[] b)
    12.         //5. String 类实现了接口 Serializable[String 可以串行化:可以在网络传输]
    13.         //                 接口 Comparable [String 对象可以比较大小]
    14.         //6. String 是final 类，不能被其他的类继承
    15.         //7. String 有属性 private final char value[]; 用于存放字符串内容 //字符串本质还是char类型数组
    16.         //8. 一定要注意：value 是一个final类型， 不可以修改(地址不可以修改)：即value不能指向新的地址，但是单个字符内容是可以变化
    17.  
    18.         String name = "jack";
    19.         name = "tom";
    20.         final char[] value = {'a','b','c'};
    21.         char[] v2 = {'t','o','m'};
    22.         value[0] = 'H';
    23.         //value = v2; 不可以修改 value地址
    24.  
    25.     }
    26. }

    二、创建String对象的两种方式

    方式一:直接赋值Strings = "hsp";

    方式二:调用构造器String s2 = new String("hsp");

    方式一，先从常量池查看是否有"hsp"数据空间，如果有，直接指向;如果没有则重新创建，然后指向。s最终指向的是常量池的空间地址

    方式二:先在堆中创建空间，里面维护了value属性，指向常量池的hsp空间。如果常量池没有"hsp",重新创建，如果有，直接通过value指向。最终指向的是堆中的空间地址。value指向常量池的空间

    3.画出两种方式的内存分布图

    练习

    1.

                    

    true ，String重写了equals方法，先比较地址，然后比较字符串内容，if（a == b），为假后循环遍历比较内容

    true，==比较的是地址

    2.

    1. String a = "hsp";
    2. String b =new String("hsp");
    3. System.out.println(a.equals(b));
    4. System.out.println(a==b); 
    5. System.out.println(a==b.intern0);
    6. System.out.println(b==b.intern();

    3.intern方法

    1. public class StringExercise03 {
    2.     public static void main(String[] args) {
    3.         String a = "hsp";//指向常量池的hsp
    4.         String b = new String("hsp");//b指向堆，String内的，对象内的value指向常量池
    5.         System.out.println(a.equals(b));//T
    6.         System.out.println(a == b);//F a->常量池"hsp" b->堆里的String空间的value
    7.         System.out.println(a == b.intern());//T
    8.         System.out.println(b == b.intern());//F
    9.         //intern:返回当调用intern方法时，如果池已经包含一个等于此，String对象的字符串(用equals(Obiect方法确定)
    10.         //则返回池中的字符串。否则，将此String对象添加到池中，并返回此String对象的引用
    11.         //b.intern()方法最终返回的是常量池的地址(对象)
    12.     }
    13. }

    4.

    1. public class StringExercise04 {
    2.     public static void main(String[] args) {
    3.         String s1 = "hspedu";//指向常量池
    4.         String s2 = "java";//指向常量池
    5.         String s4 = "java";//指向常量池
    6.         String s3 = new String("java");//指向堆中对象
    7.         System.out.println(s2 == s3);//F
    8.         System.out.println(s2 == s4);//T
    9.         System.out.println(s2.equals(s3));//T
    10.         System.out.println(s1 == s2);//F
    11.     }
    12. }

    5.

    p1.name == p2.name 比较的是两者的地址，两者都指向hspedu，所以当然相等

    6.字符串的特性常量池

            创建了两个对象        

    7. 字符串特性常量相加

            编译器会优化，等价于String a = "helloabc"，因为创建的hello和abc没人用，所以优化了

    8.字符串特性变量相加

            

    .

    1. public class StringExercise08 {
    2.     public static void main(String[] args) {
    3.         String a = "hello";
    4.         String b = "abc";
    5.         //1.创建了一个StringBuilder
    6.         //2.执行sb.append("hello") 3.再append("abc")
    7.         //再调用String sb.toString()
    8.         //最后其实是c->堆中的对象的value[] ->池中的"helloabc"
    9.         String c = a + b;
    10.         //如果有了就直接用
    11.         String d = "hello" + "abc";//直接指向堆里的helloabc
    12.         System.out.println(c == d);//false
    13.     }
    14. }

            底层是StringBuilder sb = new StringBuilder(); sb.append(a);sb.append(b); sb是在堆中，并且append是在原来字符串的基础上追加的.

            重要规则，Stringc1 = "ab" + "cd";常量相加，看的是池。

                              Stringc1 = a+b ;变量相加,看的是堆。

             

    9.

    10.数组传递，字符串引用，多看！

    三、String类的常用方法 

            String类是保存宇符事常量的。每次更新都需要重新开辟空间，效率较低，因此java设计者提供了StringBuilder和StringBuffer来增强String的功能，并提高效率。[后面我们还会详细介绍StringBuilder和StringBuffer]

    1.equals //区分大小写，判断内容是否相等

    2.equalslgnoreCase //忽略大小写的判断内容是否相等

    3.length /获取字符的个数，字符串的长度

    4.indexOf //获取字符在字符串中第1次出现的索引,索引从0开始,如果找不到,返回-1

    5.lastIndexOf //获取字符在字符串中最后1次出现的索引,索引从0开始,如找不到返回-1

    6.substring //截取指定范围的子串

    7.trim //去前后空格

    8.charAt:获取某索引处的字符，注意不能使用Str[index]这种方式.

            String str = “hello”

            str[0] //错误

            str.chatAt（0） => h

    9.toUpperCase转换成大写Strings = "heLLo";System.out.println(s.toUpperCase();

    10.toLowerCaseSystem.out.println(s.toLowerCase();

    11.concat拼接字符串

            Strings1 =“宝玉";

            s1 = s1.concat("林黛玉).concat("薛宝钗").concat(" together");

            System.out.println(s1);

    12.replace替换字符串中的字符

            ”Strings1 =“宝玉and薛宝钗薛宝钗薛宝钗";

            ”s1 = s1.replace("林黛玉"，"薛宝钗");

            System.out.println(s1);

    13.split分割字符串，对于某些分割字符，我们需要转义比如| |\等

            String poem = "锄禾日当午,汗滴禾下土，谁知盘中餐，粒粒皆辛苦";

            StringD] split = poem.split(",");

            String poem = "E:\laaa\bbb";

            String[ split = poem.split("\\|");

            String[] split = poem.splt("1lI"); 

            String[] split = poem.split(1"\1I");
            ”for(int i=0;i< split.length;i+ +){
                     System.out.println(split[);
            }

    14.toCharArray转换成字符数组

            String s = "happy";

            char[ chs = s.toCharArray();

     StringBuffer类

    一、基本介绍

            java.lang.StringBuffer代表可变的字符序列，可以对字符串内容进行增删。很多方法与String相同，但StringBuffer是可变长度的。StringBuffer是一个容器

    类结构图              

    1. StringBuffer 的直接父类 是 AbstractStringBuilder
    2. StringBuffer 实现了 Serializable, 即StringBuffer的对象可以串行化
            StringBuffer stringBuffer = new StringBuffer("hello");
    3. 在父类中AbstractStringBuilder有属性 char[] value,不是final类型。该 value 数组存放 字符串内容，引出存放在堆中的
    4. StringBuffer 是一个 final类，不能被继承
    5. 因为StringBuffer 字符内容是存在 char[] value, 所有在变化(增加/删除)不用每次都更换地址(即不是每次创建新对象)， 所以效率高于 String

    1. public class StringBuffer01 {
    2.     public static void main(String[] args) {
    3.         //1. StringBuffer 的直接父类 是 AbstractStringBuilder
    4.         //2. StringBuffer 实现了 Serializable, 即StringBuffer的对象可以串行化
    5.         StringBuffer stringBuffer = new StringBuffer("hello");
    6.         //3. 在父类中AbstractStringBuilder有属性 char[] value,不是final类型
    7.         //   该 value 数组存放 字符串内容，引出存放在堆中的
    8.         //4. StringBuffer 是一个 final类，不能被继承
    9.         //5. 因为StringBuffer 字符内容是存在 char[] value, 所有在变化(增加/删除)
    10.         //   不用每次都更换地址(即不是每次创建新对象)， 所以效率高于 String
    11.     }
    12. }

     二、String和StringBuffer的对比

            1) String保存的是字符串常量，里面的值不能更改，每次String类的更新实际上就是更改地址， 效率较低//private final char valuel[];

            2) StringBuffer保存的是字符串变量，里面的值可以更改，每次StringBuffer的更新实际上可以更新内容，不用更新地址，效率较高//char[] value; // 这个放在堆.

    三、StringBuffer的构造器

    1. 创建一个 大小为 16的 char[] ,用于存放字符内容

    2. 通过构造器指定 char[] 大小

    3. 通过 给一个String 创建 StringBuffer, char[] 大小就是 str.length() + 16

    1. public class StringBuffer02 {
    2.     public static void main(String[] args) {
    3.  
    4.         //构造器的使用
    5.         //1. 创建一个 大小为 16的 char[] ,用于存放字符内容
    6.         StringBuffer stringBuffer = new StringBuffer();
    7.  
    8.         //2 通过构造器指定 char[] 大小
    9.         StringBuffer stringBuffer1 = new StringBuffer(100);
    10.         //3. 通过 给一个String 创建 StringBuffer, char[] 大小就是 str.length() + 16
    11.  
    12.         StringBuffer hello = new StringBuffer("hello");
    13.  
    14.     }
    15. }

    四、String和StringBuffer的互相转化


    1.String——>StringBuffer
    方式1 使用构造器
            注意： 返回的才是StringBuffer对象，对str 本身没有影响
            StringBuffer stringBuffer = new StringBuffer(str);
    方式2 使用的是append方法
            StringBuffer stringBuffer1 = new StringBuffer();
            stringBuffer1 = stringBuffer1.append(str);

    2.StringBuffer ->String
            StringBuffer stringBuffer3 = new StringBuffer("韩顺平教育");
    方式1 使用StringBuffer提供的 toString方法
            String s = stringBuffer3.toString();
    方式2: 使用构造器来搞定
            String s1 = new String(stringBuffer3);
     

    1. public class StringAndStringBuffer {
    2.     public static void main(String[] args) {
    3.  
    4.         //看 String——>StringBuffer
    5.         String str = "hello tom";
    6.         //方式1 使用构造器
    7.         //注意： 返回的才是StringBuffer对象，对str 本身没有影响
    8.         StringBuffer stringBuffer = new StringBuffer(str);
    9.        
    10.         //方式2 使用的是append方法
    11.         StringBuffer stringBuffer1 = new StringBuffer();
    12.         stringBuffer1 = stringBuffer1.append(str);
    13.  
    14.         //看看 StringBuffer ->String
    15.         StringBuffer stringBuffer3 = new StringBuffer("韩顺平教育");
    16.         //方式1 使用StringBuffer提供的 toString方法
    17.         String s = stringBuffer3.toString();
    18.         //方式2: 使用构造器来搞定
    19.         String s1 = new String(stringBuffer3);
    20.  
    21.     }
    22. }

    五、StringBuffer常用方法

    1.添加方法
            s.append(',');// "hello,"
            s.append("张三丰");//"hello,张三丰"
            s.append("赵敏").append(100).append(true).append(10.5);//"hello,张三丰赵敏100true10.5"

    2.删除方法
            /*
             * 删除索引为>=start &&          * 解读: 删除 11~14的字符 [11, 14) 到14-1下标的索引都同理
             */
            s.delete(11, 14);
            System.out.println(s);//"hello,张三丰赵敏true10.5"

    3.修改方法
            //使用 周芷若 替换 索引9-11的字符 [9,11)
            s.replace(9, 11, "周芷若");
            System.out.println(s);//"hello,张三丰周芷若true10.5"
            //查找指定的子串在字符串第一次出现的索引，如果找不到返回-1
            int indexOf = s.indexOf("张三丰");
            System.out.println(indexOf);//6
    4.插入方法
            //在索引为9的位置插入 "赵敏",原来索引为9的内容自动后移
            s.insert(9, "赵敏");//包含9
            System.out.println(s);//"hello,张三丰赵敏周芷若true10.5"
            //长度
            System.out.println(s.length());//22
            System.out.println(s);

    1. public class StringBufferMethod {
    2.     public static void main(String[] args) {
    3.  
    4.         StringBuffer s = new StringBuffer("hello");
    5.         //添加方法
    6.         s.append(',');// "hello,"
    7.         s.append("张三丰");//"hello,张三丰"
    8.         s.append("赵敏").append(100).append(true).append(10.5);//"hello,张三丰赵敏100true10.5"
    9.         System.out.println(s);//"hello,张三丰赵敏100true10.5"
    10.  
    11.  
    12.         //删除方法
    13.         /*
    14.          * 删除索引为>=start && 
    15.          * 解读: 删除 11~14的字符 [11, 14) 到14-1下标的索引都同理
    16.          */
    17.         s.delete(11, 14);
    18.         System.out.println(s);//"hello,张三丰赵敏true10.5"
    19.         //修改方法
    20.         //使用 周芷若 替换 索引9-11的字符 [9,11)
    21.         s.replace(9, 11, "周芷若");
    22.         System.out.println(s);//"hello,张三丰周芷若true10.5"
    23.         //查找指定的子串在字符串第一次出现的索引，如果找不到返回-1
    24.         int indexOf = s.indexOf("张三丰");
    25.         System.out.println(indexOf);//6
    26.         //插入方法
    27.         //在索引为9的位置插入 "赵敏",原来索引为9的内容自动后移
    28.         s.insert(9, "赵敏");//包含9
    29.         System.out.println(s);//"hello,张三丰赵敏周芷若true10.5"
    30.         //长度
    31.         System.out.println(s.length());//22
    32.         System.out.println(s);
    33.  
    34.     }
    35. }

    练习

    1.

    1. public class StringBufferExercise01 {
    2.     public static void main(String[] args) {
    3.         String str = null;// ok
    4.         StringBuffer sb = new StringBuffer(); //ok
    5.         sb.append(str);//需要看源码 , 底层调用的是 AbstractStringBuilder 的 appendNull () 增加了null字符
    6.         System.out.println(sb.length());//4
    7.  
    8.         System.out.println(sb);//null
    9.         //下面的构造器，会抛出NullpointerException
    10.         StringBuffer sb1 = new StringBuffer(str);//看底层源码 super(str.length() + 16);
    11.         System.out.println(sb1);
    12.  
    13.     }
    14. }

    2. 

    1. public class StringBufferExercise02 {
    2.     public static void main(String[] args) {
    3.         /*
    4.         输入商品名称和商品价格，要求打印效果示例, 使用前面学习的方法完成：
    5.         商品名	商品价格
    6.         手机	123,564.59  //比如 价格 3,456,789.88
    7.         要求：价格的小数点前面每三位用逗号隔开, 在输出。
    8.         思路分析
    9.         1. 定义一个Scanner 对象，接收用户输入的 价格(String)
    10.         2. 希望使用到 StringBuffer的 insert ，需要将 String 转成 StringBuffer
    11.         3. 然后使用相关方法进行字符串的处理
    12.         代码实现
    13.          */
    14.  
    15.         //new Scanner(System.in)
    16.         String price = "8123564.59";
    17.         StringBuffer sb = new StringBuffer(price);
    18.         //先完成一个最简单的实现123,564.59
    19.         //找到小数点的索引，然后在该位置的前3位，插入,即可
    20.         //int i = sb.lastIndexOf(".");
    21.         //sb = sb.insert(i - 3, ",");
    22.  
    23.         //上面的两步需要做一个循环处理,才是正确的
    24.         for (int i = sb.lastIndexOf(".") - 3; i > 0; i -= 3) {
    25.             sb = sb.insert(i, ",");
    26.         }
    27.         System.out.println(sb);//8,123,564.59
    28.     }
    29. }

    StringBuilder类

    一、基本介绍

            1.一个可变的字符序列。此类提供一个与StringBuffer兼容的API,但不保证同步。该类被设计用作StringBuffer的一个简易替换，用在字符串缓冲区被单个线程使用的时候。如果可能，建议优先采用该类，因为在大多数实现中，它比StringBuffer要快。

            2.在StringBuilder上的主要操作是 append和insert 方法，可重载这些方法，以接受任意类型的数据。

    类结构图

            

    1. StringBuilder 继承 AbstractStringBuilder 类
    2. 实现了 Serializable ,说明StringBuilder对象是可以串行化(对象可以网络传输,可以保存到文件)
    3. StringBuilder 是final类, 不能被继承
    4. StringBuilder 对象字符序列仍然是存放在其父类 AbstractStringBuilder的 char[] value  因此，字符序列是堆中
    5. StringBuilder 的方法，没有做互斥的处理,即没有synchronized 关键字,因此在单线程的情况下使用StringBuilder 

    1. public class StringBuilder01 {
    2.     public static void main(String[] args) {
    3.         //1. StringBuilder 继承 AbstractStringBuilder 类
    4.         //2. 实现了 Serializable ,说明StringBuilder对象是可以串行化(对象可以网络传输,可以保存到文件)
    5.         //3. StringBuilder 是final类, 不能被继承
    6.         //4. StringBuilder 对象字符序列仍然是存放在其父类 AbstractStringBuilder的 char[] value  因此，字符序列是堆中
    7.         //5. StringBuilder 的方法，没有做互斥的处理,即没有synchronized 关键字,因此在单线程的情况下使用StringBuilder
    8.         StringBuilder stringBuilder = new StringBuilder();
    9.     }
    10. }

    三个String、StringBuffer 和StringBuilder的比较

    1) StringBuilder和StringBuffer非常类似，均代表可变的字符序列，而且方法也一样

    2) String:不可变字符序列，效率低,但是复用率高。（如果相同都指向常量池的）

    3) StringBuffer:可变字符序列、效率较高(增删)、线程安全

    4) StringBuilder:可变字符序列、效率最高、线程不安全

    5) String使用注意说明:

    string s="a"; //创建了-一个字符串

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

    结论:如果我们对String做大量修改，不要使用String

    效率测试

    1. public class StringVsStringBufferVsStringBuilder {
    2.     public static void main(String[] args) {
    3.  
    4.         long startTime = 0L;
    5.         long endTime = 0L;
    6.         StringBuffer buffer = new StringBuffer("");
    7.  
    8.         startTime = System.currentTimeMillis();
    9.         for (int i = 0; i < 80000; i++) {//StringBuffer 拼接 20000次
    10.             buffer.append(String.valueOf(i));
    11.         }
    12.         endTime = System.currentTimeMillis();
    13.         System.out.println("StringBuffer的执行时间：" + (endTime - startTime));
    14.  
    15.  
    16.  
    17.  
    18.  
    19.         StringBuilder builder = new StringBuilder("");
    20.         startTime = System.currentTimeMillis();
    21.         for (int i = 0; i < 80000; i++) {//StringBuilder 拼接 20000次
    22.             builder.append(String.valueOf(i));
    23.         }
    24.         endTime = System.currentTimeMillis();
    25.         System.out.println("StringBuilder的执行时间：" + (endTime - startTime));
    26.  
    27.  
    28.         String text = "";
    29.         startTime = System.currentTimeMillis();
    30.         for (int i = 0; i < 80000; i++) {//String 拼接 20000
    31.             text = text + i;
    32.         }
    33.         endTime = System.currentTimeMillis();
    34.         System.out.println("String的执行时间：" + (endTime - startTime));
    35.  
    36.     }
    37. }

    三个String、StringBuffer 和StringBuilder的使用原则

    使用的原则，结论:

    1.如果字符串存在大量的修改操作，一般使用StringBuffer或StringBuilder

    2.如果字符串存在大量的修改操作，并在单线程的情况，使用StringBuilder

    3.如果字符串存在大量的修改操作，并在多线程的情况，使用StringBuffer

    4.如果我们字符串很少修改，被多个对象引用，使用String， 比如配置信息等
     

  • 相关阅读:
    Zookeeper 中的 CAP
    jmeter使用csv进行参数化及（运行后出现乱码错误解决）
    【牛客网面试必刷TOP101】二叉树篇（二）
    C++ 中生成随机数的代码
    Python优化算法03——粒子群算法
    ELK日志分析系统
    vue 项目 前端 模拟后端接口数据（vue2,vue3）
    dubbo 支持的7种协议
    Spring Boot面试题汇总，含答案
    小程序自定义tabBar——原生
  • 原文地址：https://blog.csdn.net/qq_41891655/article/details/134084464