可变字符串StringBuffer类

StringBuffer类概述：

我们如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既耗时，又浪费空间。而StringBuffer就可以解决这个问题。StringBuffer:是一个可变的字符串。字符串缓冲区类。 

如图所示：中间过程中的hello和world并不是我们最后想要的，语句运行完后，它们占用内容。

+=拼接字符串耗费内存原因:

每次拼接都会产生新的字符串对象,而利用StringBuffer来拼接字符串自始至终用的都是同一个StringBuffer容器

StringBuffer和String的区别?

•   String的内容是固定的
•   StringBuffer的内容是可变的

构造方法

• public StringBuffer():无参构造方法
• public StringBuffer(int capacity):指定容量的字符串缓冲区对象
• public StringBuffer(String str):指定字符串内容的字符串缓冲区对象

package cn.wen_01;

public class StringBufferDemo {
	public static void main(String[] args) {
		//public StringBuffer():无参构造方法
		StringBuffer sb = new StringBuffer();
		System.out.println("sb:" + sb);	//sb:
		/*
		 *  StringBuffer的方法：
		 *  	public int capacity()：返回当前容量。	理论值
		 *  	public int length():返回长度（字符数）。 实际值
		 */
		System.out.println("sb.capacity():" + 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(50);
		System.out.println("sb2:" + sb2);
		System.out.println("sb2.capacity():" + sb2.capacity());	//sb2.capacity():50
		System.out.println("sb2.length():" + sb2.length());	//sb2.length():0
		System.out.println("--------------------------");
		
		// public StringBuffer(String str):指定字符串内容的字符串缓冲区对象
		StringBuffer sb3 = new StringBuffer("hello");	
		System.out.println("sb3:" + sb3);	//sb3:hello
		System.out.println("sb3.capacity():" + sb3.capacity());	//sb3.capacity():21(16+5)
		System.out.println("sb3.length():" + sb3.length()); //sb3.length():5
	}
}

StringBuffer类的成员方法

• 添加功能

public StringBuffer append(String str)：可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身

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

代码测试演示过程如下：

package cn.wen_02;

/*
 * StringBuffer的添加功能：
 * public StringBuffer append(String str):可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身
 * 
 * public StringBuffer insert(int offset,String str):在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身
 */
public class StringBufferDemo {
	public static void main(String[] args) {
		// 创建字符串缓冲区对象
		StringBuffer sb = new StringBuffer();

		// public StringBuffer append(String str)
		// StringBuffer sb2 = sb.append("hello");
		// System.out.println("sb:" + sb);
		// System.out.println("sb2:" + sb2);
		// System.out.println(sb == sb2); // true

		// 一步一步的添加数据
		// sb.append("hello");
		// sb.append(true);
		// sb.append(12);
		// sb.append(34.56);

		// 链式编程
		sb.append("hello").append(true).append(12).append(34.56);
		System.out.println("sb:" + sb);

		// public StringBuffer insert(int offset,String
		// str):在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身
		sb.insert(5, "world");
		System.out.println("sb:" + sb);
	}
}

 

• 删除功能

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

public StringBuffer delete( int start,int end): 删除从指定位置开始指定位置结束的内容，并返回本身

 

package cn.wen_03;

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);

		// public StringBuffer deleteCharAt(int index):删除指定位置的字符，并返回本身
		// 需求：删除e这个字符
		// sb.deleteCharAt(1);
		// 需求:删除第一个l这个字符
		// sb.deleteCharAt(1);

		// public StringBuffer delete(int start,int
		// end):删除从指定位置开始指定位置结束的内容，并返回本身
		// 需求：删除world这个字符串
		// sb.delete(5, 10);

		// 需求:删除所有的数据
		sb.delete(0, sb.length());

		System.out.println("sb:" + sb);
	}
}

 

• 替换功能

public StringBuffer replace( int start,int end,String str): 从start开始到end用str替换

 

package cn.wen_04;

public class StringBufferDemo {
	public static void main(String[] args) {
		// 创建字符串缓冲区对象
		StringBuffer sb = new StringBuffer();

		// 添加数据
		sb.append("hello");
		sb.append("world");
		sb.append("java");
		System.out.println("sb:" + sb);    //sb:helloworldjava

		// public StringBuffer replace(int start,int end,String str):从start开始到end用str替换
		// 需求：把world这个数据替换为"我爱"
		sb.replace(5, 10, "我爱");
		System.out.println("sb:" + sb);    //sb:hello我爱java
	}
}

 

• 反转功能

         public StringBuffer reverse()

 

package cn.wen_05;

/*
 * StringBuffer的反转功能：
 * public StringBuffer reverse()
 */
public class StringBufferDemo {
	public static void main(String[] args) {
		// 创建字符串缓冲区对象
		StringBuffer sb = new StringBuffer();

		// 添加数据
		sb.append("avaj爱我");
		System.out.println("sb:" + sb);    //avaj爱我

		// public StringBuffer reverse()
		sb.reverse();
		System.out.println("sb:" + sb);    //我爱java
	}
}

 

• 截取功能

public String substring( int start)

public String substring( int start,int end )

 

注意返回值类型不再是StringBuffer本身了

