StringBuffer类介绍和溯源

StringBuffer类常用构造器和常用方法

StringBuffer类 VS String类（重要）

二者的本质区别（含内存图解）

二者的相互转化

StringBuilder类介绍和溯源

StringBuilder类常用构造器和常用方法

String类，StringBuffer类，StringBuilder类总结

一、前言

本节内容是我们《API-常用类》专题的第三小节了。本节内容主要讲StringBuffer类和StringBuilder类，内容包括但不限于 StringBuffer介绍和溯源， StringBuffer类构造器和常用方法， StringBuffer类和String类的比较及相互转化，以及 StringBuilder类和StringBuffer类的比较等等。up希望通过这篇博文的知识分享，能够帮助大家快速上手并理解java StringBuffer类和StringBuilder类。注意 : ① 代码中的注释也很重要； ② 不要眼高手低，自己敲一遍才能知道怎么用。 ③ 点击侧边栏目录或者文章开头的目录可以跳转。良工不示人以朴，所有文章都会适时改进。大家如果有什么问题，都可以在评论区一块儿交流，或者私信up。感谢阅读！

二、StringBuffer类介绍和溯源

1.介绍 :

在上一小节的String类中，我们提到，每个字符串对象都是常量。当我们创建一个字符串对象，并试图对其内容进行“增”，“删”，或者“改”的操作时，实际上原来的字符串对象已经丢弃了。jvm会重新创建一个字符串对象，并令其指向常量池中新的数据空间。所以，如果多次进行这些“增删改”的操作，会导致大量副本字符串对象遗留在内存中，降低效率。那我们如何解决这个问题？这边要引出我们的StringBuffer类和StringBuilder类。

StringBuffer类，指可变字符序列，用于构造字符串对象。其内部使用自动扩容的数组来操作字符串数据。StringBuffer类属于java.base模块，java.lang包下，如下图所示 :

2.溯源 :

我们先来看看StringBuffer类的源码，试试能不能从中找出一些蛛丝马迹。如下 :

可以看到，同String类一样，StringBuffer类也用了final关键字修饰，因此，StringBuffer类也不可被继承。我们再来看一下StringBuffer类的类图，如下 :

可以看到，StringBuffer类并没有像String类一样直接继承了Object类，而是直接继承自AbstractStringBuilder类。但它也像String类一样实现了多个接口，其中Serializable接口的实现使得StringBuffer类的对象可以串行化。串行化后对象可以进行网络传输，也可以保存到文件。

但是，这时候可能就要有p小将（Personable小将，指风度翩翩的人）出来bb问了：你丫的，之前在String类的源码中，可以明明白白地看到“private final byte[] value”属性，并且源码中给出了注释——字符串在底层就是用这个字节数组来存储的。那你这StringBuffer类也没有见数组啥的属性，你上哪儿存储捏？

不愧是p小将，6。是的，与String类一个较大的不同点在于，StringBuffer类本身并没有用来存储字符串的容器。不急，刚刚在类图中我们也看见了，StringBuffer类直接继承自AbstractStringBuilder类，java这么牛逼的语言，不会让你凭空去继承这么一个类的。来看看父类的源码，如下 :

一看父类源码咱就懂了。唉哟，藏的还挺深儿滴。没错，父类AbstractStringBuilder源码中有byte[] value属性，并且源码中也明确给出了注释“The value is used for character storage.”，但与String类不同的是，该数组无final修饰! 因此，字符串实际存放的位置是在堆内存中。这也从根本上解释了为什么StringBuffer是可变字符序列。

当然，我们也可以通过Debug找到更令人信服的证据，如下图所示 :

AbstractStringBuilder类中的byte[] value只是定义了一个字节数组，数组属于引用类型，默认指向为空（即null），但是当我们通过构造器来创建一个非空的StringBuffer类对象时，很明显在底层有一个”new“的操作。在java面向对象专题我们说过，new出来的对象都在堆内存中。

