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()”獲取。

【實例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)。

【運行效果】

一

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 緩沖字符串類的特點

字符串是絕大多數應用程序經常使用且不可缺少的對象之一。由于緩沖字符串類有著比字符串類更加寬裕的空間，所以緩沖字符串可以用來處理一些動態字符串，而一般字符串類只能處理靜態的不可變化的字符串。