String和StringBuffer类的使用(包会)

（一）String

例1：分别用String的几个构造函数完成串的创建。

public static void main(String[] args) throws Exception {
		// 创建一个空的字符串
		String str1 = new String();
		// 创建一个内容为abcd的字符串
		String str2 = new String("abcd");
		// 创建一个内容为字符数组的字符串
		char[] charArray = new char[]{'D','E','F'};
		String str3 = new String(charArray);
		System.out.println("a"+str1+"b");
		System.out.println(str2);
		System.out.println(str3);
	}

引申：在输入框输入内容后，如何去除串尾的逗号？
——对串做length-1操作后进行输出。

一般情况下，常用的创建String对象的方式如下所示：

String str1 = "string";
String str2 = new String("string");

这两种创建方式是有区别的，这和java的内存管理有关。因为String对象创建后不可变，所以按照第一种方式创建的字符串会放在栈里，更确切的是常量池中，常量池就是用来保存在编译阶段确定好了大小的数据，一般我们定义的int等基本数据类型就保存在这里。
使用第一种创建字符串的方法时，编译器首先检查常量池，看看有没有一个“string”，如果没有则创建。如果有的话，则直接把str1指向那个位置。
而第二种创建字符串的方法是通过new关键字，java会将new的对象放在堆中，这一部分对象是在运行时创建的对象。所以我们每一次new的时候，即便堆中已经有了一个一模一样的，都会创建不同的对象。
执行以下程序，说明结果的原因：

public static void main(String[] args) {
		String str1 = "string";
		String str2 = new String("string");
		String str3 = new String("string");
		String str4 = "string";

		/* 用于测试两种创建字符串方式的区别 */
		System.out.println("(str1 == str4): "+(str1 == str4));
		System.out.println("(str2 == str3): "+(str2 == str3));
		System.out.println("(str3 == str1): "+(str3 == str1));	}

4、在程序中，需要对字符串进行一些基本操作，如获得字符串长度、获得指定位置的字符等。并且，String类提供的方法可以很方便地获取字符串的长度，获取指定位置的字符以及指定字符的位置。
对字符串进行转换操作，例如将字符串转换成数组的形式，将字符串中的字符进行大小写转换等。

例2：.length（）、.char()、.charAt()、.indexOf()

public static void main(String[] args) {
		String s = "abcdedcba"; // 声明字符串
		System.out.println("字符串的长度为：" + s.length()); // 获取字符串长度，即字符个数
		System.out.println("字符串中第一个字符:" + s.charAt(0));
		System.out.println("字符c第一次出现的位置:" + s.indexOf('c'));
		System.out.println("字符c最后一次出现的位置:" + s.lastIndexOf('c'));
	}

例3：String类的toCharArray()方法和静态valueOf（）

/*
*使用String类的toCharArray()方法将一个字符串转为一个字符数组，静态方法valueOf()将
*一个int类型的整数转为字符串，toUppercase()方法将字符串中的字符都转为大写。其中
*valueOf()方法有很多重载的形式，float、double、char等其它基本类型的数据都可以通过该
*方法转为String字符串类型。
*/
public static void main(String[] args) {
		String str = "abcd";
		System.out.print("将字符串转为字符数组后的结果:");
		char[] charArray = str.toCharArray(); // 字符串转换为字符数组
		for (int i = 0; i < charArray.length; i++) {
			if (i != charArray.length - 1) { 
				// 如果不是数组的最后一个元素,在元素后面加逗号
				System.out.print(charArray[i] + ",");
			} else {
				// 数组的最后一个元素后面不加逗号
				System.out.println(charArray[i]);
			}
		}
		System.out.println("将int值转换为String类型之后的结果:" + String.valueOf(12));
		System.out.println("将字符串转换成大写之后的结果:" + str.toUpperCase());
	}

例:4：字符串的替换和去除空格操作

程序开发中，用户输入数据时经常会有一些错误和空格，这时可以使用String类的replace()和trim()方法，进行字符串的替换和去除空格操作

public static void main(String[] args) {
		String s = "broadcast.com";
		// 字符串替换操作
		System.out.println("将com替换成edu.cn的结果:" + s.replace("com", "edu.cn"));
         // 字符串去除空格操作
		String s1 = "     b r o a d c a s t.com     ";
		System.out.println("去除字符串两端空格后的结果:" + s1.trim());
		System.out.println("去除字符串中所有空格后的结果:" + s1.replace(" ", ""));
	}

例题调用String类的两个方法，其中replace()方法用于将字符串中所有与指定字符串匹配的子串替换成另一个字符串，trim()方法用于去除字符串中的空格，需要注意的是，该方法只能去除两端的空格，不能去除中间的空格。若想去除字符串中间的空格，则可以调用String类的replace()方法。

操作字符串时，经常需要对字符串进行一些判断，如判断字符串是否以指定的字符串开始、结束，是否包含指定的字符串，字符串是否为空等。