不止于此，如果我们是先构造一个空的StringBuffer类对象，再利用append方法向容器中添加字符串时，我们仍然可以通过Debug在底层源码中找到一个”new“的操作，如下图所示 :

大家有兴趣可以自己下来去Debug一下。诚然，底层很多东西我们现在都没法搞懂，我们还需要经历很长的学习之路。但是，只要你能大致的看懂源码，明白它是干什么的，你就能对外面显式的一些功能理解地更深，更透彻。因此，Debug这时候便显得越来越关键。（PS : 大家有兴趣可以去看看up 的Debug入门教学）

三、StringBuffer类常用构造器

1.StringBuffer()

构造一个不带字符的字符串缓冲区，其初始容量为16个字符。（这里提一嘴，“buffer”本身就是缓冲区，缓冲器，缓冲物“的意思。）

2.StringBuffer(int capacity)

构造一个不带字符，但具有指定初始容量的字符串缓冲区。即可对byte[] value的大小进行指定。

3.StringBuffer(String str)

构造一个字符串缓冲区，并将其内容初始化为指定字符串的内容。

4.演示

up以Constructor_类为演示类，代码如下 :

package csdn.knowledge.api.builder_buffer;

public class Constructor_ {
    public static void main(String[] args) {
    //演示 : 演示StringBuffer类的常用构造器
        //1.StringBuffer()
        StringBuffer stringBuffer_0 = new StringBuffer();
        System.out.println(stringBuffer_0.length());
        System.out.println(stringBuffer_0);
        System.out.println("----------");

        //2.StringBuffer(int capacity)
        StringBuffer stringBuffer_1 = new StringBuffer(141);
        System.out.println(stringBuffer_1.length());
        System.out.println(stringBuffer_1);
        System.out.println("----------");

        //3.StringBuffer(String str)
        StringBuffer stringBuffer_2 = new StringBuffer("CSDN yyds!");
        System.out.println(stringBuffer_2.length());
        System.out.println(stringBuffer_2);
    }
}

运行结果 :

5.Debug

诚然，光看上面那破代码和一张糊弄人的输出结果出，我们无法直观看出三个构造器的区别，接下来up就以上面的代码为例，在第7行下一个断点，给大家把每个构造器的执行流程都Debug一下。注意：想想上面对每个构造器性质的描述，你应该知道你想在Debug过程中看到什么。

①第一个构造器Debug演示，GIF图如下 :

②第二个构造器Debug演示，GIF图如下 :

③第三个构造器Debug演示，GIF图如下 :

四、StringBuffer VS String类（重要)

1.StringBuffer类与String类的比较 :

①String类保存的是字符串常量，无法直接更改字符串本身的值。String类的每次更新实际上就是更改引用指向的地址，效率较低。

up给大家画了一张String类的内存图解，我们以下面代码为例 :

//仅作演示用，无实际意义
public static void main(String[] args) {
    String str_0 = new String("CSDN yyds");
    str_0 = new String("666");
    str_0 = "Cyan";
}

内存图解如下 :

②StringBuffer保存的是字符串变量，可以直接更改字符串本身的值。因为字符串变量在堆内存中，StringBuffer的每次更新实际上可以直接更新字符串的内容，不用每次更新地址，效率较高。只有在某些特殊情况下，比如说该数组预存的空间不足，需要扩容时，才创建新的对象。

up给大家画了一张StringBuffer类的内存图解，我们以下面代码为例 :

//仅作演示用，无实际意义
public static void main(String[] args) {
    StringBuffer sf = new StringBuffer("csdnNB");
}

内存图解如下 :

2.StringBuffer类与String类的相互转化 :

①String ——> StringBuffer

方式一：

利用上面的第三个构造器——StringBuffer(String str)

eg :

StringBuffer stringBuffer_0 = new StringBuffer("CSDN yyds");

方式二：