package cn.wen_06;

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 String substring(int start)
		String s = sb.substring(5);
		System.out.println("s:" + s);    //s:worldjava
		System.out.println("sb:" + sb);    //sb:helloworldjava

		// public String substring(int start,int end)
		String ss = sb.substring(5, 10);
		System.out.println("ss:" + ss);    //ss:worldjava
		System.out.println("sb:" + sb);    //sb:helloworldjava
	}
}

StringBuffer类练习

• String和StringBuffer的相互转换

为什么要讲解类之间的转换：

 A -- B的转换。我们把A转换为B，其实是为了使用B的功能。
 B -- A的转换。我们可能要的结果是A类型，所以还得转回来。

 String和StringBuffer的相互转换?下面通过代码演示测试：

package cn.wen_07;

public class StringBufferTest {
	public static void main(String[] args) {
		// String 转 StringBuffer
		String s = "hello";

		// 注意：不能把字符串的值直接赋值给StringBuffer。这里是错误的做法
		// StringBuffer sb = "hello";
		// StringBuffer sb = s;

		// 方式1:通过构造方法
		StringBuffer sb = new StringBuffer(s);
		// 方式2：通过append()方法
		StringBuffer sb2 = new StringBuffer();
		sb2.append(s);
		System.out.println("sb:" + sb);    //sb:hello
		System.out.println("sb2:" + sb2);    //sb2:hello
		System.out.println("---------------");


		// StringBuffer 转 String
		StringBuffer buffer = new StringBuffer("java");

		// String(StringBuffer buffer)
		// 方式1:通过构造方法
		String str = new String(buffer);

		// 方式2：通过toString()方法
		String str2 = buffer.toString();
		System.out.println("str:" + str);    //str:java
		System.out.println("str2:" + str2);    //str2:java
	}
}

• 把数组拼接成一个字符串

package cn.wen_08;

/*
 * 把数组拼接成一个字符串
 */
public class StringBufferTest {
	public static void main(String[] args) {
		// 定义一个数组
		int[] arr = { 44, 33, 55, 11, 22 };

		// 定义功能
		// 方式1：用String做拼接的方式
		String s1 = arrayToString(arr);
		System.out.println("s1:" + s1);

		// 方式2:用StringBuffer做拼接的方式(推荐使用)
		String s2 = arrayToString2(arr);
		System.out.println("s2:" + s2);
	}

	// 用StringBuffer做拼接的方式
	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]).append(", ");
			}
		}
		sb.append("]");

		return sb.toString();
	}

	// 用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;
	}
}

• 把字符串反转

package cn.wen_09;

import java.util.Scanner;

/*
 * 把字符串反转
 */
public class StringBufferTest3 {
	public static void main(String[] args) {
		// 键盘录入数据
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入数据：");
		String s = sc.nextLine();

		// 方式1：用String做拼接
		String s1 = myReverse(s);
		System.out.println("s1:" + s1);
		// 方式2：用StringBuffer的reverse()功能
		String s2 = myReverse2(s);
		System.out.println("s2:" + s2);
	}

	// 用StringBuffer的reverse()功能
	public static String myReverse2(String s) {
		// StringBuffer sb = new StringBuffer();
		// sb.append(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--) {
			// char ch = chs[x];
			// result += ch;
			result += chs[x];
		}

		return result;
	}
}

• 判断一个字符串是否是对称字符串

例如"abc"不是对称字符串，"aba"、"abba"、"aaa"、"mnanm"是对称字符串

分析：
          判断一个字符串是否是对称的字符串，需要把
          第一个和最后一个比较
          第二个和倒数第二个比较
              ...
         比较的次数是长度除以2取整。

package cn.wen_10;

import java.util.Scanner;

public class StringBufferTest4 {
	public static void main(String[] args) {
		// 创建键盘录入对象
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一个字符串：");
		String s = sc.nextLine();

		// 方式1：一个一个的比较
		boolean b = isSame(s);
		System.out.println("b:" + b);
		
		//方式2: 用字符串缓冲区的反转功能
		boolean b2 = isSame2(s);
		System.out.println("b2:"+b2);
	}
	
	public static boolean isSame2(String s) {
		return new StringBuffer(s).reverse().toString().equals(s);
	}
	

	// 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;
	// }

	public static boolean isSame(String s) {
		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;
	}
}

上面用的StringBuffer都可以和StringBuilder兼容。（单线程）

 

1、String,StringBuffer,StringBuilder的区别

• A:String是内容不可变的，而StringBuffer,StringBuilder都是内容可变的。
• B:StringBuffer是同步的，数据安全,效率低;StringBuilder是不同步的,数据不安全,效率高

       2：StringBuffer和数组的区别?

二者都可以看出是一个容器，装其他的数据。但是呢,StringBuffer的数据最终是一个字符串数据。 而数组可以放置多种数据，但必须是同一种数据类型的。

       3:形式参数问题

• String作为参数传递
• StringBuffer作为参数传递   

 形式参数：
          基本类型：形式参数的改变不影响实际参数
          引用类型：形式参数的改变直接影响实际参数  
  注意：
          String作为参数传递，效果和基本类型作为参数传递是一样的。
 

public class StringBufferDemo {
	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

		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;
		sb2.append(sb1);
	}

	public static void change(String s1, String s2) {
		s1 = s2;
		s2 = s1 + s2;
	}
}

 

​​​​​​​