StringBuffer类

最新推荐文章于 2023-08-16 11:02:04 发布

Luna_ll

最新推荐文章于 2023-08-16 11:02:04 发布

阅读量368

点赞数

分类专栏： JavaSE基础文章标签： stringbuffer

本文链接：https://blog.csdn.net/Luna_ll/article/details/78417473

版权

JavaSE基础专栏收录该内容

36 篇文章 1 订阅

订阅专栏

一.StringBuffer

1.StringBuffer:线程安全的可变字符序列。

特点：线程安全----->不同步----->执行效率高，在开发中，线程不安全会造成死锁的现象

eg:银行的网站、医院的平台

线程（相对于进程而言）后续补充！

面试题：StringBuffer和String 的区别?

StringBuffer会构造一个字符串缓冲区,从内存角度考虑,一般情况使用StringBuffer比较多(在单线程程序中使用StringBulider替代

StringBuffer:线程不安全,单线程单纯为了提供执行效率!

String:普通的一个字符串,从内存角度考虑,耗费空间!

2.StringBuffer的构造方法（三种初始化方式）：

1)public StringBuffer():构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符

2)public StringBuffer(int capacity):构造一个不带字符，但具有指定初始容量的字符串缓冲区

3)public StringBuffer(String str):构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容；该字符串的初始容量为 16 加上字符串参数的长度。

3.常用功能：

1)public int length():获取字符串长度数

2)public int capacity():获取当前字符串缓冲区的容量

package day_11_10_29.stringbuffer;

public class StringBufferDemo {

	public static void main(String[] args) {
		/**
		 * 1.public StringBuffer():构造一个其中不带字符的字符串缓冲区，其初始容量为 16个字符
		 * 2.public int length():获取字符串长度数
		 * 3.public int capacity():获取当前字符串缓冲区的容量
		 * */
		StringBuffer sb = new StringBuffer();
		System.out.println("sb.length:"+sb.length());	//0
		System.out.println("sb.capacity:"+sb.capacity());//16
		System.out.println("----------------------------");
		
		/**
		 * 4.public StringBuffer(int capacity):构造一个不带字符，但具有指定初始容量的字符串缓冲区
		 * */
		StringBuffer sb2 = new StringBuffer(50);
		System.out.println("sb2.length:"+sb2.length());	//0
		System.out.println("sb2.capacity:"+sb2.capacity());//50
		System.out.println("----------------------------");
		
		/**
		 * 5. public StringBuffer(String str):构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容；
		 * 		该字符串的初始容量为 16 加上字符串参数的长度
		 * */
		StringBuffer sb3 = new StringBuffer("hello");
		System.out.println("sb3.length:"+sb3.length());		//5
		System.out.println("sb3.capacity:"+sb3.capacity());//16+5=21
		
		
	
	}

}

4.StringBuffer中的添加方法：

1)public StringBuffer append(int/String/char/boolean/double/float....)

功能:当前这个方法追加,给缓冲中追加数据,返回字符串缓冲区本身(经常使用的)

注意：对append说明：只是创建了一个对象(未开辟新的对象)，在原来对象的内容里添加新的内容

对print()说明：重写了Object类toString方法

StringBuffer类中toString()方法：将字符缓冲区转换成String类型

2)public StringBuffer insert(int offset,String str)

功能:在某一个位置处(索引)去插入str这个字符串,返回字符串缓冲区本身。

package day_11_10_29.stringbuffer;

public class StringBufferDemo2 {
	public static void main(String[] args) {
		// 创建一个字符串缓冲区
		StringBuffer sb = new StringBuffer();
		/**
		 *1.追加数据：public StringBuffer append(int/String/char/boolean/double/float....)
		 * */
		sb.append("hello");
		sb.append('h');
		sb.append(1);
		sb.append(true);
		sb.append(12.39F);
		sb.append(12.34);
		System.out.println(sb);
		/**
		 * 对append说明：
		 * 只是创建了一个对象(未开辟新的对象)，在原来对象的内容里添加新的内容
		 * 对print()说明：重写了Object类toString方法
		 * StringBuffer类中toString()方法
		 * 说明：将字符缓冲区转换成String类型
		 * */
		//链式编程
		//sb.append("hello").append('h').append(1).append(true).append(12.39F).append(12.34);
		/**
		 *2.public StringBuffer insert(int offset,String str)
		 * 在某一个位置处去插入str这个字符串,返回字符串缓冲区本身
		 * */
		sb.insert(5, "world");
		System.out.println("sb:"+sb);		
	}
}