利用上面的第一个构造器——StringBuffer()，再利用append方法向容器中添加字符(串）。

eg :

StringBuffer stringBuffer_1 = new StringBuffer();

stringBuffer_1.append("Cyan_RA9");

Δ演示 :

up以Exchange_0类为演示类，代码如下 :

package csdn.knowledge.api.builder_buffer;

public class Exchange_0 {
    public static void main(String[] args) {
    //演示 : String ——> StringBuffer
        //方式一 : 
        StringBuffer stringBuffer_0 = new StringBuffer("CSDN yyds!");
        System.out.println(stringBuffer_0);
        //方式二 :
        StringBuffer stringBuffer_1 = new StringBuffer();
        stringBuffer_1.append("Cyan_RA9");
        System.out.println(stringBuffer_1);
    }
}

运行结果 :

②StringBuffer ——> String

方式一：

利用StringBuffer类提供的toString方法。

eg :

StringBuffer stringBuffer_0 = new StringBuffer("CSDN yyds");

String str_0 = stringBuffer.toString();

方式二：

利用String类提供的构造器，在形参列表中直接传入一个StringBuffer类对象。

eg :

StringBuffer stringBuffer_1 = new StringBuffer();

String str_1 = new String(stringBuffer_1);

Δ演示 :

up以Exchange_1类为演示类，代码如下 :

package csdn.knowledge.api.builder_buffer;

public class Exchange_1 {
    public static void main(String[] args) {
    //演示 : StringBuffer ——> String
        //方式一 :
        StringBuffer stringBuffer = new StringBuffer("感谢大家阅读！");
        String str_0 = stringBuffer.toString();
        System.out.println(str_0);
        //方式二 :
        String str_1 = new String(stringBuffer);
        System.out.println(str_1);
    }
}

运行结果 :

五、StringBuffer类常用方法

0.前言

我们可以先在IDEA的类图中查看一下StringBuffer类中的方法，看看是个什么情况。如下GIF图所示 :

可以看到，光StringBuffer类中的方法就是巨**多了，而且旁边它爹的方法看着更多。因此，还是老规矩，up就把一些比较常见的，常用的方法比如说crud（增删改查）给大家分享出来，并给大家演示一下就好了。

1.int length()

该方法可以获取到当前StringBuffer容器中字符串的有效长度。

2.int capacity()

该方法可以返回当前容器的容量。

3.StringBuffer append(...)

该方法可以将传入的形参对应的字符串形式加入到当前容器中。（返回值为StringBuffer类型，可不做接收。）

4.StringBuffer delete(int start, int end)

该方法可以删除当前容器中指定序列部分的内容。传入的两个形参代表了删除的区间——[start, end)，仍然是熟悉的前闭后开。（返回值为StringBuffer类型，可不做接收。）

5.StringBuffer replace(int start, int end, String str)

该方法可以将当前容器中指向序列部分的字符串替换为传入的str字符串。前两个形参的作用同delete方法的形参。最后一个形参代表你想最终替换成的字符串。（返回值为StringBuffer类型，可不做接收。）

6.StringBuffer reverse()

该方法可以将当前容器中的字符串反转顺序后再返回。（返回值为StringBuffer类型，可不做接收。）

7.StringBuffer insert(int offset, String str)

该方法可以在当前容器中字符串的指定索引处插入一段字符串，原字符串中的内容从该索引处自动后移。（返回值为StringBuffer类型，可不做接收。）

8.演示

up以Method_类为例，代码如下 :

package csdn.knowledge.api.builder_buffer;

public class Method_ {
    public static void main(String[] args) {
    //演示 : StringBuffer类常用方法
        //1 —— int length()
        StringBuffer strBuffer_0 = new StringBuffer("CSDN yyds!");
        System.out.println("当前字符串 = " + strBuffer_0);
        System.out.println("当前容器中字符串的有效长度为：" + strBuffer_0.length());
        System.out.println("============================================");

        //2 —— int capacity()
        StringBuffer strBuffer_1 = new StringBuffer(141);
        System.out.println("当前容器的容量是：" + strBuffer_1.capacity());
        System.out.println("============================================");

        //3 —— StringBuffer append(...)
        StringBuffer strBuffer_2 = new StringBuffer("大家好，");
        strBuffer_2.append("我是练习时长两年半的java博主——");
        strBuffer_2.append("Cyan_RA9——");
        strBuffer_2.append(6666);
        strBuffer_2.append(2333.333333);
        System.out.println("strBuffer_2容器中字符串的内容 = " + strBuffer_2);
        System.out.println("============================================");

        //4 —— StringBuffer delete(int start, int end)
        StringBuffer strBuffer_3 = new StringBuffer("小米，小红，小兰，小黑");
        System.out.println("当前字符串 = " + strBuffer_3);
        strBuffer_3.delete(0, 3);
        System.out.println("删去索引为[0, 3)的字符串后，现在的字符串 = " + strBuffer_3);
        System.out.println("============================================");

        //5 —— StringBuffer replace(int start, int end, String str)
        StringBuffer strBuffer_4 = new StringBuffer("大白 大黄 大哥 大狗");
        System.out.println("当前字符串 = " + strBuffer_4);
        strBuffer_4.replace(9, 11, "大猫");
        System.out.println("将\"大狗\"替换成\"大猫\"后，现在的字符串 = " + strBuffer_4);
        System.out.println("============================================");

        //6 —— StringBuffer reverse()
        StringBuffer strBuffer_5 = new StringBuffer("123456789");
        System.out.println("当前字符串 = " + strBuffer_5);
        strBuffer_5.reverse();
        System.out.println("颠倒字符串的顺序后，现在的字符串 = " + strBuffer_5);
        System.out.println("============================================");

        //7 —— StringBuffer insert(int offset, String str)
        StringBuffer strBuffer_6 = new StringBuffer("我叫，喜欢吃水果");
        System.out.println("当前字符串 = " + strBuffer_6);
        strBuffer_6.insert(2, "Cyan_RA9");
        System.out.println("在索引为2处插入一段字符串后，现在的字符串 = " + strBuffer_6);
    }
}

运行结果 :

六、StringBuilder介绍和溯源

1.介绍

同StringBuffer一样，StringBuilder类也是一个可变的字符序列。StringBuilder类提供与StringBuffer类兼容的API，因此两者在使用功能上非常相似，但是StringBuilder类不保证同步，因此StringBuilder类不是线程安全的。

StringBuilder类被设计用作StringBuffer类的一个简易替换，用在字符缓冲区被单个线程使用的时候。但在实际开发中，由于StringBuilder类效率比StringBuffer类还要高。因此，建议在满足单线程的基础上，优先使用StringBuilder类。

StringBuilder类也属于java.base模块，java.lang包下，如下图所示 :

2.溯源

我们先来看看StringBuilder类的源码，看看有什么线索，如下所示 :

可以看到，StringBuilder类也被final关键字修饰，因此StringBuilder类不可被继承。我们再来看看StringBuilder类的类图，如下 :

大家可以通过侧边栏跳转回StringBuffer类的类图看看，up表示，不能说一模一样，但至少是完全相同😋。很明显，这俩是难兄难弟。同样的，StringBuilder类也实现了Serializable接口，使得StringBuilder类对象串行化，串行化后，对象可以进行网络传输，也可以保存到文件。同样的，StringBuilder类也继承了AbstractStringBuilder类，那自然也是在AbstractStringBuilder类中的byte[] value中来保存字符串的。

七、StringBuilder类常用构造器

1.StringBuilder()

构造一个不带字符的字符串缓冲区，其初始容量为16个字符。

2.StringBuilder(int capacity)

构造一个不带字符，但具有指定初始容量的字符串缓冲区。即可对byte[] value的大小进行指定。

3.StringBuilder(String str)

构造一个字符串缓冲区，并将其内容初始化为指定字符串的内容。

4.演示

up以Constructor_EX类为演示类，代码如下 :

package csdn.knowledge.api.builder_buffer.builder;

public class Constructor_EX {
    public static void main(String[] args) {
    //演示 : StringBuilder类常用构造器
        //1 —— StringBuilder()
        StringBuilder sb_0 = new StringBuilder();
        System.out.println("当前sb_0容器的容量 = " + sb_0.capacity());
        System.out.println("当前sb_0容器内字符串的有效长度 = " + sb_0.length());
        System.out.println("---------------------");
        
        //2 —— StringBuilder(int capacity)
        StringBuilder sb_1 = new StringBuilder(141);
        System.out.println("当前sb_1容器的容量 = " + sb_1.capacity());
        System.out.println("当前sb_1容器内字符串的有效长度 = " + sb_1.length());
        System.out.println("---------------------");
        
        //3 —— StringBuilder(String str)
        StringBuilder sb_2 = new StringBuilder("CSDN yyds!");
        System.out.println("当前sb_2容器的容量 = " + sb_2.capacity());
        System.out.println("当前sb_2容器内字符串的有效长度 = " + sb_2.length());
    }
}

运行结果 :

八、StringBuilder类常用方法

0.前言

由于StringBuilder类使用和StringBuffer类兼容的API，因此，这两者的常用方法基本相同。至少上文中StringBuffer类的7个常用方法均可以在StringBuilder类的API文档中查找到。而且，有些眼尖的小伙伴儿刚刚可能已经发现了，StringBuilder的三个常用构造器与StringBuffer类的如出一辙。这也是up为什么没有再给出StringBuilder类构造器的Debug测试。因为就算你Debug一下，也会发现它们底层其实都一样。有兴趣的小伙伴儿们可以自己下去Debug一下。

因为两者的常用方法都一样，基本上就换了个名字，因此up也不全演示一遍了，就挑几个典型的给大家演示一下，过过眼就行，防止影响大家阅读体验。（绝b不是因为我懒！）

1.演示 :

up以Method_EX为演示类，代码如下 :

package csdn.knowledge.api.builder_buffer.builder;

public class Method_EX {
    public static void main(String[] args) {
    //演示 : StringBuilder类常用方法
        StringBuilder sb = new StringBuilder("12345");
        System.out.println("当前字符串 = " + sb);

        sb.reverse();
        System.out.println("颠倒后的字符串 = " + sb);

        sb.append(123);
        sb.append("哈哈哈");
        sb.append(666.666);
        sb.append("牛逼！");
        System.out.println("增加后的字符串 = " + sb);

        sb.delete(0, sb.length());
        System.out.println("全部删光光！当前字符串 = " + sb);
    }
}

运行结果 :

九、String类，StringBuffer类，StringBuilder类总比较

①String : 不可变字符序列，效率低，但是复用率高。
②StringBuffer : 可变字符序列，效率较高，且线程安全。
③StringBuilder : 可变字符序列，效率最高，且线程不安全。

①String : 使用于字符串很少修改，被多个对象引用的情况，比如定义数据库的IP，配置信息等。
②StringBuffer : 适用于存在大量修改字符串的情况，且满足多线程条件。
③StringBuilder : 适用于存在大量修改字符串的情况，且满足单线程条件。

十、总结

🆗，以上就是关于StringBuffer类和StringBuilder类的全部内容了。希望这篇博文的内容分享，可以帮助大家对这对难兄难弟有进一步的认识。同时，关于StringBuffer类的一些底层，up做了较为宽泛的介绍。并且，还对String类，StringBuffer类和StringBuilder类这三个作了比较。我们也再次体会到了Debug的乐趣和重要性 😆。API专题的下一小节，up准备来讲讲常用类Arrays类，我们不见不散。感谢阅读！