《Java從小白到大牛》之第9章 字符串

《Java從小白到大牛》紙質版已經上架了！！！


Java從小白到大牛書皮

由字符組成的一串字符序列，稱為“字符串”，在前面的章節中也多次用到了字符串，本章將重點介紹。

Java中的字符串 {#java}

Java中的字符串是由雙引號括起來的多個字符，下面示例都是表示字符串常量：

"Hello World"                                                           ①
"\u0048\u0065\u006c\u006c\u006f\u0020\u0057\u006f\u0072\u006c\u0064"        ②
"世界你好"                                                              ③
"A"                                                                 ④
""                                                                  ⑤

Java中的字符采用Unicode編碼，所以Java字符串可以包含中文等亞洲字符，見代碼第③行的"世界你好"字符串。代碼第②行的字符串是用Unicode編碼表示的字符串，事實上它表示的也是"Hello World"字符串，可通過System.out.print方法將Unicode編碼表示的字符串輸出到控制臺，則會看到Hello World字符串。

另外，單個字符如果用雙引號括起來，那它表示的是字符串，而不是字符了，見代碼第④行的"A"是表示字符串A，而不是字符A。

注意 字符串還有一個極端情況，就代碼第⑤行的""表示空字符串，雙引號中沒有任何內容，空字符串不是null，空字符串是分配內存空間，而null是沒有分配內存空間。

Java SE提供了三個字符串類：String、StringBuffer和StringBuilder。String是不可變字符串，StringBuffer和StringBuilder是可變字符串。

使用API文檔 {#api}

Java中很多類，每一個類又有很多方法和變量，通過查看Java API文檔能夠知道這些類、方法和變量如何使用。Java官方為Java SE提供了基于HTML的API文檔。作為Java程序員應該熟悉如何使用API文檔。

本節介紹一下如何使用Java SE的API文檔。Java官方提供了Java 8在線API文檔，網址是http://docs.oracle.com/javase/8/docs/api/，頁面如圖9-1所示。

圖9-1　Java 8在線API文檔

提示 很多讀者希望能夠有離線的中文Java API文檔，但Java官方只提供了Java 6的中文API文檔，該文件下載地址是http://download.oracle.com/technetwork/java/javase/6/docs/zh/api.zip，下載完成后解壓api.zip文件，找到其中的index.html文件，雙擊就會在瀏覽器中打開API文檔了。

下面介紹一下如何使用API文檔，熟悉一下API文檔頁面中的各個部分含義，如圖9-2所示，類和接口中，斜文字體顯示是接口，正常字體才是類。

圖9-2　API文檔頁面各個部分

在類窗口還有很多內容，向下拖曳滾動條會看到如圖9-3所示頁面，其中“字段摘要”描述了類中的實例變量和靜態變量；“構造方法摘要”描述了類中所有構造方法；“方法摘要”描述了類中所有方法。這些“摘要”只是一個概要說明，單擊鏈接可以進入到該主題更加詳細的描述，如圖9-4所示單擊了compareTo方法看到的詳細信息。

圖9-3　類窗口頁面其他內容
圖9-4　 compareTo方法詳細描述

查詢API的一般流程是：找包→找類或接口→查看類或接口→找方法或變量。讀者可以嘗試查找一下String、StringBuffer和StringBuilder這些字符串類的API文檔，熟悉一下這些類的用法。

不可變字符串

很多計算機語言都提供了兩種字符串，即不可變字符串和可變字符串，它們區別在于當字符串進行拼接等修改操作時，不可變字符串會創建新的字符串對象，而可變字符串不會創建新對象。

String {#string}

Java中不可變字符串類是String，屬于java.lang包，它也是Java非常重要的類。

提示 java.lang包中提供了很多Java基礎類，包括Object、Class、String和Math等基本類。在使用java.lang包中的類時不需要引入（import）該包，因為它是由解釋器自動引入的。當然引入java.lang包程序也不會有編譯錯誤。

創建String對象可以通過構造方法實現，常用的構造方法：

  • String()：使用空字符串創建并初始化一個新的String對象。
  • String(String original)：使用另外一個字符串創建并初始化一個新的 String 對象。
  • String(StringBuffer buffer)：使用可變字符串對象（StringBuffer）創建并初始化一個新的 String 對象。
  • String(StringBuilder builder)：使用可變字符串對象（StringBuilder）創建并初始化一個新的 String 對象。
  • String(byte[] bytes)：使用平臺的默認字符集解碼指定的byte數組，通過byte數組創建并初始化一個新的 String 對象。
  • String(char[] value)：通過字符數組創建并初始化一個新的 String 對象。
  • String(char[] value, int offset, int count)：通過字符數組的子數組創建并初始化一個新的 String 對象；offset參數是子數組第一個字符的索引，count參數指定子數組的長度。

創建字符串對象示例代碼如下：

// 創建字符串對象

String s1 = new String();

String s2 = new String("Hello World");

String s3 = new String("\u0048\u0065\u006c\u006c\u006f\u0020\u0057\u006f\u0072\u006c\u0064");

System.out.println("s2 = " + s2);

System.out.println("s3 = " + s3);

char chars[] = { 'a', 'b', 'c', 'd', 'e' };

// 通過字符數組創建字符串對象

String s4 = new String(chars);

// 通過子字符數組創建字符串對象

String s5 = new String(chars, 1, 4);

System.out.println("s4 = " + s4);

System.out.println("s5 = " + s5);

byte bytes[] = { 97, 98, 99 };

// 通過byte數組創建字符串對象

String s6 = new String(bytes);

System.out.println("s6 = " + s6);

System.out.println("s6字符串長度 = " + s6.length());

輸出結果：

s2 = Hello World

s3 = Hello World

s4 = abcde

s5 = bcde

s6 = abc

s6字符串長度 = 3

上述代碼中s2和s3都是表示Hello World字符串，獲得字符串長度方法是length()，其他代碼比較簡單，這里不再贅述。

字符串池 {#-0}

在前面的學習過程中細心的讀者可能會發現，前面的示例代碼中獲得字符串對象時都是直接使用字符串常量，但Java中對象是使用new關鍵字創建，字符串對象也可以使用new關鍵字創建，代碼如下：

String s9 = "Hello"; //字符串常量

String s7 = new String("Hello"); //使用new關鍵字創建

使用new關鍵字與字符串常量都能獲得字符串對象，但它們之間有一些區別。先看下面代碼運行結果：

String s7 = new String("Hello"); ①

String s8 = new String("Hello"); ②

String s9 = "Hello"; ③

String s10 = "Hello"; ④

System.out.printf("s7 == s8 : %b%n", s7 == s8);

System.out.printf("s9 == s10: %b%n", s9 == s10);

System.out.printf("s7 == s9 : %b%n", s7 == s9);

System.out.printf("s8 == s9 : %b%n", s8 == s9);

輸出結果：

s7 == s8 : false

s9 == s10: true

s7 == s9 : false

s8 == s9 : false

==運算符比較的是兩個引用是否指向相同的對象，從上面的運行結果可見，s7和s8指的是不同對象，s9和s10指向的是相同對象。

這是為什么？Java中的不可變字符串String常量，采用字符串池（String Pool）管理技術，字符串池是一種字符串駐留技術。采用字符串常量賦值時（見代碼第③行），如圖9-5所示，會字符串池中查找"Hello"字符串常量，如果已經存在把引用賦值給s9，否則創建"Hello"字符串對象，并放到池中。根據此原理，可以推定s10與s9是相同的引用，指向同一個對象。但此原理并不適用于new所創建的字符串對象，代碼運行到第①行后，會創建"Hello"字符串對象，而它并沒有放到字符串池中。代碼第②行又創建了一個新的"Hello"字符串對象，s7和s8是不同的引用，指向不同的對象。

圖9-5　字符串池

字符串拼接 {#-1}

String字符串雖然是不可變字符串，但也可以進行拼接只是會產生一個新的對象。String字符串拼接可以使用+運算符或String的concat(String str)方法。+運算符優勢是可以連接任何類型數據拼接成為字符串，而concat方法只能拼接String類型字符串。

字符串拼接示例如下：

String s1 = "Hello";

// 使用+運算符連接

String s2 = s1 + " "; ①

String s3 = s2 + "World"; ②

System.out.println(s3);

String s4 = "Hello";

// 使用+運算符連接，支持+=賦值運算符

s4 += " "; ③

s4 += "World"; ④

System.out.println(s4);

String s5 = "Hello";

// 使用concat方法連接

s5 = s5.concat(" ").concat("World"); ⑤

System.out.println(s5);

int age = 18;

String s6= "她的年齡是" + age + "歲。"; ⑥

System.out.println(s6);

char score = 'A';

String s7= "她的英語成績是" + score; ⑦

System.out.println(s7);

java.util.Date now = new java.util.Date(); ⑧

//對象拼接自動調用toString()方法

String s8= "今天是：" + now; ⑨

System.out.println(s8);

輸出結果：

Hello World

Hello World

Hello World

她的年齡是18歲。

她的英語成績是A

今天是：Thu May 25 16:25:40 CST 2017

上述代碼第①②行使用+運算符進行字符串的拼接，其中產生了三個對象。代碼第③④行業是使用+=賦值運算符，本質上也是+運算符進行拼接。

代碼第⑤行采用concat方法進行拼接，該方法的完整定義如下：

public String concat(String str)

它的參數和返回值都是String，因此代碼第⑤行可以連續調用該方法進行多個字符串的拼接。

代碼第⑥和第⑦行是使用+運算符，將字符串與其他類型數據進行的拼接。代碼第⑨行是與對象可以進行拼接，Java中所有對象都有一個toString()方法，該方法可以將對象轉換為字符串，拼接過程會調用該對象的toString()方法，將該對象轉換為字符串后再進行拼接。代碼第⑧行的java.util.Date類是Java SE提供的日期類。

字符串查找 {#-2}

在給定的字符串中查找字符或字符串是比較常見的操作。在String類中提供了indexOf和lastIndexOf方法用于查找字符或字符串，返回值是查找的字符或字符串所在的位置，-1表示沒有找到。這兩個方法有多個重載版本：

  • int indexOf(int ch)：從前往后搜索字符ch，返回第一次找到字符ch所在處的索引。
  • int indexOf(int ch, int fromIndex)：從指定的索引開始從前往后搜索字符ch，返回第一次找到字符ch所在處的索引。
  • int indexOf(String str)：從前往后搜索字符串str，返回第一次找到字符串所在處的索引。
  • int indexOf(String str, int fromIndex)：從指定的索引開始從前往后搜字符串str，返回第一次找到字符串所在處的索引。
  • int lastIndexOf(int ch)：從后往前搜索字符ch，返回第一次找到字符ch所在處的索引。
  • int lastIndexOf(int ch, int fromIndex)：從指定的索引開始從后往前搜索字符ch，返回第一次找到字符ch所在處的索引。
  • int lastIndexOf(String str)：從后往前搜索字符串str，返回第一次找到字符串所在處的索引。
  • int lastIndexOf(String str, int fromIndex)：從指定的索引開始從后往前搜索字符串str，返回第一次找到字符串所在處的索引。

[圖片上傳中...(10-6.jpg-790da8-1530662260524-0)]
提示 字符串本質上是字符數組，因此它也有索引，索引從零開始。String的charAt(int index)方法可以返回索引index所在位置的字符。

字符串查找示例代碼如下：

String sourceStr = "There is a string accessing example.";

//獲得字符串長度

int len = sourceStr.length();

//獲得索引位置16的字符

char ch = sourceStr.charAt(16);

//查找字符和子字符串

int firstChar1 = sourceStr.indexOf('r');

int lastChar1 = sourceStr.lastIndexOf('r');

int firstStr1 = sourceStr.indexOf("ing");

int lastStr1 = sourceStr.lastIndexOf("ing");

int firstChar2 = sourceStr.indexOf('e', 15);

int lastChar2 = sourceStr.lastIndexOf('e', 15);

int firstStr2 = sourceStr.indexOf("ing", 5);

int lastStr2 = sourceStr.lastIndexOf("ing", 5);

System.out.println("原始字符串:" + sourceStr);

System.out.println("字符串長度:" + len);

System.out.println("索引16的字符:" + ch);

System.out.println("從前往后搜索r字符，第一次找到它所在索引:" + firstChar1);

System.out.println("從后往前搜索r字符，第一次找到它所在的索引:" + lastChar1);

System.out.println("從前往后搜索ing字符串，第一次找到它所在索引:" + firstStr1);

System.out.println("從后往前搜索ing字符串，第一次找到它所在索引:" + lastStr1);

System.out.println("從索引為15位置開始，從前往后搜索e字符，第一次找到它所在索引:" + firstChar2);

System.out.println("從索引為15位置開始，從后往前搜索e字符，第一次找到它所在索引:" + lastChar2);

System.out.println("從索引為5位置開始，從前往后搜索ing字符串，第一次找到它所在索引:" + firstStr2);

System.out.println("從索引為5位置開始，從后往前搜索ing字符串，第一次找到它所在索引:" + lastStr2);

輸出結果：

原始字符串:There is a string accessing example.

字符串長度:36

索引16的字符:g

從前往后搜索r字符，第一次找到它所在索引:3

從后往前搜索r字符，第一次找到它所在的索引:13

從前往后搜索ing字符串，第一次找到它所在索引:14

從后往前搜索ing字符串，第一次找到它所在索引:24

從索引為15位置開始，從前往后搜索e字符，第一次找到它所在索引:21

從索引為15位置開始，從后往前搜索e字符，第一次找到它所在索引:4

從索引為5位置開始，從前往后搜索ing字符串，第一次找到它所在索引:14

從索引為5位置開始，從后往前搜索ing字符串，第一次找到它所在索引:-1

sourceStr字符串索引如圖9-6所示。上述字符串查找方法比較類似，這里重點解釋一下sourceStr.indexOf("ing", 5)和sourceStr.lastIndexOf("ing", 5)表達式。從圖9-6可見ing字符串出現過兩次，索引分別是14和24。sourceStr.indexOf("ing", 5)表達式從索引為5的字符（" "）開始從前往后搜索，結果是找到第一個ing（索引為14），返回值為14。sourceStr.lastIndexOf("ing", 5)表達式從索引為5的字符（" "）開始從后往前搜索，沒有找到，返回值為-1。

圖9-6　sourceStr字符串索引

字符串比較 {#-3}

字符串比較是常見的操作，包括比較相等、比較大小、比較前綴和后綴串等。

  1. 比較相等

String提供的比較字符串相等的方法：

  • boolean equals(Object anObject)：比較兩個字符串中內容是否相等。
  • boolean equalsIgnoreCase(String anotherString)：類似equals方法，只是忽略大小寫。
  1. 比較大小

有時不僅需要知道是否相等，還要知道大小，String提供的比較大小的方法：

  • int compareTo(String anotherString)：按字典順序比較兩個字符串。如果參數字符串等于此字符串，則返回值 0；如果此字符串小于字符串參數，則返回一個小于 0 的值；如果此字符串大于字符串參數，則返回一個大于 0 的值。
  • int compareToIgnoreCase(String str)：類似compareTo，只是忽略大小寫。
  1. 比較前綴和后綴
  • boolean endsWith(String suffix)：測試此字符串是否以指定的后綴結束。
  • boolean startsWith(String prefix)：測試此字符串是否以指定的前綴開始。

字符串比較示例代碼如下：

String s1 = new String("Hello");

String s2 = new String("Hello");

// 比較字符串是否是相同的引用

System.out.println("s1 == s2 : " + (s1 == s2));

// 比較字符串內容是否相等

System.out.println("s1.equals(s2) : " + (s1.equals(s2)));

String s3 = "HELlo";

// 忽略大小寫比較字符串內容是否相等

System.out.println("s1.equalsIgnoreCase(s3) : " + (s1.equalsIgnoreCase(s3)));

// 比較大小

String s4 = "java";

String s5 = "Swift";

// 比較字符串大小 s4 > s5

System.out.println("s4.compareTo(s5) : " + (s4.compareTo(s5))); ①

// 忽略大小寫比較字符串大小 s4 < s5

System.out.println("s4.compareToIgnoreCase(s5) : " + (s4.compareToIgnoreCase(s5))); ②

// 判斷文件夾中文件名

String[] docFolder = { "java.docx", " JavaBean.docx", "Objecitve-C.xlsx", "Swift.docx " };

int wordDocCount = 0;

// 查找文件夾中Word文檔個數

for (String doc : docFolder) {

// 去的前后空格

doc = doc.trim(); ③

// 比較后綴是否有.docx字符串

if (doc.endsWith(".docx")) {

wordDocCount++;

}

}

System.out.println("文件夾中Word文檔個數是： " + wordDocCount);

int javaDocCount = 0;

// 查找文件夾中Java相關文檔個數

for (String doc : docFolder) {

// 去的前后空格

doc = doc.trim();

// 全部字符轉成小寫

doc = doc.toLowerCase(); ④

// 比較前綴是否有java字符串

if (doc.startsWith("java")) {

javaDocCount++;

}

}

System.out.println("文件夾中Java相關文檔個數是：" + javaDocCount);

輸出結果：

s1 == s2 : false

s1.equals(s2) : true

s1.equalsIgnoreCase(s3) : true

s4.compareTo(s5) : 23

s4.compareToIgnoreCase(s5) : -9

文件夾中Word文檔個數是： 3

文件夾中Java相關文檔個數是：2

上述代碼第①行的compareTo方法按字典順序比較兩個字符串，s4.compareTo(s5)表達式返回結果大于0，說明s4大于s5，字符在字典中順序事實上就它的Unicode編碼，先比較兩個字符串的第一個字符j和S，j的Unicode編碼是106，S的Unicode編碼是83，所以可以得出結論s4 > s5。代碼第②行是忽略大小寫時，要么全部當成小寫字母進行比較，要么當前成全部大寫字母進行比較，無論哪種比較結果都是一樣的s4 < s5。

代碼第③行trim()方法可以去除字符串前后空白。代碼第④行toLowerCase()方法可以將此字符串全部轉化為小寫字符串，類似的方法還有toLowerCase()方法，可將字符串全部轉化為小寫字符串。

字符串截取 {#-4}

Java中字符串String截取方法主要的方法如下：

  • String substring(int beginIndex)：從指定索引beginIndex開始截取一直到字符串結束的子字符串。
  • String substring(int beginIndex, int endIndex)：從指定索引beginIndex開始截取直到索引endIndex - 1處的字符，注意包括索引為beginIndex處的字符，但不包括索引為endIndex處的字符。

字符串截取方法示例代碼如下：

String sourceStr = &quot;There is a string accessing example.&quot;;

// 截取example.子字符串

String subStr1 = sourceStr.substring(28); ①

// 截取string子字符串

String subStr2 = sourceStr.substring(11, 17); ②

System.out.printf(&quot;subStr1 = %s%n&quot;, subStr1);

System.out.printf(&quot;subStr2 = %s%n&quot;,subStr2);

// 使用split方法分割字符串

System.out.println(&quot;-----使用split方法-----&quot;);

String[] array = sourceStr.split(&quot; &quot;); ③

for (String str : array) {

System.out.println(str);

}

輸出結果：

subStr1 = example.

subStr2 = string

-----使用split方法-----

There

is

a

string

accessing

example.

上述sourceStr字符串索引參考圖9-6所示。代碼第①行是截取example.子字符串，從圖9-6可見e字符索引是28, 從索引28字符截取直到sourceStr結尾。代碼第②行是截取string子字符串，從圖9-6可見，s字符索引是11，g字符索引是16，endIndex參數應該17。

另外，String還提供了字符串分割方法，見代碼第③行split(" ")方法，參數是分割字符串，返回值String[]。

可變字符串

可變字符串在追加、刪除、修改、插入和拼接等操作不會產生新的對象。

StringBuffer和StringBuilder {#stringbuffer-stringbuilder}

Java提供了兩個可變字符串類StringBuffer和StringBuilder，中文翻譯為“字符串緩沖區”。

StringBuffer是線程安全的，它的方法是支持線程同步[1]，線程同步會操作串行順序執行，在單線程環境下會影響效率。StringBuilder是StringBuffer單線程版本，Java 5之后發布的，它不是線程安全的，但它的執行效率很高。

StringBuffer和StringBuilder具有完全相同的API，即構造方法和方法等內容一樣。StringBuilder的中構造方法有4個：

  • StringBuilder()：創建字符串內容是空的StringBuilder對象，初始容量默認為16個字符。
  • StringBuilder(CharSequence seq)：指定CharSequence字符串創建StringBuilder對象。CharSequence接口類型，它的實現類有：String、StringBuffer和StringBuilder等，所以參數seq可以是String、StringBuffer和StringBuilder等類型。
  • StringBuilder(int capacity)：創建字符串內容是空的StringBuilder對象，初始容量由參數capacity指定的。
  • StringBuilder(String str)：指定String字符串創建StringBuilder對象。

上述構造方法同樣適合于StringBuffer類，這里不再贅述。

提示 字符串長度和字符串緩沖區容量區別。字符串長度是指在字符串緩沖區中目前所包含字符串長度，通過length()獲得；字符串緩沖區容量是緩沖區中所能容納的最大字符數，通過capacity()獲得。當所容納的字符超過這長度時，字符串緩沖區自動擴充容量，但這是以犧牲新能為代價的擴容。

字符串長度和字符串緩沖區容量示例代碼如下：

// 字符串長度length和字符串緩沖區容量capacity

StringBuilder sbuilder1 = new StringBuilder();

System.out.println(&quot;包含的字符串長度：&quot; + sbuilder1.length());

System.out.println(&quot;字符串緩沖區容量：&quot; + sbuilder1.capacity());

StringBuilder sbuilder2 = new StringBuilder(&quot;Hello&quot;);

System.out.println(&quot;包含的字符串長度：&quot; + sbuilder2.length());

System.out.println(&quot;字符串緩沖區容量：&quot; + sbuilder2.capacity());

// 字符串緩沖區初始容量是16，超過之后會擴容

StringBuilder sbuilder3 = new StringBuilder();

for (int i = 0; i &lt; 17; i++) {

sbuilder3.append(8);

}

System.out.println(&quot;包含的字符串長度：&quot; + sbuilder3.length());

System.out.println(&quot;字符串緩沖區容量：&quot; + sbuilder3.capacity());

輸出結果：

包含的字符串長度：0

字符串緩沖區容量：16

包含的字符串長度：5

字符串緩沖區容量：21

包含的字符串長度：17

字符串緩沖區容量：34

### 字符串追加 {#-0}

StringBuilder在提供了很多修改字符串緩沖區的方法，追加、插入、刪除和替換等，這一節先介紹字符串追加方法。字符串追加方法是append，append有很多重載方法，可以追加任何類型數據，它的返回值還是StringBuilder。StringBuffer的追加法與StringBuffer完全一樣，這里不再贅述。

字符串追加示例代碼如下：

//添加字符串、字符

StringBuilder sbuilder1 = new StringBuilder(&quot;Hello&quot;); ①

sbuilder1.append(&quot; &quot;).append(&quot;World&quot;); ②

sbuilder1.append(&#039;.&#039;); ③

System.out.println(sbuilder1);

StringBuilder sbuilder2 = new StringBuilder();

Object obj = null;

//添加布爾值、轉義符和空對象

sbuilder2.append(false).append(&#039;\t&#039;).append(obj); ④

System.out.println(sbuilder2);

//添加數值

StringBuilder sbuilder3 = new StringBuilder();

for (int i = 0; i &lt; 10; i++) {

sbuilder3.append(i);

}

System.out.println(sbuilder3);

運行結果：

Hello World.

false null

0123456789

上述代碼第①行是創建一個包含Hello字符串StringBuilder對象。代碼第②行是兩次連續調用append方法，由于所有的append方法都返回StringBuilder對象，所有可以連續調用該方法，這種寫法比較簡潔。如果連續調用append方法不行喜歡，可以append方法占一行，見代碼第③行。

代碼第④行連續追加了布爾值、轉義符和空對象，需要注意的是布爾值false轉換為false字符串，空對象null也轉換為"null"字符串。

字符串插入、刪除和替換 {#-1}

StringBuilder中實現插入、刪除和替換等操作的常用方法說明如下：

  • StringBuilder insert(int offset, String str)：在字符串緩沖區中索引為offset的字符位置之前插入str，insert有很多重載方法，可以插入任何類型數據。
  • StringBuffer delete(int start, int end)：在字符串緩沖區中刪除子字符串，要刪除的子字符串從指定索引start開始直到索引end - 1處的字符。start和end兩個參數與substring(int beginIndex, int endIndex)方法中的兩個參數含義一樣。
  • StringBuffer replace(int start, int end, String str)字符串緩沖區中用str替換子字符串，子字符串從指定索引start開始直到索引end - 1處的字符。start和end同delete(int start, int end)方法。

以上介紹的方法雖然是StringBuilder方法，但StringBuffer也完全一樣，這里不再贅述。

示例代碼如下：

// 原始不可變字符串

String str1 = &quot;Java C&quot;;

// 從不可變的字符創建可變字符串對象

StringBuilder mstr = new StringBuilder(str1);

// 插入字符串

mstr.insert(4, &quot; C++&quot;); ①

System.out.println(mstr);

// 具有追加效果的插入字符串

mstr.insert(mstr.length(), &quot; Objective-C&quot;); ②

System.out.println(mstr);

// 追加字符串

mstr.append(&quot; and Swift&quot;);

System.out.println(mstr);

// 刪除字符串

mstr.delete(11, 23); ③

System.out.println(mstr);

運行輸出結果：

Java C++ C

Java C++ C Objective-C

Java C++ C Objective-C and Swift

Java C++ C and Swift

上述代碼第①行mstr.insert(4, " C++")是在索引4，插入字符串，原始字符串索引如同9-7所示，索引4位置是一個空格，在它之前插入字符串。代碼第②行mstr.insert(mstr.length(), " Objective-C")是按照字符串的長的插入，也就是在尾部追加字符串。在執行代碼第③行刪除字符串之前的字符串如圖9-8所示，mstr.delete(11, 23)語句是要刪除"Objective-C "子字符串，第一個參數是子字符串開始索引11；第二個參數是23，結束字符的索引是22（end - 1），所以參數end是23。

圖9-7　原始字符串索引
圖9-8　刪除之前字符串索引

本章小結

本周介紹了Java中的字符串，Java字符串類分為：可變字符串類（String）和不可變字符串類（StringBuilder和StringBuffer）。然后分別介紹了這些字符串類的用法。

配套視頻

http://www.zhijieketang.com/classroom/6/courses

配套源代碼

http://www.zhijieketang.com/group/5

與本書免費版對應的還有一個收費版本：

  1. 進入百度閱讀電子書

  2. 進入圖靈社區電子書

  1. 線程同步是一個多線程概念，就是當多個線程訪問一個方法時，只能由一個優先級別高的線程先訪問，在訪問期間會鎖定該方法，其他線程只能等到它訪問完成釋放鎖，才能訪問。有關多線程問題將在后面章節詳細介紹。 ?

?著作權歸作者所有,轉載或內容合作請聯系作者
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發布，文章內容僅代表作者本人觀點，簡書系信息發布平臺，僅提供信息存儲服務。

推薦閱讀更多精彩內容