本文详细介绍了Java中的StringBuffer类，包括其构造方法、添加、删除、替换、反转、截取功能，以及与String的转换。重点讨论了StringBuffer与StringBuilder的异同，以及在参数传递中的行为。同时介绍了StringJoiner的使用。
目录
8、StringBuffer和StringBuilder的区别
1、StringBuffer类的概述
StringBuffer类概述
我们如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既耗时，又浪费空间。
而StringBuffer就可以解决这个问题
线程安全的可变字符序列
2、StringBuffer类的构造方法
StringBuffer的构造方法：
public StringBuffer(): 无参构造方法
public StringBuffer(int capacity): 指定容量的字符串缓冲区对象
public StringBuffer(String str): 指定字符串内容的字符串缓冲区对象
StringBuffer的方法：
public int capacity()：返回当前容量。 理论值
public int length():返回长度（字符数）。 实际值
public class MyTest {
public static void main(String[] args) {
// StringBuffer 就是一长度可变的字符容器，如果你有拼串的需求，可以采用字符容器来拼串。
//StringBuffer()
//构造一个其中不带字符的字符串缓冲区，初始容量为 16 个字符。
StringBuffer sbf = new StringBuffer();
int c1 = sbf.capacity();
System.out.println(c1);//16
sbf.append("aaa");
System.out.println(sbf.capacity());//获取容器的容量;16
System.out.println(sbf.length());//获取容器中字符的长度;3
//StringBuffer( int capacity)
//构造一个不带字符，但具有指定初始容量的字符串缓冲区。
StringBuffer sbf1 = new StringBuffer(100);
int c2 = sbf1.capacity();
System.out.println(c2);//100
// StringBuffer(String str)
// 构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。
StringBuffer sbf2 = new StringBuffer("aaaaaa");
int c3 = sbf2.capacity();
System.out.println(c3);//22
}
}3、StringBuffer的添加功能
StringBuffer的添加功能
public StringBuffer append(String str):
可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身
public class MyTest1 {
public static void main(String[] args) {
StringBuffer sbf = new StringBuffer();
sbf.append("hahaha");
//往容器中追加内容,返回的还是原来的容器对象。所以我就链式编程，不断的往容器中追加内容。
sbf.append(11).append('a').append(3.14).append("哈哈").append(new char[]{'a','s','d'});
//StringBuffer类重写了父类的toSting方法，把容器中的的数据转换成字符串返回。
System.out.println(sbf.toString());
}
}输出结果：
public StringBuffer insert(int offset,String str):
在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身
public class MyTest2 {
public static void main(String[] args) {
StringBuffer sbf = new StringBuffer("aaabbbccc");
sbf.insert(3,"我");
//根据指定的索引位置进行添加，返回的还是原来的那个容器，所以可以链式编程，不断的添加
sbf.insert(7,"爱").insert(11,"吃");
System.out.println(sbf);
}
}
输出结果：
4、StringBuffer的删除功能
StringBuffer的删除功能
public StringBuffer deleteCharAt(int index):
删除指定位置的字符，并返回本身
public StringBuffer delete(int start,int end):
删除从指定位置开始指定位置结束的内容，并返回本身
public class Mytest3 {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer();
sb.append("我好饿我要吃饭我好饿我要吃饭我好饿我要吃饭");
//deleteCharAt(0) 根据索引，每次删除容器中的一个字符，返回的还是容器本身
sb.deleteCharAt(0).deleteCharAt(0).deleteCharAt(0).deleteCharAt(0);
//sb.delete(0, 4); 根据起始索引，和终止索引，删除容器中一段内容，返回的还是容器本身，索引，含头不含尾
sb.delete(0, 4);
System.out.println(sb.toString());
}
}输出结果：
5、StringBuffer的替换、反转和查找功能
StringBuffer的替换功能
public StringBuffer replace(int start,int end,String str)： 从start开始到end用str替换
StringBuffer的反转功能
public StringBuffer reverse(): 字符串反转
从头查找该字符串，在容器中第一次出现的索引，如果找不到就返回-1
int indexOf (String str)
从指定索引处开始查找该字符串，第一次出现的索引，如果找不到就返回-1
int indexOf (String str,int fromIndex)
从后往前找
int lastIndexOf (String str)
int lastIndexOf (String str,int fromIndex)
public class MyTest4 {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer();
sb.append("我好饿我要吃饭我好饿我要吃饭我好饿我要吃饭");
sb.replace(0,6,"我好困我要睡觉");
System.out.println(sb);
sb.reverse();
System.out.println(sb);
sb.reverse();
int a = sb.indexOf("睡觉");
System.out.println(a);
int b = sb.indexOf("吃饭", 6);
System.out.println(b);
int c = sb.lastIndexOf("睡觉");
System.out.println(c);
}
}输出结果：
6、StringBuffer的截取功能及注意事项
StringBuffer的截取功能
public String substring(int start):
从指定位置截取到末尾
public String substring(int start,int end):
截取从指定位置开始到结束位置，包括开始位置，不包括结束位置
public class MyTest5 {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer();
sb.append("我好饿我要吃饭");
//根据起始索引和终止索引，截取容器中的一段内容，以字符串形式返回，索引含头不含尾。
String s = sb.substring(1, 3);
System.out.println(s);//好饿
}
} 注意事项：
注意:返回值类型不再是StringBuffer本身
7、StringBuffer和String的相互转换
String -- StringBuffer
a:通过构造方法
b:通过append()方法
StringBuffer -- String
a: 使用substring方法
b:通过构造方法
c:通过toString()方法
public class MyTest6 {
public static void main(String[] args) {
// String-----------------StringBuffer
String str = "abc";
//方式1
StringBuffer sbf = new StringBuffer(str);
//方式2
StringBuffer sbf1 = new StringBuffer().append(str);
//方式3
int sbf2 = new StringBuffer().indexOf(str, 0);
//StringBuffer---------------String
StringBuffer sb = new StringBuffer("abcd");
//方式1
String s = sb.toString();
//方式2
String s1 = sb.substring(0);
//方式3
/*String(StringBuffer buffer)
分配一个新的字符串，它包含字符串缓冲区参数中当前包含的字符序列*/
String s2 = new String(sb);
}
}
8、StringBuffer和StringBuilder的区别
StringBuilder的概述
通过查看API了解一下StringBuilder类
9、String和StringBuffer分别作为参数传递
形式参数问题
String作为参数传递 String虽然是引用类型,但是它是一个常量,所以在做传递的时候,完全可以将其看成基本数据类型数据进行传递，String类型属于值传递
StringBuffer作为参数传递
public class MyTest {
public static void main(String[] args) {
//参数传递：
//基本类型，作为参数传递，属于值传递，形参的改变，不影响实参。
//引用类型，作为参数产地，属于引用传递，传递的是地址值，形参的改变，会响实参。
//String类型，虽说是引用数据类型，但是他作为参数传递，属于值传递，传递的是字符串的值，形参的改变，不影响实参。
String str="哈哈";
test(str);
System.out.println(str); //2. "哈哈"
StringBuffer sb = new StringBuffer("哈哈");
test(sb);
System.out.println(sb.toString()); //4."呵呵哈哈"
}
public static void test(String s1){
s1+="呵呵";
System.out.println(s1); //1. 哈哈呵呵
}
public static void test(StringBuffer sb){
sb.append("呵呵");
sb.reverse();
System.out.println(sb.toString()); //3. "呵呵哈哈"
}
}
10、补充：StringJoiner
StringJoiner(CharSequence delimiter)
构建了一个字符容器，指定分隔符
StringJoiner(CharSequence delimiter, CharSequence prefix, CharSequence suffix)
构建了一个字符容器，指定分隔符，前缀，后缀
StringJoiner add(CharSequence newElement)
增加了一份给 CharSequence值的 StringJoiner价值的下一个元素。
int length()
返回该 StringJoiner的 String表示长度。
String toString() 把容器中的数据以字符串返回
import java.util.StringJoiner;
public class MyTest7 {
public static void main(String[] args) {
//指定分隔符
StringJoiner sj = new StringJoiner("=");
sj.add("aa").add("bb").add("cc");
System.out.println(sj);
//构建了一个字符容器，指定分隔符，前缀，后缀
StringJoiner sj2 = new StringJoiner(",", "[", "]");
char[] chars = {'a', 'b', 'c', 'd'};
for (int i = 0; i < chars.length; i++) {
sj2.add(String.valueOf(chars[i]));
}
System.out.println(sj2);
}
}输出结果：
扫一扫
810
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
