6.2 字符串处理的类库种类
字符串处理类使用最多的有两种：“String”类和“StringBuffer”类。下面将详细讲述这两个类如何使用。
6.2.1 字符串的赋值
字符串类是处理字符串的类。“String”字符串与上一章学过的数组有一个共同点。就是它们被初始化后，长度是不变的，并且内容也不变。如果要改变它的值，就会产生一个新的字符串，如下所示：
String str1="very"; str1=str1+"good";
这个赋值表达式看起来有点像简单的接龙。在“str1”后面直接加上一个“good”字符串，形成最后的字符串“very good”。其运行原理是这样的：程序首先产生了“str1”字符串对象，并在内存中申请了一段空间。此时要追加新的字符串是不可能的，因为字符串被初始化后，长度是固定的。如果要改变它，只有放弃原来的空间，重新申请能够容纳“very”和“good”两个字符串的内存空间，然后将“very good”字符串放到内存中。
6.2.2 字符串的处理类—String
字符串的声明非常简单，具体声明方法如下所示：
字符串类型 字符串名＝字符串内容
例如：String str=“we are chinese”。
在后面类和对象中，会提到一个构造器的概念。构造器就是从类中构造出对象的方法。字符串类一共有9种不同的构造器，下面将详细讲述其中的6种。
1. 字符串类的默认构造器
“String()”这个构造器是最简单的构造器，也是系统默认的构造器，是不带参数的。
【实例6.3】下面通过实例来学习如何使用它。
01 ///创建一个空字符串str
02 ///因为是空字符串，所以输出也是没有内容的
03 public class str3
04 {
05 public static void main(String[] args)
06 {
07 String str=new String();
08 System.out.println(str);
09 }
10 }
【代码说明】第7行只初始化了一个字符串对象str，并没有为其赋值。
【运行效果】这个程序输出的结果为空，因为这个构造器构造出的对象是个空对象。
2. 字节参数的构造器
【实例6.4】“String(byte[] byte)”将字节数组中的元素作为字符串对象。请看下面的例子，再来体会这个构造器的作用。
01 ///初始化一个字节数组b
02 ///通过构造器，将字节数组中的元素连接成一个字符串
03 ///将此字符串输出
04 public class str4
05 {
06 public static void main(String[] args)
07 {
08 byte[] b={97，98，99};
09 String str=new String(b);
10 System.out.println(str);
11 }
12 }
【代码说明】这个构造器的作用是将字节数组中的元素以字符串对象的形式输出。
【运行效果】输出结果并不是数值97的字符串“97”，而是其ASCII码代表的字符a。读者可自己动手实验，结果如下所示。
abc
3. 获取指定字节数的构造器
“String(byte[] bytes，int offset，int length)”这个构造器的含义是：将字节数组中，从“offset”指定的位置开始，到“length”长度结束，中间的字符构成字符串对象。
【实例6.5】下面看一个简单的例子。
01 ///初始化一个字节数组b
02 ///通过构造器，将字节数组中的元素连接成一个字符串，并且从第4个位置开始，总共有2个元
03 ///素
04 ///将此字符串输出
05 public class str5
06 {
07 public static void main(String[] args)
08 {
09 byte[] b={97，98，99，100，101，102};
10 String str=new String(b，3，2);
11 System.out.println(str);
12 }
}
【代码说明】在“String”对象中，第一个参数“b”，就是指开始初始化的字符数组。第二个参数是3，就是指定从第4个位置开始，因为数组是从零开始的，所以3是指第4个位置即“4”。第三个参数是2，指定从这个位置开始后几个字符，因为是2，所以是从“4”开始的两个字符。
【运行效果】
de
4. 将字节型数据转换为字符集输出的构造器
“String(byte[] bytes，int offset，int length，String charsetName)”这个构造器的含义就是：将一个字节数组中从第“offset”个位置的字符开始，“length”长度的字符结束，中间的字符形成了字符串对象，然后将这个字符串按照某种字符集样式输出。
字符集一般有“us-ascii”、“iso-8859-I”、“utf-8”、“utf-16be”、“utf-16le”、“utf-16”等样式。
【实例6.6】下面先看看这种构造器的实例。
01 import java.io.＊;
02 ///初始化一个字节数组b
03 ///通过构造器，将字节数组中的元素连接成一个字符串，并且从第4个位置开始，总共有2个元素
04
05 ///将此字符串以UTF-16的形式输出
06 public class str6
07 {
08 public static void main(String[] args)
09 {
10 byte[] b={97，98，99，100，101，102};
11 try
12 {
13 String str=new String(b，3，2，"utf-8");
14 System.out.println(str);
15 }
16 catch(UnsupportedEncodingException ex){}
17
18 }
19 }
【代码说明】其实这个构造器的用法与上一个构造器差不多，唯独不同的就是输出结果的形式不一样。“String(byte[] bytes，String charsetName)”与上一个构造器是同类的构造器，此构造器是将整个字节数组作为字符串对象，并以某个字符集形式输出。
【运行效果】
de
5. 字符数组的构造器
“String(char[] value)”构造一个字符数组，其实这个构造器与第二个构造器很相似，它是将字符数组内的字符连在一起，形成一个字符串。
【实例6.7】下面是这个构造器的实例。
01 ///初始化一个字符数组c
02 ///通过构造器，将字符数组中的元素连接成一个字符串
03 ///将此字符串输出
04 public class str7
05 {
06 public static void main(String[] args)
07 {
08 char[] c={'w'，'e'，'l'，'c'，'o'，'m'，'e'};
09 String str=new String(c);
10 System.out.println(str);
11 }
12 }
【代码说明】这个程序段要做的事情，就是将字符数组中所有的元素连起来形成一个字符串。
【运行效果】
welcome
6. 截取部分字符串数组内容的构造器
“String(char[] value，int offset，int count)”这个构造器的含义是：将字符数组中从“offset”指定的位置开始，“count”指定的数目结束，中间的字符连成字符串。
【实例6.8】下面是这个构造器的实例。
01 ///初始化一个字符数组c
02 ///通过构造器，将字符数组中的元素连接成一个字符串，并从第4个位置开始，总共有4个元素
03 ///将此字符串输出
04 public class str8
05 {
06 public static void main(String[] args)
07 {
08 char[] c={'w'，'e'，'l'，'c'，'o'，'m'，'e'};
09 String str=new String(c，3，4);
10 System.out.println(str);
11 }
12 }
【代码说明】第9行是截取字符串的意思，从第三个位置开始，因为数组位置从0开始，所以这里的3，其实就是从第四个字符c开始，截取4位。
【运行效果】
come
读者可以根据上面的构造器，自己编写一些代码来熟悉它们。
6.2.3 字符串处理的方法
字符串类拥有很多针对字符串操作的方法。在这里主要讲述串连接、提取子串、从字符串中分解字符、得到字符串的长度、测试字符串是否相等、查找特定字符串、从基本类型转换成字符串等。
1. 串连接
在Java语言中，有两种串连接的方法：一种是使用“+”，另一种是使用方法函数“concat(String str)”。
【实例6.9】下面分别来举例说明。
01 ///通过加号将两个字符串str1和str2连在一起
02 public class str9
03 {
04 public static void main(String[] args)
05 {
06 String str1="you";
07 String str2="welcome";
08 System.out.println(str1+" "+str2);
09 }
10 }
【代码说明】第8行通过“+”将str1和str2两个字符串连接在一起。
【运行效果】
you welcome
【实例6.10】上面实例使用了“+”号运算符来连接两个字符串，形成新的字符串。下面通过concat方法将两个字符串连接起来。
01 ///使用concat方法将两个字符串str1和str2连在一起
02 public class str10
03 {
04 public static void main(String[] args)
05 {
06 String str1="you";
07 String str2=" welcome";
08 System.out.println(str1.concat(str2));
09 }
10 }
【代码说明】第8行使用了concat()方法，str1先输出，然后是str2。
【运行效果】
you welcome
这个实例使用了“concat”方法来连接两个字符串，形成新的字符串。无论用哪种方法将两个字符串连接起来，都同样形成新的字符串。
【实例6.11】下面将演示一个稍微复杂点的程序段。
01 ///初始化两个字符数组c和c1
02 ///通过构造器构造一个从字符数组c第1个元素开始，共4个元素组成的字符串str1
03 ///通过构造器构造一个从字符数组c1第2个元素开始，共1个元素组成的字符串str2
04 ///通过concat方法将两个字符串str2和str1连在一起
05 public class str11
06 {
07 public static void main(String[] args)
08 {
09 char[] c={'c'，'h'，'i'，'n'，'e'，'s'，'e'};
10 char[] c1={'h'，'a'，'n'，'d'，'l'，'e'};
11 String str1=new String(c，0，4);
12 String str2=new String(c1，1，1);
13 System.out.println(str1.concat(str2));
14 }
15 }
【代码说明】第9～10行定义了两个字符数组。第11～12行通过构造器构造两个字符串对象。第13行使用concat()方法连接两个字符串。
【运行效果】
china
分析以上的程序段，首先利用构造器，构造了两个将字符数组连在一起的字符串。再在这两个字符串中提取新的字符串，最后再将两个字符串合并成新字符串。仔细分析这个程序，发现这个程序段是几个知识点的组合。所以读者编程时，一定将每个知识点弄清楚，这样编写代码就不再是件难事。
2. 提取子字符串
有时一个很长的字符串，其中只有一小部分是需要的，于是Java语言类库中，就提供了相应的获取局部字符串的方法。这些方法是：“substring(int beginIndex，int endIndex)”或“substring(int index)”。下面将详细地讲述这两个方法的意义和使用方法。
❑“substring(int index)”是指提取从index指定的位置开始，一直到字符串的最后。
❑“substring(int beginIndex，int endIndex)”是指提取由“beginIndex”位置开始，到以“endIndex”为结束位置的字符串。
【实例6.12】下面将举个如何提取子字符串的实例。
01 ///初始化一个字符串str
02 ///提取从字符串的第3个元素开始到第10个元素位置的字符串，并且将其输出
03 public class str12
04 {
05 public static void main(String[] args)
06 {
07 String str="we are students and he is worker";
08 System.out.println(str.substring(2，10));
09 }
10 }
【代码说明】第7行定义了一个字符串对象str，第8行使用substring(2,10)截取字符串的一部分。
【运行效果】
are stu
【实例6.13】下面再举个如何提取子字符串的例子。
01 ///初始化一个字符串str
02 ///提取从字符串的第4个元素开始到结束位置的字符串，并且将其输出
03 public class str13
04 {
05 public static void main(String[] args)
06 {
07 String str="we are students and he is worker";
08 System.out.println(str.substring(3));
09 }
10 }
【代码说明】第8行使用了substring(3)，表示从第4个元素开始截取字符串。
【运行效果】
are students and he is worker
【实例6.14】其实提取子字符串的方法很简单，下面将看一个综合的例子。
01 ///初始化一个字符串str
02 ///通过循环语句，提取从字符串的第1个元素开始到结束位置的字符串，一直到从最后一个元素
03 ///到最后的字符串，并且将其输出
04 public class str14
05 {
06 public static void main(String[] args)
07 {
08 String str="we are students and he is a worker";
09 for(int i=0;i<34;i++)
10 {
11 System.out.println(str.substring(i));
12 }
13 }
14 }
【代码说明】这个程序以循环语句输出从第一个位置到最后一个位置的子字符串。这个程序段的运行结果看起来很复杂，但这个程序原理非常简单。
【运行效果】
we are students and he is a worker e are students and he is a worker are students and he is a worker are students and he is a worker re students and he is a worker e students and he is a worker students and he is a worker students and he is a worker tudents and he is a worker udents and he is a worker dents and he is a worker ents and he is a worker nts and he is a worker ts and he is a worker s and he is a worker and he is a worker and he is a worker nd he is a worker d he is a worker he is a worker he is a worker e is a worker is a worker is a worker s a worker a worker a worker worker worker orker rker ker er r
3. 从字符串中分解字符
上面的方法是从字符串中提取子字符串，而将要讲述的是从字符串中提取一个指定的字符。从字符串中分解字符的方法是：“charAt（int index)”，这个方法返回的是一个字符，而不是字符串，这是跟前面方法的区别。参数“index”是指字符串序列中字符的位置。
【实例6.15】下面将举个实例演示如何使用此方法。
01 ///从字符串中第2个位置将字符提取出来
02 public class str15
03 {
04 public static void main(String[] args)
05 {
06 String str="we are students and he is a worker";
07 System.out.println(str.charAt(1));
08 }
09 }
【代码说明】这个程序段输出的是字符串第二个字符，因为字符串位置从零开始计算，所以输出的字符是“e”。
【运行效果】
e
4. 得到字符串的长度
在学习数组时，学到过数组长度，而在这里也要讲到字符串的长度。字符串长度使用方法“length()”获取。
注意
数组的长度是“length”，而字符串的长度是“length()”，数组的长度后面没有括号，得到的数组长度是一个属性值，而得到字符串长度是一个方法。
【实例6.16】看看下面的程序段。
01 ///输出字符串的长度
02 public class str16
03 {
04 public static void main(String[] args)
05 {
06 String str="we are students and he is a worker";
07 System.out.println(str.length());
08 }
09 }
【代码说明】第7行使用了length()方法直接输出str对象的长度。
【运行效果】
34
5. 测试字符串是否相等
在实际程序开发中，经常会出现一些比较字符串的程序模块，通过比较字符串是否相等，来实现某个要求。例如，通过比较两个字符串是否相等，来确认密码和用户名是否正确，从而判断是否可以登录系统。这个在系统登录界面中经常遇到。测试字符串是否相等的方法是“equals(String str)”。
【实例6.17】下面看一个具体的测试字符串是否相等的实例。
01 ///通过比较字符串str和str1两个字符串是否相同，来确定不同的输出
02 ///如果相同则输出"密码正确，请登录系统"
03 ///否则输出"密码不正确，请重新输入密码"
04 public class str17
05 {
06 public static void main(String[] args)
07 {
08 String str="administrator";
09 String str1="administrator";
10 if (str.equals(str1))
11 {System.out.println("密码正确，请登录系统");}
12 else
13 {System.out.println("密码不正确，请重新输入密码");}
14 }
15 }
【代码说明】第8～9行是两个字符串。第10行是判断语句，通过equals()方法判断两个指定的字符串是否相等。
【运行效果】
密码正确，请登录系统
在现实程序开发中，有的登录系统对于输入密码的大小写忽略。此时在Java语言中也有一个方法就是“equalsIgnoreCase(String str)”，这个方法忽略字符串大小写。
【实例6.18】下面看一个程序段的例子。
01 ///通过比较字符串str和str1两个字符串是否相同，来确定不同的输出，此时忽略大小写
02 ///如果相同则输出"密码正确，请登录系统"
03 ///否则输出"密码不正确，请重新输入密码"
04 public class str18
05 {
06 public static void main(String[] args)
07 {
08 String str="Administrator";
09 String str1="administrator";
10 if (str.equalsIgnoreCase(str1))
11 {System.out.println("密码正确，请登录系统");}
12 else
13 {System.out.println("密码不正确，请重新输入密码");}
14 }
15 }
【代码说明】第8～9行定义了两个字符串，它们的不同就是首字母是否大小写。第10行使用了equalsIgnoreCase()方法来进行判断。
【运行效果】
密码正确，请登录系统
以上的程序段是使用了忽略大小写的方法，比较两个字符串是否相等。
【实例6.19】下面将通过不忽略大小写的方法编写代码，并与上例相比较。
01 ///通过比较字符串str和str1两个字符串是否相同，来确定不同的输出，此时不忽略大小写
02 ///如果相同则输出"密码正确，请登录系统"
03 ///否则输出"密码不正确，请重新输入密码"
04 public class str19
05 {
06 public static void main(String[] args)
07 {
08 String str="Administrator";
09 String str1="administrator";
10 if (str.equals(str1))
11 {System.out.println("密码正确，请登录系统");}
12 else
13 {System.out.println("密码不正确，请重新输入密码");}
14 }
15 }
【代码说明】第8～9行是一个单词，不同的是首字母一个大写，一个小写。第10行的equals()方法在比较时并不忽略大小写，所以比较结果是false。
【运行效果】
密码不正确，请重新输入密码
6. 查找特定子串
在程序开发的过程中，有的系统提供查找子系统，用于查找自己需要的内容。在Java语言中，也提供了查找特定子串的功能，可以帮助查找自己需要的子字符串。
查找字符串子串有三个方法：
❑“indexOf（子串内容）”方法是帮助查找子串，如果返回的是负数，就表示在当前字符串中没有找到所查找的子串。
❑“startsWith（子串内容）”方法测试当前字符串是否以一个子串开始。
❑“endsWith（子串内容）”方法测试当前字符串是否以子串内容为结尾。
【实例6.20】下面看一下具体的程序段，通过实例读者会理解得更加透彻。
01 ///通过indexOf方法来查找字符串中的元素位置
02 ///通过endsWith来查找当前元素是否是字符串的结尾
03 ///通过startsWith来查找当前元素是否是字符串的开头
04 public class str20
05 {
06 public static void main(String[] args)
07 {
08 String str="是一个很优秀的程序员";
09 System.out.println(str.indexOf("个"));
10 System.out.println(str.endsWith("员"));
11 System.out.println(str.startsWith("明"));
12 }
13 }
【代码说明】str.indexOf(“个”)是测试字符串中的“个”这个子串的位置。str.endsWith(“员”)是测试字符串“员”是否是这个字符串的结尾。str.startsWith(“明”)是测试字符串“明”是否是这个字符串的开始。后面两个方法返回的是布尔型数据。
【运行效果】
2 true false
7. 从基本类型转换成字符串
使用“valueOf()”将基本类型的数据转换成相应的字符串。由于这个方法很简单，读者在后面的程序中会看到，这里不作详细的解释。
8. toString()方法
为什么会把这个方法提出来讲述呢？因为它是程序开发语言中非常重要的字符串处理方法。
【实例6.21】复习下面的程序段。
01 public class str21
02 {
03 public static void main(String[] args)
04 {
05 String str="小明是一个很优秀的程序员";
06 System.out.println(str);
07 }
08 }
【代码说明】第5行定义一个字符串str，第6行直接输出str。
【运行效果】
小明是一个很优秀的程序员
为什么可以直接将这个对象作为输出的参数呢？因为在Java语言内含一种机制，系统默认会在这些对象后面自动加上“toString()”方法。在Java类库的基本类中，每一个类都有一个“toString()”方法，可以将这个方法写出来，也可以直接使用对象来代替“toString()”方法。
【实例6.22】下面来看看这个方法的实际例子。
01 ///通过toString方法来输出对象的字符串形式
02 public class str22
03 {
04 public static void main(String[] args)
05 {
06 String str="小明是一个很优秀的程序员";
07 System.out.println(str.toString());
08 }
09 }
【代码说明】其实上面的程序段与前面的程序段输出一模一样。它们之间唯一不同的是，在输出语句中一个是把对象作为参数，将其内容输出。而上面的程序段则是直接运用“toString()”方法，将对象中的字符串提取出来，然后再进行输出。
【运行效果】
小明是一个很优秀的程序员
对于Java语言的类库来说，一般可以省去“toString()”方法，但如果是自己设计的类，最好加上这个方法，养成良好的编程习惯。
6.2.4 缓冲字符串处理类—StringBuffer
前面介绍过，“String”类一旦声明初始化后，是固定不变的。如果要改变它，就必须重新申请空间，重新声明和初始化。Java类库中有一个类，可以解决上面的问题，那就是缓冲字符串类—“StringBuffer”类。
当创建StringBuffer类对象时，系统为对象分配的内存会自动扩展，以容纳新增的内容。针对“StringBuffer”类创建对象时的构造器有两个，下面将详细地讲述。
6.2.5 缓冲字符串StringBuffer类的构造器
在这一小节中，将学习缓冲字符串类的构造器知识。通过学习来对比StringBuffer类和String类的不同点和相同点。
1. 默认的构造器
StringBuffer sb=new StringBuffer();
默认构造器是由系统自动分配容量，而系统容量默认值是16个字符。
【实例6.23】下面来看这个默认构造器的实例。
01 ///输出字符串的容量capacity
02 ///输出字符串的长度length
03 public class str23
04 {
05 public static void main(String[] args)
06 {
07 StringBuffer sb1=new StringBuffer();
08 System.out.println(sb1.capacity());
09 System.out.println(sb1.length());
10 }
11 }
【代码说明】这个程序段要说明的是，缓冲字符串对象的容量和缓冲字符串的长度。缓冲字符串的容量，就是指在刚刚创建对象时，系统分配的内存容量的大小。缓冲字符串的长度，则是指实际缓冲字符串对象的内存空间中，字符串的长度。在这个程序中，由于是默认的构造器，所以它的容量也是默认的，即16。由于它没有赋值，所以这个缓冲字符串对象的长度就是0。
【运行效果】
16 0
2. 设定容量大小的构造器
StringBuffer sb=new StringBuffer(int x)
“x”是设置容量的大小值。
【实例6.24】例如下面的语句。
01 ///输出字符串的容量capacity
02 ///输出字符串的长度length
03 public class str24
04 {
05 public static void main(String[] args)
06 {
07 StringBuffer sb1=new StringBuffer(100);
08 System.out.println(sb1.capacity());
09 System.out.println(sb1.length());
10 }
11 }
【代码说明】这里通过构造器设定了缓冲字符串对象的容量。虽然容量改变了，但长度仍然是零，因为它的内存空间中没有值。“capacity()”方法代表了字符串对象在内存中，可以容纳字符串的个数。如果想要扩充内存容量，可以使用方法“ensureCapacity()”。方法“length()”表示内存中已经存在的字符串的个数，如果想要改变字符串长度，可以使用“setLength()”方法。
【运行效果】
100 0
【实例6.25】下面看一个缓冲字符串实例。
01 ///输出字符串的容量capacity
02 ///输出字符串的长度length
03 public class str25
04 {
05 public static void main(String[] args)
06 {
07 StringBuffer sb=new StringBuffer(40);
08 System.out.println(sb.capacity());
09 sb.ensureCapacity(100);
10 System.out.println(sb.capacity());
11 }
12 }
【代码说明】这里通过构造器设定了缓冲字符串对象的容量，第一次是40。第9行使用方法“ensureCapacity()”扩充内存容量到100。
【运行效果】
40 100
6.2.6 缓冲字符串处理的方法
下面将学习StringBuffer类的一些主要方法。其实这些方法有很多与String类的方法很相似，通过学习可以进行比较。
1. 初始化字符串
StringBuffer sb=new StringBuffer(字符串);
使用这种形式的构造器，可以构建具有初始化文本的对象，容量大小就是字符串的长度。一旦创建了“StringBuffer”类的对象，就可以使用“StringBuffer”类的大量方法和属性。“StringBuffer”类最常用的是“append()”方法，它将文本内容添加到现有的“StringBuffer”对象内存中字符串的结尾处。
【实例6.26】下面看看这个方法应用的实例。
01 ///构造一个缓冲字符串类的对象
02 ///通过append方法，在这个对象后面添加一个新字符串
03 public class str26
04 {
05 public static void main(String[] args)
06 {
07 StringBuffer sb=new StringBuffer("小明是一个优秀");
08 sb.append("的程序员");
09 System.out.println(sb);
10 }
11 }
【代码说明】第8行使用append()方法将两个字符串连接在一起，有点像String类的concat()方法。
【运行效果】
小明是一个优秀的程序员
【实例6.27】前面讲了“setLength()”方法，现在通过实例了解其用法。
01 ///构造一个缓冲字符串类的对象
02 ///通过append方法，在这个对象后面添加一个新字符串
03 ///通过setLength方法来设置缓冲字符串对象的长度
04 public class str27
05 {
06 public static void main(String[] args)
07 {
08 StringBuffer sb=new StringBuffer("小明是一个优秀");
09 sb.append("的程序员");
10 sb.setLength(3);
11 System.out.println(sb);
12 }
13 }
【代码说明】第8行定义了字符串sb，第9行将两个字符串连接起来，此时字符串的长度是11。第10行指定字符串长度是3，所以读者要注意输出结果。
【运行效果】
小明是
2. 取字符串的单个字符
charAt()方法返回字符串中的单个字符。
【实例6.28】下面是这个方法的实例。
01 ///构造一个缓冲字符串类对象
02 ///返回指定位置的字符
03 public class str28
04 {
05 public static void main(String[] args)
06 {
07 StringBuffer sb=new StringBuffer("小明是一个优秀");
08 System.out.println(sb.charAt(3));
09 }
10 }
【代码说明】第7行定义了字符串sb，第8行指定输出sb的第四个元素，因为索引时从0开始的，所以代码是charAt(3)。
说明
除特殊情况外，基本上所有的索引都是从0开始。
【运行效果】
一
3. 单个字符串赋值
setCharAt()方法对字符串中的单个字符赋值或进行替换。
【实例6.29】下面是这个方法的实例。
01 ///构造一个缓冲字符串类对象
02 ///将指定位置的元素替换成新的字符
03 public class str29
04 {
05 public static void main(String[] args)
06 {
07 StringBuffer sb=new StringBuffer("小明是一个优秀程序员");
08 sb.setCharAt(0，'张');
09 System.out.println(sb);
10 }
11 }
【代码说明】“setCharAt()”方法使用的格式是“setCharAt（int index，char ch）”。上面的实例将字符串中的“小”替换成“张”。
【运行效果】
张明是一个优秀程序员
4. 指定位置插入字符串
insert()方法在字符串指定位置插入值。
【实例6.30】下面学习一个实例。
01 ///构造一个缓冲字符串类对象
02 ///使用insert方法将新字符串插入到指定的位置上
03 public class str30
04 {
05 public static void main(String[] args)
06 {
07 StringBuffer sb=new StringBuffer("我是一个优秀");
08 sb.insert(6，"的程序员");
09 System.out.println(sb);
10 }
11 }
【代码说明】第8行的结构就是“insert（int index，string str）”。最终的结果其实是连接了两个字符串，因为指定的位置正好是字符串sb的结束位置。
【运行效果】
我是一个优秀的程序员
上面的这个例子有点像“append()”方法。
【实例6.31】下面再看一个实例。
01 ///构造一个缓冲字符串类对象
02 ///使用append方法连接字符串
03 public class str32
04 {
05 public static void main(String[] args)
06 {
07 StringBuffer sb=new StringBuffer("我是一个优秀的");
08 sb.append("程序员");
09 System.out.println(sb);
10 }
11 }
【代码说明】第8行使用了“append()”方法实现了和上一个实例相同的功能。
【运行效果】
我是一个优秀的程序员
5. 返回字符串的子串
substring()方法返回字符串的一个子串。
【实例6.32】下面是这个方法的实例。
01 ///构造一个缓冲字符串类对象
02 ///使用substring方法返回指定位置开始到结束位置的子串
03 public class str33
04 {
05 public static void main(String[] args)
06 {
07 StringBuffer sb=new StringBuffer("我是一个程序员");
08 System.out.println(sb.substring(2));
09 }
10 }
【代码说明】这个程序段返回的是，从字符串的第三个位置开始，到最后位置之间的子字符串。
【运行效果】
一个程序员
【实例6.33】针对这个方法，再看看下面的实例。
01 ///构造一个缓冲字符串类对象
02 ///使用substring方法返回指定位置开始到另一个指定位置结束的子串
03 public class str34
04 {
05 public static void main(String[] args)
06 {
07 StringBuffer sb=new StringBuffer("我是一个程序员");
08 System.out.println(sb.substring(2，7));
09 }
10 }
【代码说明】其实这个方法同“String”类中的方法用法相同。返回从开始位置到结束位置之间的字符串。
【运行效果】
一个程序员
6. 倒置字符串的内容
reverse()方法用来倒置“StringBuffer”的内容。
【实例6.34】下面针对这个方法看一个实例。
01 ///构造一个缓冲字符串类对象
02 ///将字符串倒置后输出
03 public class str35
04 {
05 public static void main(String[] args)
06 {
07 StringBuffer sb=new StringBuffer("我是一个程序员");
08 System.out.println(sb.reverse());
09 }
10 }
【代码说明】这段代码比较简单，第8行直接调用reverse()方法，不需要任何参数。
【运行效果】
员序程个一是我
6.2.7 缓冲字符串类的特点
字符串是绝大多数应用程序经常使用且不可缺少的对象之一。由于缓冲字符串类有着比字符串类更加宽裕的空间，所以缓冲字符串可以用来处理一些动态字符串，而一般字符串类只能处理静态的不可变化的字符串。