(23)Java学习笔记——常用对象API / StringBuffer类

最新推荐文章于 2023-10-08 17:05:33 发布

xiexiecm

最新推荐文章于 2023-10-08 17:05:33 发布

阅读量281

点赞数

分类专栏： Java 文章标签： java API

本文链接：https://blog.csdn.net/xiexiecm/article/details/54891589

版权

Java 专栏收录该内容

52 篇文章 0 订阅

订阅专栏

StringBuffer类

线程安全的可变字符序列

StringBuffer和String的区别

前者长度和内容可变，后者不可变

如果使用前者做字符串的拼接，不会浪费太多的资源

StringBuffer类的构造方法：

public StringBuffer() //无参构造方法

public StringBuffer(int capacity) //指定容量的字符串缓冲区对象

public StringBuffer(String str) //指定字符串内容的字符串缓冲区对象

范例：

package cn.itcast_01;

public class StringBufferDemo {
	public static void main(String[] args) {
		//public StringBuffer() 无参构造方法
		StringBuffer sb = new StringBuffer();
		System.out.println("sb:"+sb);	//sb:
		System.out.println("sb.capacity:"+sb.capacity());	//空参构造方法的容量16
		System.out.println("sb.length:"+sb.length());	//sb.length:0
		System.out.println("----------------------------");
		
		//public StringBuffer(int capacity)  //指定容量的字符串缓冲区对象
		StringBuffer sb2 = new StringBuffer(32);	//设置32容量
		System.out.println("sb2.capacity:"+sb2.capacity());		//sb2.capacity:32
		System.out.println("----------------------------");
		
		//public StringBuffer(String str) //指定字符串内容的字符串缓冲区对象
		StringBuffer sb3 = new StringBuffer("helloworld");
		System.out.println("sb3.capacity:"+sb3.capacity());		//sb3.capacity:26
		System.out.println("sb3.length:"+sb3.length());		//sb3.length:10
	}
}

StringBuffer类的成员方法

添加功能：

public StringBuffer append(String str) //可以把任意类型添加到字符串缓冲区里面

public StringBuffer insert(int offset , String str) //在指定位置把任意类型的数据插入到字符串缓冲区里面

范例01：添加功能：public StringBuffer append(String str) //可以把任意类型添加到字符串缓冲区里面

package cn.itcast_02;
/*
 * StringBuffer的添加功能
 * 
 */
public class StringBufferDemo {
	public static void main(String[] args) {
		
		//public StringBuffer append(String str)    //可以把任意类型数据添加到字符串缓冲区里面，并返回字符串缓冲区本身
		//创建字符串缓存区对象
		StringBuffer sb = new StringBuffer();	//这一部相当于创建了一个缓冲区
		
		/*StringBuffer sb2 = sb.append("hello");		//这一部相当于追加了一个数据，并没有重新开空间。
		System.out.println("sb:"+sb);		//返回结果：sb:hello
		System.out.println("sb2:"+sb2);		//返回结果：sb2:hello
		System.out.println(sb==sb2);		//返回结果：true
*/		
		//以上代码简化：
		sb.append("hello");
		System.out.println("sb:"+sb);	//返回结果：sb:hello
		
		System.out.println("--------------------");
		
		StringBuffer sb2 = new StringBuffer();
		sb2.append("hello");
		sb2.append(true);
		sb2.append(123);
		System.out.println("sb2:"+sb2); 	//返回结果：sb2:hellotrue123	//就是不断的一步一步的往缓冲区里添加数据
		
		/*//以上代码用链式编程方式：
		sb2.append("hello").append(true).append(123);
		System.out.println("sb2:"+sb2);  //返回结果：sb2:hellotrue123
*/
	}
}

范例02：添加功能 public StringBuffer insert(int offset , String str) //在指定位置把任意类型的数据插入到字符串缓冲区里面

package cn.itcast_02;
/*
 * StringBuffer的添加功能
 * 
 */
public class StringBufferDemo {
	public static void main(String[] args) {
		
		//创建字符串缓存区对象
		StringBuffer sb = new StringBuffer();	//这一部相当于创建了一个缓冲区
	
		//码用链式编程方式：
		sb.append("hello").append(true).append(123);
		System.out.println("sb:"+sb);  //返回结果：sb2:hellotrue123
		
		//public StringBuffer insert(int offset,String str)  //在制定位置把任意类型数据插入到字符串缓冲区里面，并返回字符串缓冲区本身
		
		sb.insert(5, false);	//从第5个元素后开始插入false数据
		System.out.println("sb:"+sb);	//返回结果：sb:hellofalsetrue123
		
	}
}