5.StringBuffer的删除功能

1)public StringBuffer deleteCharAt(int index)

说明:删除指定位置处的字符,返回的是字符串缓冲区本身!

2)public StringBuffer delete(int start,int end)

说明:删除从指定位置开始到指定位置结束的字符,返回的是字符串缓冲区本身!

package day_11_10_29.stringbuffer;

public class StringBufferDemo3 {
	public static void main(String[] args) {
		// 创建字符串缓冲区对象
		StringBuffer sb = new StringBuffer();
		//给缓冲区添加数据
		sb.append("hello");
		sb.append("world");
		sb.append("java!");
		
		/*public StringBuffer deleteCharAt(int index)
		 *需求:要删除当前缓冲区中对应索引的字符
		 */
		sb.deleteCharAt(0);
		System.out.println("sb:"+sb);
		
		/*public StringBuffer delete(int start,int end)
		 *从当前索引(star)开始,到(end-1)索引结束
		 */
		sb.delete(0, 1);
		System.out.println("sb:"+sb);
	}
}

6.StringBuffer的反转功能：（重点掌握）

public StringBuffer reverse():将此字符串中的字符序列直接反转

返回值类型：StringBuffer

package day_11_10_29.stringbuffer;

import java.util.Scanner;

public class StringBufferDemo4 {
	public static void main(String[] args) {
		// 创建键盘录入对象
		Scanner sc = new Scanner(System.in);
		
		//录入并接收数据
		System.out.println("请您输入一个字符串:");
		String s = sc.nextLine();
		
		//可以创建字符串缓冲区对象
		StringBuffer sb = new StringBuffer(s);
		/*
		 * public String toString()
		 * 说明：StirngBuffer类型的toString()方法
		 * 将StringBuffer类型转换成String类型
		 */
		//StringBuffer result = sb.reverse();//.toString();
		String result = sb.reverse().toString();
		System.out.println("result:"+result);
	}
}

7.StringBuffer的替换功能：

public StringBuffer replace(int start, int end,String str)：从指定位置开始到指定位置(包前不包后)结束的字符用str子字符串去替代

package day_11_10_29.stringbuffer;

public class StringBufferDemo5 {
	public static void main(String[] args) {
		// 创建字符串缓冲区对象
		StringBuffer sb = new StringBuffer();
		//给字符串缓冲区追加数据
		sb.append("hello");
		sb.append("world");
		sb.append("java");
		sb.replace(5, 10, "你好");
		System.out.println("sb:"+sb);

	}

}

8.StringBuffer的截取 功能（得到字符串）：

1)public String substring(int start)：从指定位置默认截取到末尾,返回值是一个新的字符串

2)public String substring(int start,int end):从指定位置开始截取到指定位置结束,包前不包后,返回一个新的字符串

public class StringBufferDemo6 {
	public static void main(String[] args) {
		//创建字符串缓冲区对象
		StringBuffer sb = new StringBuffer() ;
		
		//添加
		sb.append("hello") ;
		sb.append("world") ;
		sb.append("java") ;
		
		//截取形成新的字符串(创建了一个新的对象)
		String s1 = sb.substring(1);
		System.out.println("s1:"+s1);
		
		//此时字符串缓冲区内容(可以看到上述操作并未对缓冲区内容进行操作,原因？)
		System.out.println("sb:"+sb);
		
		//截取形成新的字符串(创建了一个新的对象)
		String s2 = sb.substring(5,10) ;
		System.out.println("s2:"+s2);
		
		//此时字符串缓冲区内容(可以看到上述操作并未对缓冲区内容进行操作)
		System.out.println("sb:"+sb);
	}

}

面试题: String,StringBuffer,StringBuilder的区别?

