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

时间：2023-02-24 11:37:23

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效率会更高。










标签：

相关文章