StringBuilder和StringBuffer类

简介

可变字符序列，用于构造字符串对象。内部使用自动扩容的数组操作字符串数据。StringBuilder和StringBuffer使用相同的API。 StringBuilder比StringBuffer运行效率高。因为两者类似，故只介绍一种。

StringBuilder

概述：

他是java中用来表示字符序列的另一种表示形式，表示的是一个可变的字符序列。[字符序列自身发生改变]通常他被成为字符串缓冲区。它内部定义的功能基本在字符串本身上发生作用，字符串内容会发生改变

特点：

1、他是可变的字符串表示形式
2、他提供的功能是改变自身的功能

StringBuilder和String对比：

StringBuilder是一个可变的字符序列，功能是对内部类字符串进行改变

都是字符序列的体现形式但是在java中类型不一样

String是一个不可变的字符序列，功能不能改变自身的字符串内容，都是返回新的字符串对象

String为什么不可变？

​ 因为String只提供了构造方法，属性进行了私有化封装，但是没有提供setter方法所以一旦定义无法改变

构造方法

空参构造

StringBuilder()：

创建一个默认空间大小为16字符序列为空的字符串缓冲区对象

​ 默认空间：指的的缓冲区的空间大小 16

​ 字符序列：指的是缓冲区中存放的字符串的内容 0

有参构造

StringBuilder(int len)：

​ 创建一个指定空间大小为len字符序列为空的字符串缓冲区对象

StringBuilder(String s)：

​ 创建一个空间大小为16+指定字符序列长度同时字符序列为s的字符串缓冲区对象

public static void main(String[] args) {
		StringBuilder s1 = new StringBuilder();
		StringBuilder s2 = new StringBuilder(20);
		StringBuilder s3 = new StringBuilder("abc");
		
		System.out.println(s1.capacity());  //16
		System.out.println(s1.length()); //0
		
		System.out.println(s2.capacity()); //20
		System.out.println(s2.length()); //0
		 
		System.out.println(s3.capacity()); //19
		System.out.println(s3.length()); //3
}

成员方法

一、获取功能

capacity()：

获取调用字符串缓冲区对象的空间大小值

length()：

获取调用字符串缓冲区对象的字符序列的内容长度

代码示例：

public static void main(String[] args) {
		StringBuilder s1 = new StringBuilder();
		StringBuilder s2 = new StringBuilder(20);
		StringBuilder s3 = new StringBuilder("abc");
		
		System.out.println(s1.capacity());  //16
		System.out.println(s1.length()); //0
		
		System.out.println(s2.capacity()); //20
		System.out.println(s2.length()); //0
		 
		System.out.println(s3.capacity()); //19
		System.out.println(s3.length()); //3
}

二、添加功能：

append(Object o)：

把指定的参数数据追加到调用字符串缓冲区对象的字符序列的尾部

insert(int offset,Object o)：

把指定的参数数据插入到调用字符串缓冲区对象的字符序列指定的位置上【插入指定位置的前面，元素向后顺移】

代码示例：

//添加功能
public static void main(String[] args) {
		StringBuffer s4 = new StringBuffer("abc");
		System.out.println(s4);  //abc
		s4.append(123);
		System.out.println(s4);  //abc123
		s4.append("java");
		System.out.println(s4);  //abc123java
		
		s4.insert(2, "插入"); //插入指定元素前面
		System.out.println(s4);  //ab插入c123java
}
		

三、删除功能：

deleteCharAt(int index)：

删除指定索引位置的元素

delete(int starindex， int endindex)：

删除指定索引范围内的元素

注意：

1、索引含头不含尾的操作
2、最大的索引值没有要求【大于最大索引默认删除到最后】

代码示例：

public static void main(String[] args) {
		//删除指定功能
		StringBuffer s5 = new StringBuffer("abcd123");
		s5.deleteCharAt(2);
		System.out.println(s5); //abd123
		
		StringBuffer s6 = new StringBuffer("abcd123");
		s6.delete(4, 7); //开始索引，结束索引， 含头不含尾
		System.out.println(s6); //abcd
		s6.delete(2, 123); //结束索引大于字符串，将删除到字符串最后，并不会报错
		System.out.println(s6); //abcd
}

四、替换功能：

replace(int start, int end, String str)：

使用指定的内容str替换缓冲区中字符串的指定范围内的内容

注意：

1、替换的内容从左边开始替换 一次只能替换一个
2、索引还是遵循含头不含尾的原则
3、最大的索引值使用的时候没有限定【大于最大索引，默认取到最后元素】

代码示例：

public static void main(String[] args) {
		//替换功能
		StringBuffer s7 = new StringBuffer("abcd123");
		s7.replace(4, 7, "e");  //含头不含尾
		System.out.println(s7);//abcde
		StringBuffer s8 = new StringBuffer("abcd123");
		s8.replace(4, 5, "8888");
		System.out.println(s8);//abcd88882
		StringBuffer s9 = new StringBuffer("abcd123");
		s9.replace(2, 500, "5");
		System.out.println(s9);//ab5
}