从可变性：String:一个不可变的字符序列，StringBuffer和StringBuilder是可变的字符序列,在单个线程时候的时候(优先采用StringBuilder)

从线程角度考虑:StringBuilder线程不安全,不同步,执行效率高!它比StringBuffer要快!

package day_11_10_29.stringbuffer;

public class StringBufferDemo7 {

	public static void main(String[] args) {
		// 定义两个字符串
		String s1 = "hello";
		String s2 = "world";
		System.out.println(s1+"---"+s2);	//hello---world
		change(s1,s2);	//自己定义方法
		System.out.println(s1+"---"+s2);	//hello---world
		System.out.println("---------------------");
		
		//定义两个字符串缓冲区对象
		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"
		/**
		 * 形参其实是与实参指向同一个对象的不同引用(堆和方法(形参)区);
		 * 在方法区也有一个sb1和sb2，将对象(引用)分别赋给sb1,sb2；
		 * 此时将sb2指向sb1，此时理解为(方法区)这两个引用指向同一个对象("world");
		 * 此时再sb2.append(sb1);就是在sb2的缓冲区内继续添加内容，sb1不变
		 * */	
		sb2.append(sb1);	//worldworld
	}
	public static void change(String s1,String s2){
		s1 = s2;
		s2 = s1 + s2;
	}
}

8.类与类之间的转换 ：

A类型--->B类型

这里面可能最终使用B类型里面的功能
B类型--->A类型

有时候需要的不是B类型,所以又要将B类型-->A类型

StringBuffer--->String之间的相互转换

方式1:

直接：String的另一种构造方法:String(StringBuffer buffer)

方式2:

public String toString()；说明:现在的数据类型是StirngBuffer类型,

String--->StringBuffer

方式1:

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

功能：创建一个字符串缓冲区并指向这个字符串

方式2:

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

package day_11_10_29.stringbuffertest;

public class StringBufferTest {
	public static void main(String[] args) {
		// String---->StringBuffer
		/**
		 * 方式1：
		 * 使用StringBuffer的构造方式：StringBuffer(String str)
		 * 功能：创建一个字符串缓冲区并指向这个字符串
		 * */
		//定义一个字符串
		String s = "hello";
		StringBuffer sb = new StringBuffer(s);
		System.out.println("sb= "+sb);
		
		/**
		 * 方式2：
		 * 1)创建字符串缓冲区对象;
		 * 2)使用无参构造StringBuffer();
		 * 3)利用append();
		 * */
		StringBuffer sb2 = new StringBuffer();
		sb2.append(s);
		System.out.println("sb2:"+sb2);
		System.out.println("--------------------");
		
		//StringBuffer--->String
		/*方式1:
		 *直接：String的另一种构造方法:String(StringBuffer buffer)
		 *1)有一个字符串缓冲区对象
		 *2)
		 * */
		StringBuffer buffer = new StringBuffer("world");
		String s2 = new String(buffer);
		System.out.println("s2:"+s2);
		
		/*方式2:
		 * public String toString()
		 * 说明:现在的数据类型是StirngBuffer类型,
		 * 利用此方法可以将StringBuffer类型转换String
		 * 
		 * */
		String s3 = buffer.toString();
		System.out.println("s3:"+s3);
	}
}

面试题：StringBuffer和数组的区别？

两个共同特点：都属于容器类型的容量

数组：只能存储同一种数据类型的元素，数组的长度是固定的 int【】 arr = {10,20,30,"hello"} 错误的

StringBuffer:字符串缓冲区，可以存储任意类型的元素，可以不断的去给缓冲区中追加（append）,字符串缓冲区中：在内存始终返回的字符串

练习：将数组拼接成一个字符串，分别使用String和StringBuffer实现

package day_11_10_29.stringbuffertest;
/**
 * 将数组拼接成一个字符串,分别使用String和StringBuffer实现(定义功能方法)
 * 
 * 		int[] arr = {11,55,33 ,44 ,22} ;
 * 		形成这样一个字符串:[11, 55, 33, 44, 22] 
 * 分析:
 * 		1)存在一个数组,静态初始化
 * 		2)分别使用String和StringBuffer类型去完成
 * 	
 * */
