【我的Java笔记】常用类_StringBuffer

StringBuffer类

注：需要输出StringBuffer则需要将StringBuffer类转换成String类型再输出

1.线程问题：

（1）线程安全----->同步----->执行效率低

（2）线程不安全----->不同步----->执行效率高

StringBuffer是关于线程安全的可变字符序列

2.注：String 和 StringBuffer的区别

（1）StringBuffer：会构造一个字符串缓冲区，从内存角度考虑，一般情况使用StringBuffer较多

（ 在单线程中使用StringBuilder代替StringBuffer，为了执行效率 ）

（2）String：一个普通的字符串，从内存角度考虑耗费空间

3.String,StringBuffer和StringBuilder的区别
   （1）String:一个不可变的字符序列,StringBuffer:和StringBuilder是可变的字符序列,在单个线程时候的时候(优先采用StringBuilder)
   从线程角度考虑:
   StringBuilder线程不安全,不同步,执行效率高!它比StringBuffer要快!
   （2）String和StringBuffer作为形式参数时，String类型作为形式参数和基本数据类型作为形式参数的效果一样!

4.StringBuffer中的构造方法：

（1）public StringBuffer ()构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符
  （2）public StringBuffer(int capacity)构造一个不带字符，但具有指定初始容量的字符串缓冲区

注：默认初始容量+当前字符串长度

例：StringBuffer sb = new StringBuffer("hello");

sb.capacity(); //结果为21
  （3）public StringBuffer(String str)
  构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。该字符串的初始容量为 16 加上字符串参数的长度。
  
  常用的功能:
  （1）public int length():获取字符串长度数
  （2）public int capacity():获取当前字符串缓冲区的容量

5.StringBuffer中的和添加有关的方法：

（1）public StringBuffer append(int/String/char/boolean/double/float....):当前这个方法追加,给缓冲中追加数据,返回字符串缓冲区本身
  （2）public StringBuffer insert(int offset,String str):在某一个位置处去插入str这个字符串,返回字符串缓冲区本身

6.StringBuffer的删除方法：

（1）public StringBuffer deleteCharAt(int index):删除指定位置处的字符,返回的是字符串缓冲区本身
  （2）public StringBuffer delete(int start,int end):删除从指定位置开始到指定位置结束的字符,返回的是字符串缓冲区本身

7.StringBuffer的反转功能：
  public StringBuffer reverse(): 将此字符串中的字符序列直接反转

例：StringBuffer sb = new StringBuffer("hello") ;
//反转功能
String result = sb.reverse().toString() ; //将StringBuffer类型转换为String类型
System.out.println("result:"+result);

8.StringBuffer的替换功能:
  public StringBuffer replace(int start, int end,String str) 从指定位置开始到指定位置结束的字符用str子字符串去替代

9.StringBuffer的截取功能:
  public String substring(int start): 从指定位置默认截取到末尾,返回值是一个新的字符串
  public String substring(int start,int end): 从指定位置开始截取到指定位置结束,包前不包后,返回一个新的字符串

10.例题：

public class Test {
	public static void main(String[] args) {
		
		String s1 = "hello" ;
		String s2 = "world" ;
		System.out.println(s1+"---"+s2);
		change(s1,s2) ;
		System.out.println(s1+"---"+s2);
		
		StringBuffer sb1 = new StringBuffer("hello") ;
		StringBuffer sb2 = new StringBuffer("world") ;
		System.out.println(sb1+"---"+sb2);//hello---world
		change(sb1,sb2);
		System.out.println(sb1+"---"+sb2);//hello---worldworld
		//缓冲区是不变
	}
	
	public static void change(StringBuffer sb1 ,StringBuffer sb2){
		sb1 = sb2 ;  //缓冲区不变"world"
		sb2.append(sb1) ;//worldworld
	}
	
	public static void change(String s1,String s2){
		s1 = s2 ;
		s2 = s1 + s2 ;
	}
}

/*
结果：

hello---world
hello---world
hello---world
hello---worldworld

*/

11.StringBuffer和数组的区别

（1）两个共同特点:都属于容器类型的变量
  （2）数组:只能存储同一种数据类型的元素,数组的长度是固定的
  例：int[] arr = {10,20,40,50,"hello"}   是错误的
  StringBuffer:字符串缓冲区,可以存储任意类型的元素,可以不断的去给缓冲区中追加(append),字符串缓冲区中:在内存始终返回的字符串

12.StringBuffer类型和String类型之间的转换

（1）String------>StringBuffer

①使用StringBuffer的构造方式:StringBuffer(String str)

例：String s= "hello";

StringBuffer sb = new StringBuffer(s);

②创建字符串缓冲区对象,使用无参构造StringBuffer(),利用append()

例：StringBuffer sb = new StringBuffer();