例5：字符串的判断操作

操作字符串时，经常需要对字符串进行一些判断，如判断字符串是否以指定的字符串开始、结束，是否包含指定的字符串，字符串是否为空等。

public static void main(String[] args) {
		String s1 = "String"; 	// 声明一个字符串
		String s2 = "Str";
		System.out.println("判断是否以字符串Str开头:" + s1.startsWith("Str"));
		System.out.println("判断是否以字符串ng结尾:" + s1.endsWith("ng")); 
		System.out.println("判断是否包含字符串tri:" + s1.contains("tri")); 
		System.out.println("判断字符串是否为空:" + s1.isEmpty()); 
		System.out.println("判断两个字符串是否相等" + s1.equals(s2)); 
	}

例题涉及到的方法都是用于判断字符串的，并且返回值均为boolean类型。其中，equals()方法比较重要，该方法将父类Object中equals()方法进行了重写。
。

例6：字符串的截取和分割

在String类中针对字符串的截取和分割操作提供了两个方法，其中，substring()方法用于截取字符串的一部分，split()方法可以将字符串按照某个字符进行分割。

public static void main(String[] args) {
		String str = "羽毛球-篮球-乒乓球";
		// 下面是字符串截取操作
		System.out.println("从第5个字符截取到末尾的结果：" + str.substring(4));
		System.out.println("从第5个字符截取到第6个字符的结果：" + str.substring(4, 6)); 
		// 下面是字符串分割操作
		System.out.print("分割后的字符串数组中的元素依次为:");
		String[] strArray = str.split("-"); // 将字符串转换为字符串数组
		for (int i = 0; i < strArray.length; i++) {
			if (i != strArray.length - 1) {
				// 如果不是数组的最后一个元素,在元素后面加逗号
				System.out.print(strArray[i] + ",");
			} else {
				// 数组的最后一个元素后面不加逗号
				System.out.println(strArray[i]);
			}
		}
	}

例题调用了String类中重载的两个substring()方法。substring()方法传入参数4，即截取字符串中第5个字符以及之后的所有字符，因为字符串中的字符，索引是从0开始的。substring()方法时传入两个参数4和6，即截取第5个和第6个字符，因为字符串在截取时，只包括开始索引，不包括结束索引。split()方法根据指定的符号“-”将字符串分割成了三部分，并存放到一个String类型的数组当中。

**注意：**String字符串在获取某个字符时，会用到字符的索引，当访问字符串中的字符时，如果字符的索引不存在，则会发生StringIndexOutOfBoundsException字符串下标越界异常）（。

二、StringBuffer

为了便于对字符串的修改，在JDK中提供了一个StringBuffer类（也称字符串缓冲区）。StringBuffer类和String类最大的区别在于它的内容和长度都是可以改变的。StringBuffer类似一个字符容器，当在其中添加或删除字符时，并不会产生新的StringBuffer对象。
StringBuffer类和String类有很多相似之处，初学者使用时容易混淆。
1、String类表示的字符串是常量，一旦创建后，内容和长度都是无法改变的。StringBuffer表示字符容器，其内容和长度都可以随时修改。在操作字符串时，如果该字符串仅用于表示数据类型，则使用String类即可，但是如果需要对字符串中的字符进行增删操作，则使用StringBuffer类。
2、String类覆盖了Object类的equals()方法，而StringBuffer类没有覆盖Object类的equals()方法
3、String类对象可以用操作符“+”进行连接，而StringBuffer类对象之间不能。

例7：StringBuffer类的append（）、insert（）、delete（）方法（上）

public static void main(String[] args) {
		System.out.println("1、添加------------------------");
		add();
		System.out.println("2、删除------------------------");
		remove();
		System.out.println("3、修改------------------------");
		alter();
	}
	public static void add() {                   
		StringBuffer sb = new StringBuffer(); // 定义一个字符串缓冲区
		sb.append("abcdefg");                    // 在末尾添加字符串
		System.out.println("append添加结果：" + sb);
		sb.insert(2, "123");                     // 在指定位置插入字符串
		System.out.println("insert添加结果：" + sb);
	}
	public static void remove() {             
		StringBuffer sb = new StringBuffer("abcdefg");
		sb.delete(1, 5);                         // 指定范围删除
		System.out.println("删除指定位置结果：" + sb);
		sb.deleteCharAt(2);                     // 指定位置删除
		System.out.println("删除指定位置结果：" + sb);
		sb.delete(0, sb.length());            // 清空缓冲区
		System.out.println("清空缓冲区结果：" + sb);
	}
	public static void alter() {              
		StringBuffer sb = new StringBuffer("abcdef");
		sb.setCharAt(1, 'p');                  // 修改指定位置字符
		System.out.println("修改指定位置字符结果：" + sb);
		sb.replace(1, 3, "qq");               // 替换指定位置字符串或字符
		System.out.println("替换指定位置字符（串）结果：" + sb);
		System.out.println("字符串翻转结果：" + sb.reverse());	
	}