public class StringBufferTest2 {
	public static void main(String[] args) {
		// 定义一个数组并静态初始化
		int [] arr = {11,55,33,44,22};
		
		//使用String
		String result = arrayToString(arr);
		System.out.println("result:"+result);
		
		//使用StringBuffer
		String result2 = arrayToString2(arr);
		System.out.println("result2:"+result2);
	}
	
	/**
	 * 明确返回值类型:String
	 * 明确参数类型:int[] arr
	 */
	
	//String
	public static String arrayToString(int [] arr){
		//定义一个空字符串
		String s = "";
		//拼接"["
		s+="[";
		//遍历数组
		for(int i=0;i<arr.length;i++){
			//判断最大索引
			if(i==arr.length-1){
				s+=arr[i];
				s+="]";
			}else{
				s+=arr[i];
				s+=", ";
			}
		}
		return s;
	}
	//StringBuffer
	public static String arrayToString2(int [] arr){
		//创建字符串缓冲区对象
		StringBuffer sb = new StringBuffer();
		//追加"["
		sb.append("[");
		//遍历数组
		for(int i=0;i<arr.length;i++){
			//判断最大索引
			if(i==arr.length-1){
				sb.append(arr[i]).append("]");;	
			}else{
				sb.append(arr[i]).append(", ");
			}
		}
		//sb.append("]");
		return sb.toString(); //将StringBuffer--->String
	}
}

练习：分别使用String和StringBuffer实现字符串反转

package day_11_10_29.stringbuffertest;

import java.util.Scanner;

/**
 * 分别使用String和StringBuffer实现字符串的反转
 **/
public class StringBufferTest3 {
	public static void main(String[] args) {
		
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一个字符串:");
		String str = sc.nextLine();
		
		//使用String类型转换
		String result = myReverse(str);
		System.out.println("result:"+result);
		
		//使用StringBuffer类型转换
		String result1 = myReverse1(str);
		System.out.println("result1:"+result1);
	}
	
	//使用String实现反转
	public static String myReverse(String str){
		//定义一个空字符串
		String s = "";
		//将字符串转换成字符数组
		char[] chs = str.toCharArray();
		//倒序遍历字符串数组
		for(int i=chs.length-1;i>=0;i--){
			s+=chs[i];
		}
		return s;
	}
	
	//使用StringBuffer实现反转
	public static String myReverse1(String str){
		//创建字符串缓冲区对象
		StringBuffer sb = new StringBuffer(str);//注意参数str
		//调用反转功能
		sb.reverse();
		return sb.toString();
		
	}
}

练习：判断一个字符串是否是对称字符串

package day_11_10_29.stringbuffertest;

import java.util.Scanner;

/**
 * 1判断一个字符串是否是对称字符串
  
   例如"abc"不是对称字符串，"aba"、"abba"、"aaa"、"mnanm"是对称字符串
	使用(String和StringBuffer实现这个功能)
	
	分析:
			用第一个字符和倒数第一个字符相比较
			用二个字符和倒数第二个字符进行比较
			...
 */
public class StringBufferTest4 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一串字符串：");
		String s = sc.nextLine();
		//使用String
		boolean result = isSame(s); 
		System.out.println("result:"+result);
		
		//使用StringBuffer实现
		boolean result2 =isSame2(s);
		System.out.println("result2:"+result2);
	}
	//使用String实现
	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]){
				//return false;
				//修改标记
				flag = false;
				break;
			}
		}
		//return true;
		return flag ;
	} 
	
	//使用StringBuffer实现
	public static boolean isSame2(String s){
		return new StringBuffer(s).reverse().toString().equals(s);	
	}	
}

Luna_ll

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
StringBuffer类

一.StringBuffer1.StringBuffer:线程安全的可变字符序列。特点：线程安全----->不同步----->执行效率高，在开发中，线程不安全会造成死锁的现象eg:银行的网站、医院的平台线程（相对于进程而言）后续补充！面试题：StringBuffer和String 的区别?StringBuffer会构造一个字符串缓冲区,从内存角度考虑,一般情况使用Strin
复制链接

扫一扫