sb.append("world");

（2）StringBuffer------>String

①String的另一种构造方法:String(StringBuffer buffer)

例：StringBuffer sb = new StringBuffer("hello");

String s = new String(sb);

②public String toString():现在的数据类型StirngBuffer类型,需要将StringBuffer类型转换String

例：StringBuffer sb = new StringBuffer("hello");

String s = sb.toString();

课堂练习

练习一：

/*
将数组拼接成一个字符串，分别使用String和StringBuffer实现
	例：int [] arr = {1,2,3}-------->[1,2,3]
*/

public class Test{
	
	public static void main(String[] args) {
		//定义一个数组,静态初始化!
		int[] arr = {11,55,33,44,22} ;
		
		//方式1：使用String类型实现
		String result = arrayToString(arr) ;
		System.out.println("result:"+result);
		
		System.out.println("------------------------");
		//方式2:使用StringBuffer的append功能
		String result2 = arrayToString2(arr) ;
		System.out.println("result2: " + result2);
	}
	
	public static String arrayToString2(int[] arr){
		//1)创建字符串缓冲区对象
		StringBuffer sb = new StringBuffer() ;
		//sb对象追加左中括号
		sb.append("[") ;
		//遍历数组
		for(int x = 0 ; x < arr.length ; x ++){
			//判断是否是最大索引
			if(x==arr.length-1){
				//append追加
				sb.append(arr[x]);
			}else{
				sb.append(arr[x]).append(", ") ;
			}
		}
		
		sb.append("]") ;
		
		return sb.toString() ; //将StringBuffer--->String
	}
	
	/**
	 * 明确返回值类型:String
	 * 明确参数类型:int[] arr
	 */
	public static String arrayToString(int[] arr){
		
		//定义一个空字符串
		String result = "" ;
		
		//拼接左中括号
		result +="[" ;
		
		//遍历int数组
		for(int x = 0 ; x < arr.length ; x ++){
			//判断是否最大索引
			if(x==arr.length-1){
				//拼接元素以及"]"
				result += arr[x] ;
				result += "]" ;
			}else{
				result += arr[x] ;
				result += ", " ;
			}
		}
		return result ;
	}
}

练习二

/*
分别使用String和StringBuffer实现字符串的反转
*/
import java.util.Scanner;

public class Test{
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		
		System.out.println("请输入一个字符串：");
		String str = sc.nxtLine();
		
		//方式1:使用String类型进行拼接
		String result = myReverse(str) ;
		System.out.println("result:"+result);
		
		//方式2:使用StringBuffer的reverse()功能
		String result2 = myReverse2(str) ;
		System.out.println("result2:"+result2);
	}
	
	//StringBuffer的rever()方法实现
	public static String myReverse2(String s){
		//创建字符串缓冲区对象
		StringBuffer sb = new StringBuffer(s) ;
		//开始调用反转功能
		sb.reverse() ;
		//返回
		return sb.toString() ;
		
		/*
		//链式编程:
		return new StringBuffer(s).reverse().toString() ;
		*/
	}
	
	//String类型的方式进行反转
	public static String myReverse(String s){
		//定义空串
		String result = "" ;
		
		//可以字符组其转成字符数组
		char[] chs = s.toCharArray() ;
		
		//倒着遍历
		for(int x = chs.length-1 ; x >=0 ; x --){
			//空串进行拼接
			result += chs[x] ;
		}
		
		return result ;
	}
}

练习三

/*
判断一个字符串是否为对称字符，使用StringBuffer和String实现
	例如：aba，nbvbn
*/
import java.util.Scanner;

public class Test{
	public static void main(String[] args) {
		
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in) ;
		
		//录入并接收数据
		System.out.println("请您输入一个字符串:");
		String line = sc.nextLine() ;
		
		//方式1:String类型的转换功能
		boolean flag = isSame(line) ;
		System.out.println("flag:"+flag);
		
		//方式2:间接的使用StringBuffer的reverse()功能
		boolean flag2 = isSame2(line) ;
		System.out.println("flag2:"+flag2);
	}
	
	public static boolean isSame2(String s){
		//链式编程
		//new StringBuffer(s).reverse().toString()--->StirngBuffer--->String
		return new StringBuffer(s).reverse().toString().equals(s) ;
	}
	

	public static boolean isSame(String s){
		//定义一个标记:假设返回值是true
		boolean flag = true ;
		
		//需要字符串转换成字符数组
		char[] chs = s.toCharArray();
		//遍历字符数组,获取前面索引对应的字符和后面索引的字符
		for(int start = 0 ,end = chs.length -1 ; start<=end ; start++,end--){
			//判断
			if(chs[start]!= chs[end]){
				//修改标记
				flag = false ;
				break ;
			}
		}
		return flag ;
	}
}

2017.10.29