涉及到StringBuffer类的很多方法，其中append()和insert()方法是最常用的，并且这两个方法有很多重载形式，它们都用于添加字符。不同的是，append()方法始终将这些字符添加到缓冲区的末尾，而insert()方法则可以在指定的位置添加字符。

例8：StringBuffer类的append（）、insert（）、delete（）方法（下）

StringBuffer类有很多操作字符的方法，其中append()和insert()是常用的添加字符方法，delete()是常用的删除字符方法。为了让初学者对StringBuffer类中的添加、删除方法有更深入的了解，本案例将演示StringBuffer对象的添加、删除操作。

// 创建对象
	StringBuffer sb = new StringBuffer();
	System.out.println("sb:" + sb);
	System.out.println("****StringBuffer的添加方法****");
	sb.append(100).append("hello").append(true).append(12.5);
	System.out.println("使用StringBuffer对象添加任意数据类型的数据后sb:" + sb);
	sb.insert(8, "world");
	System.out.println("在sb的第9个位置插入'world'字符串后sb:" + sb);
	System.out.println("****StringBuffer的删除方法****");
	sb.deleteCharAt(1);
	System.out.println("删除sb中第2个位置的字符后sb:" + sb);
	sb.delete(5, 10);
	System.out.println("删除sb中第6个到第11个字符后的sb:" + sb);
	}

例9：String类和StringBuffer类的区别

String类和StringBuffer类同样是操作字符串的相关类，他们的区别如下：
（a)String类表示的字符串是常量，一旦创建后，内容和长度都是无法改变的。而StringBuffer表示字符容器，其内容和长度都可以随时修改。在操作字符串时，如果该字符串仅用于表示数据类型，则使用String类即可，但是如果需要对字符串中的字符进行增删操作，则使用StringBuffer类。
b)String类覆盖了Object类的equals()方法，而StringBuffer类没有覆盖Object类的equals()方法，具体示例如下：

String s1 = new String("abc");
String s2 = new String("abc");
System.out.println(s1.equals(s2));      // 打印结果为true
StringBuffer sb1 = new StringBuffer("abc");
StringBuffer sb2 = new StringBuffer("abc");
System.out.println(sb1.equals(sb2));   // 打印结果为false

c)String类对象可以用操作符“+”进行连接，而StringBuffer类对象之间不能，具体示例如下：

String s1 = "a";
String s2 = "b";
String s3 = s1+s2;                             // 合法
System.out.println(s3);                       // 打印输出 ab
StringBuffer sb1 = new StringBuffer("a");
StringBuffer sb2 = new StringBuffer("b");
StringBuffer sb3 = sb1+sb2;                  // 编译出错

例10：StringBuffer类的操作方法

StringBuffer类有很多操作字符的方法，其中replace(int start, int end, String str)是用来替换字符的方法；substring(int start) 和substring(int start, int end)是用来截取字符的方法；reverse()是用来反转字符顺序的方法。

public static void main(String[] args) {
		StringBuffer sb = new StringBuffer();
		sb.append("hello").append("world").append("java");
		System.out.println("追加字符串后的sb:"+sb);
		System.out.println("****字符序列的替换方法**** ");		
		sb.replace(5, 10, "鲁智深");
		System.out.println("使用replace()方法替换后的sb:"+sb);		
		System.out.println("****字符序列的截取方法**** ");	
		String s = sb.substring(5);
		System.out.println("使用substring()方法截取后的s:"+s);
		System.out.println("sb:"+sb);	
		System.out.println("****字符序列的反转方法**** ");	
		sb.reverse();
		System.out.println("使用reverse()方法反转后的sb:"+sb);	
	}

练习

public static void main(String[] args) {
		// 方式1 
		String s1 = new String();
		s1 = "abcde";
		System.out.println("通过String()方法创建的字符串s1:" + s1);
		// 方式2 
		byte[] bys = { 97, 98, 99, 100, 101 };
		String s2 = new String(bys);
		System.out.println("通过String(byte[] bytes)方法创建的字符串s2:" + s2);
		// 方式3 
		String s3 = new String(bys, 2, 3);
		System.out.println("通过String(byte[] bytes, int index, int length)方法创建的字					符串s3:" + s3);
		// 方式4 
		char[] chs = { 'a', 'b', 'c', 'd', 'e' };
		String s4 = new String(chs);
		System.out.println("通过String(char[] value)方法创建的字符串s4:" + s4);
		// 方式5 
		String s5 = new String(chs, 1, 3);
		System.out.println("通过String(char[] value, int index, int length)方法创建的字					符串s5:" + s5);
		// 方式6 
		String s6 = new String("abcde");
		System.out.println("通过String(String str)方法创建的字符串s6:" + s6);
		// 方式7
		String s7 = "abcde";
		System.out.println("直接给字符串对象赋值s7:" + s7);
		}