Java.lang包——字串類(String, StringBuffer)
Java.lang 包——字串類 (String, StringBuffer)
作者： zccst
先提及一下陣列， 與 C++ 不同的是， Java 中 所有的陣列都是動態分配儲存空間。一但分配了儲存空間，就不能在程式中改變陣列長度，但可以用 new 重新分配空間。在 Java 中，陣列是一種類，有自己的屬性和方法。比較常用的是 length 方法，用於返回陣列的長度。
回憶一下嚴蔚敏 C 語言描述的《資料結構》（第二版），都有哪幾種資料結構？
常見的是：
1. 線性表（包括順序表和連結串列）
2. 堆疊和佇列
3. 串
4. 陣列和廣義表
5. 樹和二叉樹
6. 圖
既然陣列在 Java 中封裝成類，不難發現，其實這些資料結構在 java 中全部封裝成了類。串也不例外，所以也封裝成了類。
字串類—— String 類和 StringBuffer 類
程式中用到的字串可以分為兩類：
1. String 類：建立之後不能再修改和變動的字串常量。
String 被 java 的開發者構造得非常接近基本資料型別，換句話說，在很多時候可以象使用基本資料型別一樣來使用
// 聲明瞭一個空字串 s
String s ；
String ss = ” 建立了一個字串 ”;
// 聲明瞭一個空字串 s
String s = new String();
String ss = new String(” 建立了一個字串 ”);
String []sa = new String[]{” 建立了一個字串 ”, “ 陣列 ”};
常用的方法有：
int length() // 返回字串長度
boolean equals(Object anObject) //
String substring(int beginIndex) // 返回從 beginindex 開始的子串。
String substring(int beginIndex,int endIndex) // 返回從 beginIndex 到 endIndex 的子串
char charAt(int index) // 返回 index 指定位置的字元
int indexOf(String str) // 返回 str 在字串第一次出現的位置
String replace(char oldChar,char newChar) // 替換字串中所有的 oldChar 子串
更多方法請查閱本文《附錄 1 ： String 類的常用方法》
2. StringBuffer 類：建立之後可以修改和變動的字串變數。即能插入字元，也能追加字元到串尾。 StringBuffer 類物件的長度是可變的（即 StringBuff 是可變長的字串物件 ）。
常用方法有：
int length(); // 獲取當前物件的長度
int capacity(); // 獲取當前物件的容量。
StringBuff append( …… ); // 將物件，字串等新增到 StringBuff 物件中去。
StringBuff insert(int offset, …… ); // 將物件，字串等插入到指定的位置。
其中主要的方法是 append 和 insert ，可以過載和接收任何型別的資料。
String 類和 StringBuffer 類都在 java 的 lang 包中，並被定義為最終類，不能再派生子類。
如果你只是瞭解一下，可以到此為止。如果你想深入理解字串類，請繼續下去。
本文框架（本文由以下內容構成）：
String 類（構造方法，常用方法，例項）
StringBuffer 類（構造方法，常用方法，例項）
字串類總結（特點比較）
附錄 1 ： String 類的常用方法（表格形式，方便查詢）
附錄 2 ： StringTokenizer 類（擴充套件知識）
String 類
一、 String 類——常用構造方法
String() 用來建立一個空的字串常量
String(String str) 利用一個已經存在的字串常量，來建立一個新的 String 物件
String(StringBuffer buf) 利用一個已經存在的 StringBuffer 物件，來建立新的 String 物件
String(char c[]) 利用已經存在的字元陣列的內容，來建立新的 String 物件
其原型是：
1. 用擴在雙引號 (“”) 裡面的一串字串做引數構造字串
Public String(String value);
2. 用字元作為建構函式
Public String(char value[]);
Public String(char value, int offset, int count);
3. 用指定的緩衝字串物件 buffer 構造字串物件
Public String(StringBuffer buffer);
4. 用位元組陣列作為引數構造字串
Public String(byte[] bytes);
Public String(byte[] bytes, String enc);
Public String(byte[] bytes, int offset, int length);
Public String(byte[] bytes, int offset, int length, String enc);
舉例
String str = new String(“I like Java”);
Char ch[] = {‘a’, ‘b’, ‘c’, ‘d’, ‘e’};
String s1 = new String(ch); // s1 為 ”abcde”
String s2 = new String(ch, 2, 3); // s2 為 ”cde”
StringBuffer buff = new StringBuffer();
Buff.append(“a”);
Buff.append(“5.6”);
String s1 = new String(buff); // s1 為 ”a5.6”
二、 String 類——常用方法
1 ，求字串長度
public int Length() // 用於獲得當前字串物件中字元的個數
例： String s = “ 歡迎使用 java 語言 ”;
Int len = s.length();
結果： len = 10
注： java 採用 Unicode 編碼，每個字元為 16 為長，因此漢字和其他符號一樣只佔用一個字元。
2 ，字串連線
public String concat(String str) // 用於將字串 str 連線在當前字串的尾部，並返回新的字串
例： “to”.concat(“get”).concat(“her”) 的返回值為 ”together” 。
例： String str = “hello”;
str = str + “world” +2;
str 的值為 ”hello world 2”;
注：利用 ” + ” ，編譯器講自動把非字串轉換為字串再進行連線。
3 ，字串比較
boolean equals(Object o) // 用於將當前字串與方法引數列表中給出的字串物件 o 作比較，若相同則返回 true ，否則返回 false ，區分大小寫
boolean equalsIgnoreCase(String str) // 用於將當前字串與方法引數列表中給出的字串物件 str 作比較，若相同則返回 true ，否則返回 false ，不區分大小寫
int compareTo(String str) // 用於將當前字串與引數中字串物件 str 作比較，若完全相同則返回 0 ；若按字母順序大於引數字串，則返回一個大於 0 的整數；反之，則返回一個小於 0 的整數
int compareTo(Object object)
int compareToIgnoreCase(String str)
例： String str3 = “This”;
String str2 = “That”;
System.out.println(“ 結果 1 ： ”+str3.equals(“this”)+”,”+str3.equalsIgnoreCase(”this”));
System.out.println(“ 結果 2 ： ”+str2. compareTo (“that”)+”,”+str2. compareTo IgnoreCase(”that”));
輸出：結果 1 ： false, true;
結果 2 ： -32,0;
注：在前文《 Java.lang 包—— Object 類》中使用關係運算符“ == ”判定兩個 object ，作為繼承了 object 類的字串類，同理也可以用“ == ”判定兩個字串是否相等，並且其使用規則也一樣。
4 ，轉化字串的大小寫
Public String toLowerCase() // 將字串中所有的大寫字母轉換成小寫
Public String toUpperCase() ， // 將字串中所有的小寫字母轉換成大寫
例如： StringCaseChange.java
public class StringCaseChange
{
public static void main(String[] args)
{
String str = "Hello world.This is a Java code.";
// 宣告並初始化字串
System.out.println("The str is :");
System.out.println(str);
System.out.println("to UpperCase:");
System.out.println(str.toUpperCase());
// 字串物件 str 呼叫 toUpperCase() 方法，並輸出返回值
System.out.println(str.toLowerCase());
// 字串物件 str 呼叫 toLowerCase() 方法，並輸出返回值
System.out.println(str);
// 輸出原字串 str
}
}
5 ，字串擷取
public char charAt(int index) // 返回 index 指定位置的字元
public String subString(int start) // 返回從 start 開始的子串。
public String subString(int start, int end) // 返回從 start 到 end 的子串
例： String str = “hello world”;
char charValue = str.charAt(2);
String s1 = str.subString(2);
String s2 = str.subString(6, 11);
結果： charValue = ‘1’;
s1 = “llo world”;
s2 = “world”;
注： start 和 end 的位置需特別小心。
6 ，判斷一個字元的字首和字尾
public boolean startsWith(String prefix) // 用於判斷當前字串的字首，是否是指定的字串物件 str ，若是則返回 true ，否則返回 false
public boolean endsWith(String suffix) // 用於判斷當前字串的字尾，是否是指定的字串物件 str ，若是則返回 true ，否則返回 false
public boolean startsWith(String prefix, int offset)
注：偏移量從 0 開始計數。
綜合例子 1 ： String 類物件的建立及使用 StringDemo.java
public class StringDemo
{
String str1 = "Hello world!This is Java code."; // 宣告並初始化字串 str1
String str2; // 宣告字串 str2
String str3 = new String("This is Java code."); // 宣告並初始化字串 str3
public StringDemo()
{
str2 = new String("This is Java code.");
// 建立字串物件 str2 並初始化
System.out.println("str1 is: "+str1);
System.out.println("str2 is: "+str2);
System.out.println("str3 is: "+str3+"/n");
System.out.println("Each item of str1 is:");
for(int i=0;i<str1.length();i++)
{ // 使用 charAt() 方法得到 String 字串中指定位置的字元，並利用迴圈分別輸出
char c = str1.charAt(i);
System.out.print("/""+c+"/",");
if((i+1)%10==0) System.out.println();
}
System.out.println();
byte b[] = str1.getBytes();
// 使用 String 類的 getBytes() 方法，得到 str1 中所有字元對應的 Unicode 編碼，並存入 byte 型陣列 b 中
System.out.println("Change each item of str1 to unicode is:");
for(int i=0;i<b.length;i++)
{ // 利用迴圈分別輸出 str1 中，所有元素對應的字元的 Unicode 編碼
System.out.print(b[i]+",");
if((i+1)%10==0) System.out.println();
}
System.out.println();
System.out.print("The result of comparing str2 and str3 is:");
System.out.println(str2.equals(str3));
// 將字串物件 str2 與 str3 進行比較，並將返回值輸出
System.out.println("/nReplace all charcters /"a/" to /"e/" in str2");
System.out.println("The result of str2.replace() is:"+str2.replace('a','e'));
// 將字串 str2 呼叫 replace() 方法的結果輸出
System.out.println("str2 is: "+str2+"/n");
System.out.print("The result of whether str1 is beginning with /"Hello/":");
System.out.println(str1.startsWith("Hello"));
System.out.print("The result of whether str3 is end with /"code./":");
System.out.println(str3.startsWith("code."));
}
public static void main(String[] args)
{
StringDemo stringDemo = new StringDemo();
}
}
綜合例子 2 ： String 類部分方法測試 StringMethodDemo.java
public class StringMethodDemo
{
public static void main(String[] args)
{
String str1 = "abc";
String str2 = "aab";
String str3 = "abd";
String str4 = "abc";
String str5 = "ABC";
String str6 = "abcdefgabcde";
// 以上完成字串的宣告及初始化
int i = str1.compareTo(str2);
int j = str1.compareTo(str3);
int k = str1.compareTo(str4);
// 以上呼叫 String 的 compareTo() 方法來比較字串
System.out.println("str1 is:"+str1);
System.out.println("str2 is:"+str2);
System.out.println("str3 is:"+str3);
System.out.println("str4 is:"+str4);
System.out.println("str5 is:"+str5);
System.out.println("str6 is:"+str6);
System.out.print("The result of str1 compareTo str2 is:");
System.out.println(i);
System.out.print("The result of str1 compareTo str3 is:");
System.out.println(j);
System.out.print("The result of str1 compareTo str4 is:");
System.out.println(k);
System.out.print("The result of str1 equals str5 is:");
System.out.println(str1.equals(str5));
// 呼叫 String 的 equals() 方法來比較字串
System.out.print("The result of str1 equalsIgnoreCase str5 is:");
System.out.println(str1.equalsIgnoreCase(str5));
// 呼叫 String 的 equalsIgnoreCase() 方法來比較字串
int m = str6.indexOf((int)'d');
// 呼叫 String 的 indexOf() 方法，返回字元 'd' 第一次出現的位置
System.out.println("The char /"d/" first appear position is :"+m);
int n = str6.indexOf((int)'d',4);
// 呼叫 String 的 indexOf() 方法，返回字元 'd' 從第四位後，首次出現的位置
System.out.println("After 4th position The char/"d/"appear position is:"+n);
}
}
三、 String 類——查詢指定字元、字串和替換
由於檢索對字串特別重要，為突出其重要性，故單獨列出。
1 ，查詢字元
int indexOf(char a) // 用於查詢並返回當前字串中，某個特定字元 a 第一次出現的位置
int indexOf(char a,int b) // 用於從當前字串中，自 b 位個字元之後向後查詢並返回某個特定字元 a 第一次出現的位置
int lastIndexOf(char a) // 用於查詢並返回當前字串中，某個特定字元 a 最後一次出現的位置
int lastIndexOf(char a, int b) // 用於從當前字串中，自 b 位個字元之後向後查詢並返回某個特定字元 a 最後一次出現的位置
2 ，查詢字串
int indexOf(String str) // 用於查詢並返回當前字串中，某個特定字串 str 第一次出現的位置
int indexOf(String str,int a) // 用於從當前字串中，自 a 位個字元之後向後查詢並返回某個特定字串 str 第一次出現的位置
int lastIndexOf(String str) // 用於查詢並返回當前字串中，某個特定字串 str 最後一次出現的位置
int lastIndexOf(String str int a) // 用於從當前字串中，自 a 位個字元之後向後查詢並返回某個特定字串 str ，最後一次出現位置
例如： StringSearchDemo.java
public class StringSearchDemo
{
public static void main(String[] args)
{
String str1 = "Hello world.This is a Java code.we will program Java code.";
String searchStr = "Java code";
// 以上宣告建立了字串物件
int i = str1.indexOf(searchStr);
// 在字串 str1 中，查詢並返回字串物件 searchStr 的位置
int j = str1.indexOf(searchStr,str1.indexOf("we"));
// 在字串 str1 中，從字串 "we" 開始，查詢並返回字串物件 searchStr 的位置
int m = str1.lastIndexOf(searchStr);
// 在字串 str1 中，查詢並返回字串物件 searchStr 最後一次出現的位置
System.out.println("str1 is:"+str1);
System.out.println("searchStr is:"+searchStr);
System.out.println("i = str1.indexOf(searchStr):"+i);
System.out.println("j=str1.indexOf(searchStr,str1.indexOf(/"we/")):"+j);
System.out.println("m = str1.lastIndexOf(searchStr):"+m);
}
}
3 ，替換字元（包括字串）
String replace(char c1,char c2) // 用於將當前字串中的所有 c1 指定的字元替換為 c2 指定的字元，並返回新的字串
四、 String 類——字串轉換為位元組陣列或字元陣列
1 ，位元組陣列
byte [] getBytes();
byte [] getBytes(String enc); //enc 是字符集編碼
2 ，字元陣列
char [] toCharArray();
char [] toCharArray(int srcBegin, int srcEnd, char[] dst, int dstBegin);
例： byte byteArr[];
char charArr[];
String str = "This is s test string";
byteArr = str.getBytes();
charArr = str.toCharArray();
原始碼： StringToArray.java
public class StringToArray{
public static void main(String[] args){
String s="ABCDE";
byte b[]=s.getBytes();
System.out.println("/t"+s);
for(int i=0;i<b.length;i++)
System.out.print("/t"+b[i]);
System.out.println();
char ch0[]=s.toCharArray();
myPrint(ch0);
char ch1[]=new char[3];
s.getChars(1,4,ch1,0);
myPrint(ch1);
}
static void myPrint(char[] obj){
for(int i=0;i<obj.length;i++)
System.out.print("/t"+obj[i]);
System.out.println();
}
}
StringBuffer 類
StringBuffer 類是可變字串類，建立 StringBuffer 類的物件後，可以隨意修改、變更字串的內容。每個 StringBuffer 類 的物件，都能夠儲存指定容量的字串，如果字串的長度超過了 StringBuffer 類物件的容量，則該物件的容量會自動的擴大。
一、 StringBuffer 類——構造方法
StringBuffer() // 用於建立一個空的 StringBuffer 物件
StringBuffer(int length) // 用於建立一個長度為 length 的 StringBuffer 物件
StringBuffer(String str) // 返回一個字串，初始化為 s ，長度為 s.length()+16 個位元組
例： StringBuffer sb = new StringBuffer();
StringBuffer sb = new StringBuffer(32);
StringBuffer sb = new StringBuffer(“I like this”);
注：系統為 String 類物件分配記憶體是，按照物件中所含字元的實際個數等量分配。而 StringBuffer 類物件分配記憶體時，出去字元所佔空間外，再另加 16 個字元大小的緩衝區。
二、StringBuffer 類——主要方法（全為 public ）
1 ，獲得長度、容量和設定長度
int capacity() // 用於獲取可變字串的當前容量，值為字串長度 +16
void setLength(int a) // 用於設定當前可變字串的長度
int length() // 用於獲取可變字串的長度，值為字串長度
例： StringBuffer buf = new StringBuffer(“0123”);
buf.length() = 4;
buf.capacity() = 4 + 16 = 20;
一般 StringBuffer 的長度 (length) 是指儲存在其中的字元個數，容量 (capacity) 是指緩衝區所能容納的最大字元數。
2 ， append 、 replace 、 reverse
StringBuffer append(Object obj) // 將物件引數以字串的方式，加入到當前可變字串中
StringBuffer append(String str) // 將給定的字串，追加到當前可變字串中
StringBuffer append(StringBuffer sb) // 將給定的可變字串，追加到當前可變字串中
StringBuffer replace(int a,int b,String str)// 使用新的字串 str ，替換當前可變字串中，起始位置為 a ，結束位置為 b 之間的內容
StringBuffer reverse(int start, int end, String str)
注： append 共有 11 個方法，上面僅列出常見的 3 個。
3 ， insert 、 delete
StringBuffer insert(int offset,Object obj) // 將物件引數以字串的方式，插入到當前可變字串中指定位置
StringBuffer insert(int offset,String str) // 將給定字串，插入到當前可變字串中指定位置
StringBuffer delete(int a,int b) // 用於刪除掉當前可變字串中，起始位置為 a ，結束位置為 b 之間的內容
StringBuffer deleteCharAt(int a) // 用於刪除指定索引位置處的字元
void setCharAt(int a,char ch) // 將給定字元 ch ，插入到當前可變字串中指定索引位置處
4 ，其他
String toString() // 獲得一個字串常量來代表當前可變字串
String substring(int start)
String substring(int start , int end);
注： insert 共有 10 個方法，上面僅列出常見的 2 個。
三、例項
1， StringBuffer 類的建立和使用
例如： StringBuffer 類物件的建立及使用 StringBufferDemo.java
public class StringBufferDemo
{
StringBuffer strBuf1 = new StringBuffer("Hello world!");
// 宣告、建立並初始化 StringBuffer 類的物件 strBuf1
StringBuffer strBuf2;
// 宣告 StringBuffer 類的物件 strBuf2
StringBuffer strBuf3 = new StringBuffer(10);
// 宣告並建立 StringBuffer 類的物件 strBuf3 ，並設定其長度為 10
public StringBufferDemo()
{
strBuf2 = new StringBuffer("This is Java code.");
// 建立並初始化 StringBuffer 類的物件 strBuf2
strBuf3 = new StringBuffer("Hello");
// 建立並初始化 StringBuffer 類的物件 strBuf3
String output = "strBuf1:"+strBuf1.toString()+"/nlength="+ strBuf1.
length()+"/ncapacity="+strBuf1.capacity();
// 使用 StringBuffer 類的方法 toString() ，將 StringBuffer 類物件轉化為 String
型字串
// 使用 StringBuffer 類的方法 length() ，來獲得該可變字串的長度
// 使用 StringBuffer 類的方法 capacity() ，來獲得該可變字串的最大儲存容量
System.out.println(output);
strBuf1.setLength(30);
// 使用 StringBuffer 類的方法 setLength() ，來設定可變字串的長度
System.out.print("After add strBuf1's length,");
System.out.println("strBuf1's capacity is:"+strBuf1.length());
strBuf1.ensureCapacity(60);
// 使用 StringBuffer 類的方法 ensureCapacity() ，來設定可變字串的最大儲存容量
System.out.print("Set strBuf1's capacity,");
System.out.println("Now strBuf1's capacity is:"+strBuf1.capacity());
System.out.println();
System.out.println("strBuf2:"+strBuf2.toString());
System.out.println("Char at 0 in strBuf2 is:"+strBuf2.charAt(0));
System.out.println("Char at 9 in strBuf2 is:"+strBuf2.charAt(9));
char ch[] = new char[strBuf2.length()];
strBuf2.getChars(8,12,ch,0);
// 使用 StringBuffer 類的方法 getChars() ，來獲取 strBuf2 中第 8 ～ 12 位的字元
System.out.println("The char from 8 to 12 is:");
for(int i=0;i<4;i