五、反转功能：

reverse()：

可以把缓冲区中的字符串内容进行反转

		StringBuffer s10 = new StringBuffer("abcd123");
		s10.reverse(); 
		System.out.println(s10);//321dcba

六、转换为字符串功能：

toString()：把字符串缓冲区对象变为字符串对象

代码示例：

		StringBuffer s10 = new StringBuffer("abcd123");
		String string = s10.toString(); //将StringBuffer转换为String类型
		System.out.println(string);

String和StringBuilder相互转换:

String变为StringBuilder：

StringBuilder的构造方法、append方法、insert方法

StringBuilder变为String：

toString方法

练习一

定义一个方法，接收一个String类型的字符串，返回该字符串的反转形式
举例：接收字符串为abc，返回字符串为cba
代码示例：

public class StringBuilderTest01 {
	
	
	public static void main(String[] args) {
		
		System.out.println(reverseStr("abcd"));
	}
	
	//定义方法
	public static String reverseStr(String str) {
		//方式一
		// 创建字符串缓冲区对象
//		StringBuilder sb1 = new StringBuilder();
//		sb1.append(str);
//		//进行翻转
//		sb1.reverse();
//		//转换为String类型,并返回
//		return sb1.toString();
		
		//方式二
		//转换为字符数组
		char[] ch = str.toCharArray();
		//循环遍历并反转
		for (int i = 0, j = ch.length-1; i < j; i++,j--) {
			//定义一个第三变量，用来接收其中一个数据
			char c = ch[i];
			ch[i] = ch[j];
			ch[j] = c;
		}
		//将字符数组转换为字符串
		String str2 = new String(ch);
		//返回反转完成的字符串
		return str2;
	} 

}

练习二

定义一个方法，接收一个int[]类型的数组，返回该数组的字符串表示形式
举例：接收数组为int[] arr = {1, 2, 3}，返回的字符串为[1, 2, 3]
要求：使用StringBuilder进行拼接，提高运行效率

代码示例：

public class StringBuilderTest2 {

	public static void main(String[] args) {
		//定义一个数组
		int [] arr = {1,2,3,4,5};
		System.out.println(getArrayStr(arr));  //[1,2,3,4,5]
	}
	
	//定义方法
	public static String getArrayStr(int[] arr) {
		
		//获取数组元素之前先得到字符串
		StringBuilder sb1 = new StringBuilder("[");
		
		//然后在字符串[ 后面拼接数组的元素
		for (int i = 0; i < arr.length; i++) {
			//前面索引  元素和，
			if ( i != arr.length -1) {
				sb1.append(arr[i]).append(",");
			}else {
				//最后一个  元素和]
				sb1.append(arr[i]).append("]");
			}
			  
		}
		//转换数据类型，并返回
		return sb1.toString();
		
	}
}

String和StringBuilder作为方法参数

String ：

方法体内部对传入的字符串进行修改操作产生的效果值适用于方法体的结果，对外部的字符串不会产生改变的效果

StringBuilder ：

方法体内部对传入的字符串缓冲区进行修改操作产生的效果值适用于方法体的结果，同时对外部的字符串缓冲区内容产生改变的效果

代码示例：

public class StringBuilderDemo2 {
	public static void main(String[] args) {
		String str = "我爱学习";
		StringBuilder sb = new StringBuilder("我爱学习");
		
		//调用方法
		String str2 = StringParam(str);
		System.out.println(str); //原始值  我爱学习
		System.out.println(str2); //方法执行后的值  我爱学习java
		
		System.out.println(sb); //原始值的字符缓冲区 (我爱学习)  
		StringBuilder sb2 = StringBuilderParam(sb);
		System.out.println(sb); //执行方法体后的原始值字符缓冲区 (我爱学习java)  
		System.out.println(sb2); //方法执行后的字符缓冲区 我爱学习java
	}

	public static String StringParam(String str) {
		//对字符串进行改变
		str += "java";
		return str;
	}
	
	public static StringBuilder StringBuilderParam(StringBuilder sb) {
		//对字符缓冲区进行改变
		sb.append("java");
		return sb;
	}
}

StringBuilder和StringBuffer的对比【面试题】

StringBuffer他也是一个字符串缓冲区，也是字符序列的表现形式，和StringBuilder是一模一样的使用功能，除了类型不一样，其他的功能和使用方式是一模一样的。

区别：

出现时机不一样：

​ StringBuffer：jdk1.0出现的 比较早

​ StringBuilder：jdk1.5版本出现 比较晚

线程安全不一样：

​ StringBuffer：线程比较安全

​ StringBuilder：线程不安全的

效率不一样

​ StringBuffer：效率比较低

​ StringBuilder：效率高