删除功能：

public StringBuffer deleteCharAt(int index) //删除指定位置的一个字符，并返回本身

public StringBuffer delete(int start , int end) //删除指定位置开始到指定位置解释的内容，并返回本身

范例：

package cn.itcast_03;
/*
 * StringBuffer的删除功能
 */
public class StringBufferDemo {
	public static void main(String[] args) {
		//创建对象
		StringBuffer sb = new StringBuffer();
		
		//添加元素，链式编程
		sb.append("hello").append("world").append("java");  //返回结果：sb:helloworldjava
		
		//public StringBuffer deleteCharAt(int index)  	//删除指定位置的字符，并返回本身
		//需求：要删除e这个字符
//		sb.deleteCharAt(1);		//返回结果：sb:hlloworldjava
		
		//public StringBuffer delete(int start,int end)  // 删除从指定位置开始到指定位置结束的内容，并返回本身
		//需求：删除world
//		sb.delete(5,10); //返回结果sb:hellojava
		
		//需求：删除所有数据
		sb.delete(0,sb.length());	//返回结果sb:
		
		System.out.println("sb:"+sb);
	}
}

替换功能：

public StringBuffer replace(int start , int end , strint str) //从指定位置到结束位置替换成字符XXX

范例：

package cn.itcast_04;
/*
 * StringBuffer类的替换功能
 */
public class StringBufferDemo {
	public static void main(String[] args) {
		//创建对象
		StringBuffer sb = new StringBuffer();
		
		//添加元素
		sb.append("hello").append("world").append("java");
		System.out.println("sb:"+sb);	//返回结果sb:helloworldjava
		
		//public StringBuffer replace(int start,int end,String str)  从指定位置到结束位置替换成字符XXX
		//需求：把world替换成hahaha
		
		sb.replace(5,10, "hahaha");
		System.out.println("sb:"+sb);	//返回结果：sb:hellohahahajava
	}
}

反转功能：

public StringBuffer reverse() //将字符串反转

范例：

package cn.itcast_05;
/*
 * StringBuffer类的反转功能
 * 
 */
public class StringBufferDemo {
	public static void main(String[] args) {
		//创建一个对象
		StringBuffer sb = new StringBuffer();

		//添加元素
		sb.append("helloworld");
		
		//public StringBuffer reverse() //将字符串反转
		sb.reverse();
		System.out.println("sb:"+sb);
	}
}

截取功能：

public String substring(int start) //将字符串从指定位置截取

public String substring(int start , int end) //将字符串从指定位置开始到指定位置结束中间的内容截取

截取功能和前面几个功能的不同：

返回值类型是String类型，本身没有发生改变

范例：

package cn.itcast_06;
/*
 * StringBuffer类的截取功能
 */
public class StringBufferDemo {
	public static void main(String[] args) {
		//创建对象
		StringBuffer sb = new StringBuffer();
		
		//添加元素
		sb.append("helloworldjava");
		
		//public StringBuffer(int start)  //从指定位置开始截取
		String s = sb.substring(5);		//注意返回值类型是String，本身并没有改变
		System.out.println("s:"+s);		//返回结果：s:worldjava
		
		//public StringBuffer(int start,int end)  //截取中间一段
		String s1 = sb.substring(5,10);
		System.out.println("s1:"+s1);  //返回结果：s1:world
		
	}
}

String 和 StringBuffer的相互转换

类之间的转换：

A---B的转换，其实是为了使用B的功能

范例：

package cn.itcast_07;
/*
 * String 和 StringBuffer的相互转换
 */
public class StringBufferTest_01 {
	public static void main(String[] args) {
		//String--------->StringBuffer
		//定义一个String
		String s = "helloworld";
		//不能吧字符串的值直接赋值给StringBuffer
		//方式1：
		StringBuffer sb = new StringBuffer(s); //通过构造方法public StringBuffer(String str)  //指定字符串内容的字符串缓冲区对象
		
		//方式2：通过append方法
		StringBuffer sb2 = new StringBuffer();
		sb2.append(s);
		
		System.out.println("sb:"+sb);
		System.out.println("sb2:"+sb2);
		
		//StringBuffer-------------->String
		StringBuffer buffer = new StringBuffer("java");
		
		//方式1：通过String的构造方法 String(StringBuffer buffer)
		String str = new String(buffer);
		
		//方式2：通过toString()方法
		String str2= buffer.toString();
		
		System.out.println("str:"+str);
		System.out.println("str2:"+str2);
	}
}

