Hi i,m JinXiang
? 前言 ?
本篇文章主要介绍在Java中String，Stringbuffer，StringBuilder的区别以及部分理论知识
🍉欢迎点赞 👍 收藏 ?留言评论 📝私信必回哟😁
🍉博主收将持续更新学习记录获，友友们有任何问题可以在评论区留言
目录
?String、Stringbuffer和StringBuilder的区别
在Java中，String是一个类，用于表示字符串。它是Java中的一个内置类，不需要额外导入就可以使用。String类是不可变的，一旦创建了一个String对象，就无法修改它的值。这意味着每次对字符串进行操作时，实际上是创建了一个新的String对象来存储修改后的字符串。
String类提供了很多方法来操作和处理字符串，例如，比较字符串、拼接字符串、截取子串等。通过这些方法，我们可以对字符串进行各种常见的操作，如查找子串、替换字符、转换大小写等。
在Java中，我们可以使用双引号（" "）来创建一个String对象，例如：
String str = "Hello world!";也可以使用String关键字来声明一个字符串变量，然后使用new关键字来创建一个String对象，例如：
String str = new String("Hello world!");双引号（“”）和String关键字来声明都可以使用String类提供的方法来操作和处理字符串
1、String表示字符串类型，属于?引用数据类型，不属于基本数据类型。
2、在java中随便使用?双引号括起来?的都是String对象。
例如：“abc”，“def”，“hello world!”，这是3个String对象。
3、java中规定，双引号括起来的字符串，是 不可变 的，也就是说"abc"自出生到最终死亡，不可变，不能变成"abcd"，也不能变成"ab"
public class String_Test {
public static void main(String[] args) {
// 这两行代码表示创建了3个字符串对象，都在字符串常量池当中。
String str1 = "abcdef";
String str2 = "abcdef" + "xy";
// 分析：这是使用new的方式创建的字符串对象。这个代码中的"xy"是从哪里来的？
// 凡是双引号括起来的都在字符串常量池中有一份。
// new对象的时候一定在堆内存当中开辟空间。
String str3 = new String("xy");
}
}
String类代表字符串，?Java程序中的所有字符串文字（例如"abc" ）都被实现为此类的实例。
字符串不变; 它们的值在创建后不能被更改。 字符串缓冲区支持可变字符串。 因为String对象是不可变的，它们可以被共享
以下是String的相关构造方法：
| 构造方法名 | 描述 |
| String（） | 初始化新创建的 String对象，使其表示空字符序列 |
String(byte[]?bytes) | 通过使用平台的默认字符集解码指定的字节数组来构造新的 String |
String(byte[]?bytes,? ? ?Charset?charset) | 构造一个新的String由指定用指定的字节的数组解码charset? |
String(byte[]?bytes, int?offset, int?length) | 通过使用平台的默认字符集解码指定的字节子阵列来构造新的 String? |
String(byte[]?bytes, int?offset, int?length, Charset?charset) | 构造一个新的String通过使用指定的指定字节子阵列解码charset? |
String(byte[]?bytes, int?offset, int?length, String?charsetName) | 构造一个新的 String通过使用指定的字符集解码指定的字节子阵列 |
String(byte[]?bytes,String?charsetName) | 构造一个新的String由指定用指定的字节的数组解码charset? |
String(char[] value) | 分配一个新的 String ，以便它表示当前包含在字符数组参数中的字符序列 |
String(int[]?codePoints, int?offset, int?count) | 分配一个新的 String ，其中包含 Unicode code point数组参数的子阵列中的 字符? |
StringBuffer是Java中的一个可变字符串类，它和String类类似，但是可以修改和操作其内部的字符序列。StringBuffer是一个线程安全的类，适用于多线程环境下的字符串操作。
和String类不同，StringBuffer的字符序列是可变的，可以通过调用StringBuffer的方法来修改其内容，比如追加新的字符、插入字符、删除字符等。由于StringBuffer是可变的，所以在进行多次字符串连接和修改时，使用StringBuffer比直接使用String效率要高。
StringBuffer类提供了很多方法来操作和处理字符串，例如，追加字符串、插入字符串、删除字符串、替换字符串等。通过这些方法，可以在字符串中进行各种操作。
每个字符串缓冲区都有一个容量。 只要字符串缓冲区中包含的字符序列的长度不超过容量，就不必分配新的内部缓冲区数组。 如果内部缓冲区溢出，则会自动变大。
在Java中，我们可以使用new关键字来创建一个StringBuffer对象，然后调用它的方法来修改和操作字符串，例如：
StringBuffer stringbuffer = new StringBuffer();
stringbuffer.append("Hello");
stringbuffer.append(" world!");通过调用append方法，我们可以将不同的字符串追加到StringBuffer的字符序列中。
需要注意的是，由于StringBuffer是线程安全的，所以在单线程环境下，如果只需要修改和操作字符串，建议使用StringBuilder类，因为StringBuilder的性能更高。只有在多线程环境下，才需要使用StringBuffer来保证线程安全性。线程详解：Java 线程（什么是线程？为什么要使用线程？使用线程的好处和优势优点）-CSDN博客
1、StringBuffer是一个可变序列。
2、线程不安全，存在同步操作同一数据的行为，效率高。安全的时候，没有同步操作，效率低。
3、StringBuffer又被称为字符缓冲区，把它当成一个字符串去操作，只不过它与string相比是可以修改内容的。
package com.one;
public class StringDemo {
public static void main(String[] args) {
//public StringBuffer() 构造一个没有字符的字符串缓冲区，初始容量为16个字符。
StringBuffer sb1 = new StringBuffer();
System.out.println("sb1:" + sb1); //StringBuffer重写了toString方法
//如何获取StringBuffer的容量
//public int capacity()返回当前容量。
System.out.println("当前StringBuffer的容量为：" + sb1.capacity());
//public int length()返回长度（字符数）。
System.out.println("StringBuffer中字符串的长度为：" + sb1.length());
System.out.println("===================================================");
//public StringBuffer(int capacity) 构造一个没有字符的字符串缓冲区和指定的初始容量。
StringBuffer sb2 = new StringBuffer(50);
System.out.println("sb2:" + sb2); //StringBuffer重写了toString方法
//如何获取StringBuffer的容量
//public int capacity()返回当前容量。
System.out.println("当前StringBuffer的容量为：" + sb2.capacity());
//public int length()返回长度（字符数）。
System.out.println("StringBuffer中字符串的长度为：" + sb2.length());
System.out.println("===================================================");
//public StringBuffer(String str) 构造一个初始化为指定字符串内容的字符串缓冲区。
StringBuffer sb3 = new StringBuffer("hello");
System.out.println("sb3:" + sb3); //StringBuffer重写了toString方法
//如何获取StringBuffer的容量
//public int capacity()返回当前容量。
System.out.println("当前StringBuffer的容量为：" + sb3.capacity()); // 21 = 16 + 5
//public int length()返回长度（字符数）。
System.out.println("StringBuffer中字符串的长度为：" + sb3.length()); // 5
}
}线程安全，可变的字符序列。 字符串缓冲区就像一个String ，但可以修改。 在任何时间点，它包含一些特定的字符序列，但可以通过某些方法调用来更改序列的长度和内容。
字符串缓冲区可以安全地被多个线程使用。 这些方法在必要时进行同步，以便任何特定实例上的所有操作都按照与所涉及的各个线程所执行的方法调用顺序一致的顺序发生。
以下是Stringbuffer的相关构造方法：
| 构造方法 | 描述 |
StringBuffer | append(double?d) 将 |
StringBuffer | append(String?str) 将指定的字符串附加到此字符序列。 |
StringBuffer | deleteCharAt(int?index) 删除 |
int | indexOf(String?str, int?fromIndex) 返回指定子串的第一次出现的字符串中的索引，从指定的索引开始。 |
StringBuffer | insert(int?offset, boolean?b) 在此序列中插入 |
StringBuffer | insert(int?index, char[]?str, int?offset, int?len) 在此序列中插入 |
StringBuffer | insert(int?offset, double?d) 在此序列中插入 |
int | lastIndexOf(String?str, int?fromIndex) 返回指定子字符串最后一次出现的字符串中的索引。 |
int | length() 返回长度（字符数） |
StringBuffer | replace(int?start, int?end, String?str) 用指定的String中的字符替换此序列的子字符串中的 |
StringBuffer | reverse() 导致该字符序列被序列的相反代替。 |
void | setCharAt(int?index, char?ch) 指定索引处的字符设置为 |
void | setLength(int?newLength) 设置字符序列的长度。 |
CharSequence | subSequence(int?start, int?end) 返回一个新的字符序列，该序列是该序列的子序列。 |
StringBuilder是Java中的一个可变字符串类，它和StringBuffer类功能相似，都可以对字符串进行修改和操作。StringBuilder也是用来处理可变字符串的，但与StringBuffer不同的是，StringBuilder是非线程安全的类。
和String类不同，StringBuilder的字符序列是可变的，可以通过调用StringBuilder的方法来修改其内容，比如追加新的字符、插入字符、删除字符等。由于StringBuilder是可变的，所以在进行多次字符串连接和修改时，使用StringBuilder比直接使用String效率更高。
StringBuilder类提供了很多方法来操作和处理字符串，例如，追加字符串、插入字符串、删除字符串、替换字符串等。通过这些方法，可以在字符串中进行各种操作。
在Java中，我们可以使用new关键字来创建一个StringBuilder对象，然后调用它的方法来修改和操作字符串，例如：
StringBuilder stringbuilder = new StringBuilder();
stringbuilder.append("Hello");
stringbuilder.append(" world!");通过调用append方法，我们可以将不同的字符串追加到StringBuilder的字符序列中。
需要注意的是，由于StringBuilder是非线程安全的，所以在多线程环境下，应该使用StringBuffer类来保证线程安全性。只有在单线程环境下，才需要使用StringBuilder来提高性能。
首先我们使用StringBuilder()来创建一个空白可变字符串对象，不含有任何内容。
StringBuilder s1 = new StringBuilder();
System.out.println("s1:" + s1);接下来我们使用StringBuiler(String str)根据字符串内容，来创建可变字符串对象。
StringBuilder s2 = new StringBuilder("Hello World");
System.out.println("s2:" + s2);最后我们会发现结果为：
sb1:
sb2:Hello World
由于第一个没有给定任何内容，所以控制台的输出为空白。而第二个给定内容为Hello World，所以控制台输出为Hello World。
String转换为StringBuilder
public StringBuilder(String s)：通过构造方法就可以实现把String转换为StringBuilder
StringBuilder转换为String
StringBuilder sb = new StringBuilder();
//添加数据
sb.append("Hello");
//StringBuilder转换为String
String a = sb.toString();
System.out.println(a);
String转换为StringBuilder
String s = "Hello";
StringBuilder sb = new StringBuilder(s);
System.out.println(sb);StringBuilder是一个可变的字符串类，我们可以把它看成是一个容器。
这里的可变指的是 StringBuilder对象中的内容是可变的。
以下是Stringbuffer的相关构造方法：
| 构造方法 | 描述 |
StringBuilder | append(char[]?str) 将 |
StringBuilder | append(char[]?str, int?offset, int?len) 将 |
int | capacity() 返回当前容量。 |
StringBuilder | delete(int?start, int?end) 删除此序列的子字符串中的字符。 |
StringBuilder | deleteCharAt(int?index) 删除 |
StringBuilder | insert(int?offset, char?c) 在此序列中插入 |
StringBuilder | insert(int?offset, char[]?str) 在此序列中插入 |
void | setLength(int?newLength) 设置字符序列的长度。 |
String | toString() 返回表示此顺序中的数据的字符串。 |
void | trimToSize() 尝试减少用于字符序列的存储。 |
String、StringBuffer和StringBuilder都是Java中用于处理字符串的类
它们之间的主要区别如下：
1、可变性：String类是不可变的，即一旦创建了一个String对象，就不能修改它的值。而StringBuffer和StringBuilder是可变的，可以对其内容进行修改和操作。
2、线程安全性：String是线程安全的，即多个线程可以同时访问和操作一个String对象而不会出现线程安全问题。而StringBuffer是线程安全的，多个线程可以共享一个StringBuffer对象而不会出现数据混乱。而StringBuilder是非线程安全的，不同的线程同时访问和操作一个StringBuilder对象可能会出现数据混乱。
3、性能：由于String是不可变的，每次对String进行修改都会创建一个新的String对象，这会产生大量的临时对象，降低性能。而StringBuffer和StringBuilder是可变的，对其进行修改不会创建新的对象，可以提高性能。StringBuilder比StringBuffer的性能更高，因为StringBuffer为了保证线程安全性使用了同步锁，而StringBuilder没有。
综上所述，如果需要处理不可变的字符串或在多线程环境下操作字符串时，应使用String类或StringBuffer类。如果在单线程环境下需要频繁修改和操作字符串时，应使用StringBuilder类以获得更好的性能。
总结不易，希望宝宝们不要吝啬亲爱的👍哟(＾Ｕ＾)ノ~ＹＯ！如有问题，欢迎评论区批评指正😁