StringBuffer
概述
StringBuffer是一个线程安全的可变字符序列类。类似于String类的字符串缓冲区。本质上就是一个用来操作字符串的Java类。StringBuffer可以通过调用setLength和ensureCapacity方法改变对象序列的长度和容量。
StringBuffer 对象的主要操作是 append 和 insert 方法，这些方法有很多种重载的形式，用以接受任意类型的数据。每个方法都能有效地将给定的数据转换成字符串，然后将该符串的内容追加或插入到字符串缓冲区中。append 方法可以将指定的字符数据添加到缓冲区的末，而 insert 方法则在指定的字符索引区间添加新的字符。
方法实例
append
@Test
public void append() {
//append: 将指定数据添加到末尾
StringBuffer buffer = new StringBuffer();
//链式代码输出
System.out.println(buffer
.append(3) //int类型参数
.append('C') //char类型参数
.append(1.2F) //float类型参数
.append(1.2) //double类型参数
.append(1L) //long类型参数
.append(true) //boolean类型参数
.append(new char[]{'1', '2', '3'}) //char类型数组参数
.append("String") //String字符串参数
.append(new StringBuffer("123")) //Stringbuffer对象参数
//从0号索引开始，显示2个字符
.append(new char[]{'c','h','a','r'}, 0, 2)
.append("StringBuffer", 1, 3)); //截取1-3索引区间的字符
}
capacity
@Test
public void capacity() {
//capacity: 返回对象当前的容量，默认初始容量长度为16
StringBuffer buffer = new StringBuffer("StringBuffer");
int capacity = buffer.capacity();
//打印为28个长度.
System.out.println("capacity = " + capacity);
}
charAt
@Test
public void charAt() {
//charAt: 根据所引获取指定位置的字符
StringBuffer buffer = new StringBuffer("charAt");
char ch = buffer.charAt(1);
System.out.println("ch = " + ch);
}
codePointAt
@Test
public void codePointAt() {
//codePointAt: 获取指定位置字符的unicode值
StringBuffer buffer = new StringBuffer("codePointAt");
int code = buffer.codePointAt(0);
System.out.println("code = " + code);
}
codePointBefore
@Test
public void codePointBefore() {
//codePointBefore: 返回制定索引值前一位索引的unicode值
StringBuffer buffer = new StringBuffer("codePointBefore");
//获取1号索引之前也就是0号索引的值
int code = buffer.codePointBefore(1);
System.out.println("code = " + code);
}
codePointCount
@Test
public void codePointCount() {
//codePointCount: 获取指定区间的值
StringBuffer buffer = new StringBuffer("codePointCount");
//获取0-2区间索引的值
int code = buffer.codePointCount(0, 2);
System.out.println("code = " + code);
}
delete
@Test
public void delete() {
//delete: 删除指定索引区间的字符
StringBuffer buffer = new StringBuffer("delete");
//删除3-6区间的字符
StringBuffer delete = buffer.delete(3, 6);
System.out.println("delete = " + delete);
}
deleteCharAt
@Test
public void deleteCharAt() {
//deleteCharAt: 删除指定索引位置的字符
StringBuffer buffer = new StringBuffer("deleteCharAt");
StringBuffer deleteCharAt = buffer.deleteCharAt(0);
System.out.println("deleteCharAt = " + deleteCharAt);
}
ensureCapacity
@Test
public void ensureCapacity() {
//ensureCapacity: 像对象中添加容量
StringBuffer buffer = new StringBuffer("ensureCapacity");
buffer.ensureCapacity(100);
}
getChars
@Test
public void getChars() {
//getChars: 将指定索引区间的字符复制到另一个数组当中
StringBuffer buffer = new StringBuffer("getChars");
char[] chars = new char[10];
//复制0-2区间的字符到char数组中
buffer.getChars(0,2,chars,0);
System.out.println("buffer = " + buffer);
//此时打印字符为ge
System.out.println(chars);
}
indexOf
@Test
public void indexOf() {
//indexOf: 根据字符返回索引值
StringBuffer buffer = new StringBuffer("indexOf");
int indexOf = buffer.indexOf("O");
System.out.println("indexOf = " + indexOf);
//---------------------------------------
//根据字符返回索引值，从指定索引开始查找
int index = buffer.indexOf("f", 3);
System.out.println("index = " + index);
}
insert
@Test
public void insert() {
StringBuffer buffer = new StringBuffer("insert");
System.out.println(buffer
.insert(6, true) //在第6号索引插入true值
.insert(10, 'c') //在10号索引开始插入'c'字符
.insert(11,new char[]{'c','h','a','r'})//在11号索引开始插入字符数组内容
//从15号索引插入一个char数组，并指定数组内的开始索引和插入的长度
.insert(15,new char[]{'c','h','a','r'},0,4)
//从指定索引插入字符串，并指定字符串的开始索引和结束索引
.insert(19,"CharSequence",0,12)
.insert(31,1.2) //在31号索引值开始插入double类型1.2数值
.insert(34,1.3F) //在34号索引值开始插入1.3F float类型数值
.insert(37,18) //在37号索引值开始插入18 int类型数值
.insert(39,200L) //在39号索引值开始插入200L long类型数值
//在42号索引值开始插入Object类型数组
.insert(42, Arrays.toString(new Object[]{3,2,1}))
.insert(51,"String") //在51号索引值开始插入字符串类型字符
);
lastIndexOf
@Test
public void lastIndexOf() {
//优先返回最右边的字符索引值
StringBuffer buffer = new StringBuffer("lastIndexOf");
int lastIndexOf = buffer.lastIndexOf("O");
System.out.println("lastIndexOf = " + lastIndexOf);
//lastIndexOf(String str, int fromIndex): 返回最右边字符的索引值，从指定索引值开始查询
int indexOf = buffer.lastIndexOf("O", 10);
System.out.println("indexOf = " + indexOf);
}
offsetByCodePoints
@Test
public void offsetByCodePoints() {
//offsetByCodePoints: 返回指定位置的索引值
StringBuffer buffer = new StringBuffer("offsetByCodePoints");
int offsetByCodePoints = buffer.offsetByCodePoints(0, 2);
System.out.println(offsetByCodePoints);
}
replace
@Test
public void replace() {
//replace: 替换指定索引区间的字符
StringBuffer buffer = new StringBuffer("replace");
StringBuffer replace = buffer.replace(6, 7, "ies");
System.out.println("replace = " + replace);
}
reverse
@Test
public void reverse() {
//reverse: 反转字符串
StringBuffer buffer = new StringBuffer("reverse");
StringBuffer reverse = buffer.reverse();
System.out.println("reverse = " + reverse);
}
setCharAt
@Test
public void setCharAt() {
//setCharAt: 替换指定索引的字符
StringBuffer buffer = new StringBuffer("setCharAt");
buffer.setCharAt(0,'S');
System.out.println("buffer = " + buffer);
}
setLength
@Test
public void setLength() {
//setLength: 设置字符串的长度
StringBuffer buffer = new StringBuffer("setLength");
buffer.setLength(20);
System.out.println("buffer = " + buffer);
}
subSequence
@Test
public void subSequence() {
//subSequence: 获取指定索引区间的字符
StringBuffer buffer = new StringBuffer("subSequence");
CharSequence charSequence = buffer.subSequence(0, 2);
System.out.println("charSequence = " + charSequence);
}
substring
@Test
public void substring() {
//substring: 截取指定索引区间的字符
StringBuffer buffer = new StringBuffer("substring");
String substring = buffer.substring(3);
System.out.println("substring = " + substring);
//(int start, int end): 截取指定索引区间的字符，根据开始和结束的索引位置
String sub = buffer.substring(3, 4);
System.out.println("sub = " + sub);
}