练习01：把数组拼接成一个字符串

package cn.itcast_08;
/*
 * 把数组拼接成一个字符串
 */
public class StringBufferTest_01 {
	public static void main(String[] args) {
		//定义一个数组：
		int[] arr = {44,33,55,11,22};
		
		//定义功能
		//方式1：用String做拼接大方式
		String s1 = arrayToString(arr);
		System.out.println("s1:"+s1); 	//返回结果：s1:[44, 33, 55, 11, 22]
		
		//方式2：用StringBuffer做拼接方式
		
		String s2 = arrayToString2(arr);
		System.out.println("s2:"+s2);		//返回结果s2:[44, 33, 55, 11, 22]
		
	}
	
	：用String做拼接的方法
	public static String arrayToString(int[] arr){
		String s = "";
		
		s += "[";
		for (int x = 0;x<arr.length;x++){
			if(x==arr.length-1){
				s +=arr[x];
			}
			else{
				s +=arr[x];
				s +=", ";
			}
		}
		s +="]";
		
		return s;
	}
	
	public static String arrayToString2(int[] arr){
		StringBuffer sb = new StringBuffer();
		
		sb.append("[");
		for (int x=0;x<arr.length;x++){
			if(x==arr.length-1){
				sb.append(arr[x]);
			}
			else{
				sb.append(arr[x]);
				sb.append(", ");
			}
		}
		sb.append("]");
		
		return sb.toString();
		
	}
}

练习02：从键盘输入字符串，把字符串反转

package cn.itcast_08;

import java.util.Scanner;

/*
 * 从键盘输入字符串，将字符串反转
 */
public class StringBufferTest_02 {
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);	//创建Scanner对象
		System.out.println("请输入一串字符：");
		String s = input.nextLine(); //调用Scanner对象的nextLine方法
		
		String ouput = reversalString(s); // 调用reversalString方法，传递给String类型的接收
		System.out.println("ouput:"+ouput);
			
	}
	
	//定义一个基于StringBuffer类的字符反转方法。
/*	两个要素：
	a/ 返回值类型 String
	b/ 参数列表 String str*/
	
	public static String reversalString(String str){
		StringBuffer sb = new StringBuffer(); //创建一个StringBuffer对象
		sb.append(str);	//添加元素
		String s = sb.reverse().toString();	//调用reverse方法反转后，转换成String类型
		return s;
	}
}

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

例如：“abc”不是对称字符串，“aba”是对称字符串

package cn.itcast_08;

import java.util.Scanner;

/*
 * 判断一个字符串是不是对称字符串
 * 思路：
 * 判断一个字符串是否是对称字符串，需要：
 * 第一个和最后一个比较
 * 第二个和倒数第二个比较
 * 。。。。
 * 比较的次数是长度/2
 */
public class StringBufferTest_03 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入字符串：");
		String s = sc.nextLine();
		
		//一个一个比较
		boolean b = isSame(s);
		System.out.println("b:"+b);
		
		//方式2，使用字符串缓冲区反转功能
		boolean b2 = isSame2(s);
		System.out.println("b2:"+b2);

	}
	//方式1：定义一个boolean方法
	public static boolean isSame(String s){
		//把字符串转成字符数组
		char[] chs = s.toCharArray();
		
		for(int start=0,end = chs.length-1;start<=end;start++,end--){
			if (chs[start]!=chs[end]){
				return false;
			}
		}
		return true;
		
	}
	
	//方式2：使用字符串缓冲区的反转功能
	public static boolean isSame2(String s){
		StringBuffer sb = new StringBuffer();
		sb.append(s);
		String s1 = sb.reverse().toString();
		return s.equals(s1); //调用equals方法判断反转前后的字符是否一致。返回boolean值
	}
	
}

在单线程模式下，用StringBuilder替代StringBuffer效率会更高。

xiexiecm

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
(23)Java学习笔记——常用对象API / StringBuffer类

StringBuffer类线程安全的可变字符序列StringBuffer和String的区别前者长度和内容可变，后者不可变如果使用前者做字符串的拼接，不会浪费太多的资源StringBuffer类的构造方法：public StringBuffer() //无参构造方法public StringBuffer(int capacity) //指定容量的
复制链接

扫一扫