5 字符串
5.1 String 類
（1）字符串的聲明，雙引號中的內容表示字符串；聲明方法：String a; String a,b;分別聲明一個和兩個字符串變量
（2）創建字符串
1.引用字符串常量--直接將字符串常量賦值給String類型變量——String a=“時間就是金錢，我的朋友”；
2.利用構造方法示例化--使用new關鍵字創建String對象——String a=new String（“我愛劉敬”）；
3. 利用字符數組實例化--例 : char[ ] charArrays ={'t','i','m','e'}; String a=new String (charArrays);
4.提取字符數組的一部分創建字符串對象--例 : char[ ]charArrays ={'t','i','m','e'}; String a=new String (charArrays，2,2);
方法實現：
public classCreateString{
publicstatic void main(String[] args) {
//直接引用字符串常量
Stringa = "時間就是金錢，我的朋友。";
System.out.println("a= " + a);
//利用構造方法實例化
Stringb = new String("我愛清湯小肥羊");
//使用已有字符串變量實例化
Stringc = new String(b);
System.out.println("b= " + b);
System.out.println("c= " + c);
char[]charArray = { 't', 'i', 'm', 'e' };
//利用字符數組實例化
Stringd = new String(charArray);
System.out.println("d= " + d);
char[]charArray2 = { '時', '間', '就', '是', '金', '錢' };
//提取字符數組部分內容,從下標爲4的元素開始，截取2個字符
Stringe = new String(charArray2, 4, 2);
System.out.println("e= " + e);
}
}
結果：
5.2 連接字符串
（1）字符串連接 --使用‘+’‘+=’進行字符串之間的連接
（2）連接其他數據類型--會將其他數據轉化成字符串
5.3 提取字符串信息
（1）獲取字符串長度--使用 length（）方法獲取字符串的長度 方法：str.length()；
（2）獲取指定字符--使用charA（index）方法可將指定索引處的字符返回 方法str.charA(index); str=任意字符串，index：char值得索引
（3）獲取子字符串索引位置
1.indexOf（String str）--該方法用於返回參數字符串在指定字符串str中首次出現的索引位置。如果沒有檢索到，該方法的返回值爲-1；語法：a.indexOf(str)； a：任意字符串對象； str：要搜索的字符串；
代碼實現：
public class StringIndexOf {
publicstatic void main(String[] args) {
//創建字符串對象
Stringstr = "12345abde";
//獲取字符串str中"abc"首次出現的索引，賦值給charIndex
intcharIndex = str.indexOf("abc");
//判斷：index的值不等於-1
if(charIndex != -1) {
//如果index不等於-1，則執行此行代碼，說明str中存在“abc”字符串
System.out.println("str中存在abc字符串");
}else {
//如果index等於-1，則執行此行代碼，說明str中沒有“abc”字符串
System.out.println("str中沒有abc字符串");
}
}
}
結果：
2.indexOf（String str，int fromIndex）--從指定索引fromIndex開始至字符串最後，返回指定子字符串在字符串中第一次出現處的索引。如果沒有檢索到，該方法的返回值爲-1；語法：a.indexOf(str,fromIndex)；a：任意字符串對象； str：要搜索的子字符串；fromIndex：開始搜索索引的索引位置
代碼實現：
public class StringIndexOf2 {
publicstatic void main(String[] args) {
//創建字符串
Stringstr = "We are the world";
//獲取字符串中"r"第一次出現的索引位置
intfirstIndex = str.indexOf("r");
//獲取字符串中"r"第二次出現的索引位置，從第一次出現的索引位置之後開始查找
intsecondIndex = str.indexOf("r", firstIndex + 1);
//獲取字符串中"r"第三次出現的索引位置，從第二次出現的索引位置之後開始查找
intthirdIndex = str.indexOf("r", secondIndex + 1);
//輸出三次獲取的索引位置
System.out.println("e第一次出現的索引位置是："+ firstIndex);
System.out.println("e第二次出現的索引位置是："+ secondIndex);
System.out.println("e第三次出現的索引位置是："+ thirdIndex);
}
}
結果：
3.lastIndexOf（Stringstr）--返回指定子字符串在此字符串最右邊出現處的索引。--語法：a.lastIndexOf(str);a：任意字符串對象； str：要搜索的字符串；
代碼實現：
public class StringLastIndexOf {
publicstatic void main(String[] args) {
Stringstr = "Let it go!Let it go!"; //創建字符串對象
intgIndex = str.lastIndexOf("g"); // 返回”g“最後一次出現的位置
intgoIndex = str.lastIndexOf("go"); // 返回”go“最後一次出現的位置
intoIndex = str.lastIndexOf("o"); // 返回”o“最後一次出現的位置
System.out.println("字符串\"Letit go!Let it go\"中:\n");
System.out.println("\"g\"最後一次出現的位置是："+ gIndex);
System.out.println("\"o\"最後一次出現的位置是："+ oIndex);
System.out.println("\"go\"最後一次出現的位置是："+ goIndex);
Stringstr1 = "人過大佛寺，寺佛大過人";
intgIndex1 = str1.lastIndexOf("人");
System.out.println("\"人\"最後一次出現的位置是："+ gIndex1);
}
}
結果
4.lastIndexOf（String str，int fromIndex）--返回指定子字符串在此字符串中最後一次出現處的索引，從指定索引位置開始反向搜索。a.lastIndexOf（str，fromIndex）；a：任意字符串對象； str：要搜索的子字符串；fromIndex：開始搜索索引的索引位置
代碼實現：
public class StringLastIndexOf2 {
publicstatic void main(String[] args) {
Stringstr = "01a3a56a89";
//返回字母"a"最後一次出現的索引位置
intlastIndex = str.lastIndexOf("a");
//返回字母"a"的索引位置otherIndex
//滿足0<=fiveBeforeIndex<=5條件，在滿足條件的結果集中，返回最大的數字
intfiveBeforeIndex = str.lastIndexOf("a", 5);
//返回字母"a"的索引位置otherIndex
//滿足0<=threeBeforeIndex<=3條件，在滿足條件的結果集中，返回最大的數字
intthreeBeforeIndex = str.lastIndexOf("a", 3);
System.out.println("字符串\"01a3a56a89\"中：\n");
System.out.println("字母\"a\"最後一次出現的位置是："+ lastIndex);
System.out.println("從索引位置5開始往回搜索，字母\"a\"最後一次出現的位置："+ fiveBeforeIndex);
System.out.println("從索引位置3開始往回搜索，字母\"a\"最後一次出現的位置："+ threeBeforeIndex);
}
}
結果：
（4）判定字符串首尾內容
1.starsWith（String str）--用於判定字符串是否以指定的前綴開始。語法：a.starsWith(str)；a：任意字符串； str：要作爲前綴的字符串；
代碼實現：
public classStringStartWith {
publicstatic void main(String[] args) {
//前半句
StringmyDream1 = "我有一個夢想，幽谷上升，高山下降；";
//後半句
StringmyDream2 = "坎坷曲折之路成坦途，聖光披露，滿照人間。";
//打印整句話
System.out.println(myDream1+ myDream2 + "\n\t\t————馬丁•路德金《我有一個夢想》\n");
//判斷前半句是否以"我有一個夢想"爲前綴
booleanfirstBool = myDream1.startsWith("我有一個夢想");
//判斷後半句是否以"我有一個夢想"爲前綴
booleansecondBool = myDream2.startsWith("我有一個夢想");
//判斷前半句的邏輯結果
if(firstBool) {
System.out.println("前半句是以\"我有一個夢想\"開始的。");
//判斷後半句的邏輯結果
}else if (secondBool) {
System.out.println("後半句是以\"我有一個夢想\"開始的。");
//如果沒有符合條件的字符串
}else {
System.out.println("沒有以\"我有一個夢想\"開始的。");
}
}
}
結果：
2.starsWith（String str，int index）--用於判定從指定索引開始的子字符串是否以指定的前綴開始。語法：a.starsWith(str，index)；a：任意字符串； str：要作爲前綴的字符串；index：開始查找的位置。
代碼實現：
public classStringStartWith2 {
publicstatic void main(String[] args) {
//創建字符串對象
Stringstr = "牀前明月光，疑是地上霜。\n舉頭望明月，低頭思故鄉。";
//打印古詩
System.out.println(" 《靜夜思》\n" + str +"\n");
//返回換行符所在的位置
intenterIndex = str.indexOf("\n");
//返回從換行符之後開始的子字符串前綴是否爲”舉“。
//換行符在字符串中只佔一個字符，所以enterIndex + 1
booleanflag = str.startsWith("舉", enterIndex + 1);
if(flag) {
//如果結果爲真，則輸出此句
System.out.println("第二行是以\"舉\"開始的");
}else {
//如果結果爲假，則輸出第二行開頭第一個字符
System.out.println("第二行是以\""+ str.charAt(enterIndex + 1) + "\"開始的");
}
}
}
結果：
3.endsWith（String str）--用於判斷字符串是否以指定的後綴結束。語法：a.starsWith(str)；a：任意字符串； str：指定的後綴字符串；
代碼實現：
public classStringEndsWith {
publicstatic void main(String[] args) {
Stringstr1 = "你說完了嗎？";
Stringstr2 = "我說完了.java";
booleanflag1 = str1.endsWith("。");// 判斷str1是否以"。"結尾
booleanflag2 = str2.endsWith(".java");// 判斷str2是否以"。"結尾
System.out.println("字符串str1是以句號結尾的嗎？"+ flag1);// 輸出結果
System.out.println("字符串str2是以.java結尾的嗎？" +flag2);
}
}
結果：
（5）獲取字符數組
1.toCharArray（）方法可以將一個字符串轉化爲一個字符數組。語法str.toCharArray();str：任意字符串
代碼實現
public classStringToArray {
publicstatic void main(String[] args) {
Stringstr = "這是一個字符串";//創建一個字符串
char[]ch = str.toCharArray();//將字符串轉換成字符數組
for(int i = 0; i < ch.length; i++) {//遍歷字符數組
System.out.println("數組第" + i+ "個元素爲：" + ch[i]);//輸出數組的元素
}
}
}
結果
（6）判定子字符串是否存在
1.contains（）方法可以判斷字符串中是否包含指定的內容。語法str.contains(string)；str：任意字符串；string：查詢的子字符串。
代碼實現：
public classStringContains {
publicstatic void main(String[] args) {
//創建字符串
Stringstr = "今天的菜單有：蒸羊羔，蒸熊掌，蒸鹿尾。燒花鴨，燒雛雞，燒子鵝，滷煮鹹鴨，醬雞，臘肉，松花小肚。";
System.out.println(str);//輸出字符串
booleanrequest1 = str.contains("臘肉");// 判斷字符串中是否有“臘肉”的字樣
System.out.println("今天有臘肉嗎？"+ request1);
booleanrequest2 = str.contains("漢堡");// 判斷字符串中是否有“漢堡”的字樣
System.out.println("今天有漢堡嗎？"+ request2);
}
}
結果：
今天的菜單有：蒸羊羔，蒸熊掌，蒸鹿尾。燒花鴨，燒雛雞，燒子鵝，滷煮鹹鴨，醬雞，臘肉，松花小肚。
今天有臘肉嗎？true
今天有漢堡嗎？false
5.4字符串操作
（1）截取字符串
1.substring（int beginIndex）--該方法返回一個新的字符串，它是此字符串的一個子字符串，該字符串從指定的索引處開始，直到此字符串的末尾。語法：str.substring（ beginIndex）；str：任意字符串。beginIndex：起始索引（包括）
代碼實現：
public class StringSub {
publicstatic void main(String[] args) {
Stringstr = "爲革命保護視力，眼保健操開始！";
Stringsubstr = str.substring(8); //從第8位開始截取字符串
System.out.println("字符串str的後半句是："+ substr);
}
}
結果：
字符串str的後半句是：眼保健操開始！
2.substring（int beginIndex，int endindex）--該方法返回一個新的字符串，它是此字符串的一個子字符串，該字符串從指定的beginIndex處開始，直到索引endindex-1處的字符。語法：str.substring（ beginIndex，endindex）；str：任意字符串。beginIndex：起始索引（包括）。endindex：結束索引）（不包括）。
代碼實現：
public classStringSub2 {
publicstatic void main(String[] args) {
Stringstr = "閉門造車，出門合轍。";
//從0開始（即從頭開始）截取至4-1索引位置的子字符串
Stringsubstr = str.substring(0, 4);
System.out.println("字符串str的前半句是："+ substr);
}
}
結果：
字符串str的前半句是：閉門造車
（2）字符串替換
1.replace（CharSequence target,CharSequence replacement）--該方法可以實現將指定的字符串序列替換成新的字符序列。語法：str.replace（oldstr，newstr）str：任意字符串，oldstr：要被替換的字符序列，newstr：替換後新的字符序列。
代碼實現：
public class StringReplace {
publicstatic void main(String[] args) {
Stringstr="明月幾時有，把酒問青天";
Stringrestr=str.replace("月", "日"); //將str中的”月“全部替換成”日“
System.out.println("字符串str替換之後的效果："+restr);
}
}
結果：
字符串str替換之後的效果：明日幾時有，把酒問青天
2.replaceAll（String oldstr,String newstr）--該方法可以實現將指定的字符串替換成新的字符串，支持正則表達式。語法：str.replaceAll（oldstr，newstr）str：任意字符串，oldstr：要被替換的字符串或正則表達式，newstr：替換後新的字符串。
代碼實現：
public classStringReplaceAll {
publicstatic void main(String[] args) {
//創建字符串，前十位是數字
Stringstr = "0123456789abc\\d";
//使用replace()將符合"\\d"表達式的字符串替換"?"
Stringrestr = str.replace("\\d", "?");
//使用replaceAll()將符合"\\d"表達式的字符串替換"?"
StringrestrAll = str.replaceAll("\\d", "?");
//輸出結果
System.out.println("字符串str：" + str);
System.out.println("使用replace()替換的結果："+ restr);
System.out.println("使用replaceAll()替換的結果："+ restrAll);
}
}
結果：
字符串str：0123456789abc\d
使用replace()替換的結果：0123456789abc?
使用replaceAll()替換的結果：??????????abc\d
3.replaceFirst（String oldstr,String newstr）--該方法可以實現將第一個指定的字符串替換成新的字符串，支持正則表達式。語法：str.replaceFirst（oldstr，newstr）str：任意字符串，oldstr：第一個被替換的字符串或正則表達式，newstr：替換後新的字符串。
代碼實現：
public classStringReplaceFirst {
publicstatic void main(String[] args) {
//創建字符串
Stringstr = "8I want to marry you, so I need you！";
//將開頭的數字去掉
StringnoNumber = str.replaceFirst("\\d", "");
//將第一次出現的"you"替換成"her"
StringyouToHer = noNumber.replaceFirst("you", "her");
//輸出結果
System.out.println(noNumber);
System.out.println("替換之後的結果是："+youToHer);
//創建字符串
Stringstr1 = "Let it go！Let it go！Let it go！";
//將第一次出現的"go"替換成"do"
StringnoNumber1 = str1.replaceFirst("go", "do");
//將第二次出現的"go"替換成"do"
StringyouToHer1 = noNumber1.replaceFirst("go", "do");
//輸出結果
System.out.println(noNumber1);
System.out.println("替換之後的結果是："+youToHer1);
}
}
結果：
I want to marry you, so I need you！
替換之後的結果是：I want to marry her, so I need you！
Let it do！Let it go！Let it go！
替換之後的結果是：Let it do！Let it do！Let it go！
另附常見正則表達式
（3）字符串分割
1.split（String str）--根據給定的分隔符對字符串進行拆分，支持正則表達式，最後返回一個字符串數組。語法：a.split（str）
代碼實現：
public classStringSplit {
publicstatic void main(String[] args) {
//創建一個字符串
Stringstr = "從前有座山,山裏有個廟,廟裏有個小松鼠";
//讓字符串按照","進行分割
String[]strArray = str.split(",");
//使用for循環，循環輸出數字所有元素
for(int i = 0; i < strArray.length; i++) {
System.out.println("數組第" + i+ "索引的元素是：" + strArray[i]);
}
}
}
結果
數組第0索引的元素是：從前有座山
數組第1索引的元素是：山裏有個廟
數組第2索引的元素是：廟裏有個小松鼠
2.split（String str,int limit）--根據給定的分隔符對字符串進行拆分，並限定拆分的次數，支持正則表達式。語法：a.split（str，limit）a:任意字符串；str：分隔符表達式；limit：限定的分割次數。
代碼實現：
public classStringSplit3 {
publicstatic void main(String[] args) {
//創建字符串
Stringstr = "192.168.0.1";
//按照"."進行分割
String[]firstArray = str.split("\\.");
//按照"."進行兩次分割
String[]secondArray = str.split("\\.", 2);
//輸出str原值
System.out.println("str的原值爲：["+ str + "]");
//輸出全部分割的結果
System.out.print("全部分割的結果：");
for(String a : firstArray) {
System.out.print("["+ a + "]");
}
System.out.println();//換行
//輸出分割兩次的結果
System.out.print("分割兩次的結果：");
for(String a : secondArray) {
System.out.print("["+ a + "]");
}
System.out.println();
}
}
結果：
str的原值爲：[192.168.0.1]
全部分割的結果：[192][168][0][1]
分割兩次的結果：[192][168.0.1]
（4）大小寫轉換
1.toLowerCase（）--該方法將字符串轉化爲小寫，沒有需要轉化的則返回原字符串，否則則生成新的字符串：語法str.toLowerCase()；
2.toUpperCase（）--該方法將字符串轉化爲大寫，沒有需要轉化的則返回原字符串，否則則生成新的字符串：語法str.toUpperCase()；
代碼實現：
public classStringTransform {
publicstatic void main(String[] args) {
Stringstr = "good morming EVERY ONE"; // 創建字符串
System.out.println(str.toUpperCase());// 按照大寫格式輸出
System.out.println(str.toLowerCase());// 按照小寫格式輸出
}
}
結果：
GOOD MORMING EVERY ONE
good morming every one
（5）去除空白內容
1.trim（）--該方法可以返回字符串的副本，忽略首尾處空白。語法：str.trim（）；
代碼實現：
public classStringTrim {
publicstatic void main(String[] args) {
Stringstr = " abc ";
StringshortStr = str.trim();
System.out.println("str的原值是：["+ str + "]");
System.out.println("去掉首尾空白的值：["+ shortStr + "]");
}
}
結果：
str的原值是：[ abc ]
去掉首尾空白的值：[abc]
（6）字符串比較
1.equals（String str）；將此字符串與指定的對象比較。
2.equalsIgnoreCase（String str）--將此字符串與指定的對象比較，不考慮大小寫。
代碼實現：
public classStringEqualsIgnoreCase {
public staticvoid main(String[] args) {
// 創建字符串對象，內容全部小寫
String str1 = "abc";
// 創建字符串對象，內容全部大寫
String str2 = "ABC";
// 比較兩個字符串的內容是否相等
System.out.println("區分大小寫的結果："+str1.equals(str2));
// 比較兩個字符串的內容是否相等，不區分大小寫
System.out.println("不區分大小寫的結果："+str1.equalsIgnoreCase(str2));
}
}
結果
區分大小寫的結果：false
不區分大小寫的結果：true
（7）字符串格式化--format()方法用於創建格式化字符串
1.日期與時間格式化
1.1日期格式化
常用日期格式化轉換符
| 轉換符 | 描述體 | 示例 |
|---|---|---|
| %te | 一個月中的某一天（1～31） | 2 |
| %tb | 指定語言環境的月份簡稱 | Feb（英文）、二月（中文） |
| %tB | 指定語言環境的月份全稱 | February（英文）、二月（中文） |
| %tA | 指定語言環境的星期幾全稱 | Monday（英文）、星期一（中文） |
| %ta | 指定語言環境的星期幾簡稱 | Mon（英文）、星期一（中文） |
| %tc | 包括全部日期和時間信息 | Mon Jan 08 06:30:04 UTC 2018 |
| %tY | 四位年份 | 2018 |
| %ty | 兩位年份 | 18 |
| %tj | 一年中的第幾天（001～366） | 008 |
| %tm | 月份（01～12） | 08 |
| %td | 一個月中的第幾天（01～31） | 08 |
1.2時間格式化
常用時間格式化轉換符
| 轉換符 | 描述體 | 示例 |
|---|---|---|
| %tH | 2位數字的24小時制的小時（00～23） | 14 |
| %tI | 2位數字的12小時制的小時（01～12） | 05 |
| %tk | 2位數字的24小時制的小時（1～23） | 5 |
| %tI | 2位數字的12小時制的小時（1～12） | 10 |
| %tM | 2位數字的分鐘（00～59）） | 05 |
| %tS | 2位數字的秒數（00～60） | 12 |
| %tL | 3位數字的毫秒數（000～999） | 920 |
| %tN | 9位數字的微秒數（000000000～999999999） | 062000000000 |
| %tp | 指定語言環境下上午或下午標記 | 下午（中文）、pm（英文） |
| %tz | 相對於GMT RFC 82格式的數字時區偏移量 | +0800 |
| %tZ | 時區縮寫形式的字符串 | CST |
| %ts | 1970-01-01 00:00:00至現在經過的秒數 | 1206426646 |
| %tQ | 1970-01-01 00:00:00至現在經過的毫秒數 | 1206426737453 |
1.3日期時間組合格式化
常用日期時間格式化組合轉換符
| 轉換符 | 描述體 | 示例 |
|---|---|---|
| %tF | “年-月-日”格式（4位年份） | 2018-01-08 |
| %tD | “月/日/年”格式（2位年份） | 01/08/18 |
| %tr | “時：分：秒 PM（AM）”格式（12小時制） | 15:23:50 PM |
| %tT | “時：分：秒”格式（24小時制） | 15:23:50 |
| %tR | “時：分”格式（24小時制） | 15:23 |
2.常規類型格式化
轉換符 | ||
轉換符 | 說明 | 示例 |
%b , %B | 結果被格式化爲布爾型 | True |
%h , %H | 結果被格式化爲散列碼 | A05A5198 |
%s , %S | 結果被格式化爲字符串類型 | “abcd” |
%c , %C | 結果被格式化爲字符類型 | ‘a’ |
%d | 結果被格式化爲十進制整數 | 40 |
%o | 結果被格式化爲八進制整數 | 11 |
%x , %X | 結果被格式化爲十六進制整數 | 4b1 |
%e | 結果被格式化爲用計算機科學計數法表示的十進制數 | 1.700000e+01 |
%a | 結果被格式化爲帶有效位數和指數的十六進制浮點值 | 0X1.C000000000001P4 |
%n | 結果爲特定於平臺的分割符 |
|
%% | 結果爲子面值% | % |
代碼實現
public classStringFormat {
publicstatic void main(String[] args) {
//輸出字符
Stringstr1 = String.format("%c", 'X');
System.out.println("字母x大寫：" + str1);
//輸出數字
Stringstr2 = String.format("%d", 1251 + 3950);
System.out.println("1251+3950的結果是：" +str2);
//輸出小數點後兩位
Stringstr3 = String.format("%.2f", Math.PI);
System.out.println("π取兩位小數點："+ str3);
//輸出布爾值
Stringstr4 = String.format("%b", 2 < 3);
System.out.println("2<3的結果是：" +str4);
//輸出哈希散列碼，等同Integer.toHexString(3015);
Stringstr5 = String.format("%h", 3510);
System.out.println("3510的hashCode值：" + str5);
//輸出8進制
Stringstr6 = String.format("%o", 33);
System.out.println("33的8進制結果是："+ str6);
//輸出16進制
Stringstr7 = String.format("%x", 33);
System.out.println("33的16進制結果是："+ str7);
//輸出科學計數法
Stringstr8 = String.format("%e", 120000.1);
System.out.println("120000.1用科學計數法表示："+ str8);
//輸出帶有效位數和指數的16進制浮點值
Stringstr9 = String.format("%a", 40.0);
System.out.println("40.0的十六進制浮點值："+ str9);
//輸出百分號和數字
System.out.println(String.format("天才是由%d%%的靈感，%d%%的汗水 。", 1, 99));
}
}
結果
字母x大寫：X
1251+3950的結果是：5201
π取兩位小數點：3.14
2<3的結果是：true
3510的hashCode值：db6
33的8進制結果是：41
33的16進制結果是：21
120000.1用科學計數法表示：1.200001e+05
40.0的十六進制浮點值：0x1.4p5
天才是由1%的靈感，99%的汗水 。
使用轉換符還可以配合轉換符標識來控制輸出格式
轉換符標識 | |
標識 | 說明 |
‘-’ | 在最小的寬度內左對齊，不可以與‘0’填充標識同時使用 |
‘#’ | 用於8進制和16進制格式，在8進制前加一個0，在16進制前加一個0x |
‘+’ | 顯示數字的正負號 |
‘’ | 在正數前面加空格，在負數前加負號 |
‘0’ | 在不夠最小位數的結果前用0填充 |
‘，’ | 只適用於10進制數，沒三位數字‘，’分隔 |
‘（’ | 用括號吧負數括起來 |
代碼實現：
public classStringFormat2 {
publicstatic void main(String[] args) {
//讓字符串輸出的最大長度爲5，不足長度在前端補空格
Stringstr1 = String.format("%5d", 123);
System.out.println("輸出長度爲5的字符串|" +str1 + "|");
//讓字符串左對齊
Stringstr2 = String.format("%-5d", 123);
System.out.println("左對齊|" + str2+ "|");
//在8進制前加一個0
Stringstr3 = String.format("%#o", 33);
System.out.println("33的8進制結果是："+ str3);
//在16進前加一個0x
Stringstr4 = String.format("%#x", 33);
System.out.println("33的16進制結果是："+ str4);
//顯示數字正負號
Stringstr5 = String.format("%+d", 1);
System.out.println("我是正數：" +str5);
//顯示數字正負號
Stringstr6 = String.format("%+d", -1);
System.out.println("我是負數：" +str6);
//在正數前補一個空格
Stringstr7 = String.format("% d", 1);
System.out.println("我是正數，前面有空格"+ str7);
//在負數前補一個負號
Stringstr8 = String.format("% d", -1);
System.out.println("我是負數，前面有負號"+ str8);
//讓字符串輸出的最大長度爲5，不足長度在前端補0
Stringstr9 = String.format("%05d", 12);
System.out.println("前面不夠的數用0填充：" + str9);
//用逗號分隔數字
Stringstr10 = String.format("%,d", 123456789);
System.out.println("用逗號分隔："+ str10);
//正數無影響
Stringstr11 = String.format("%(d", 13);
System.out.println("我是正數，我沒有括號："+ str11);
//讓負數用括號括起來
Stringstr12 = String.format("%(d", -13);
System.out.println("我是負數，我有括號的："+ str12);
}
}
結果
輸出長度爲5的字符串| 123|
左對齊|123 |
33的8進制結果是：041
33的16進制結果是：0x21
我是正數：+1
我是負數：-1
我是正數，前面有空格 1
我是負數，前面有負號-1
前面不夠的數用0填充：00012
用逗號分隔：123,456,789
我是正數，我沒有括號：13
我是負數，我有括號的：(13)
5.5可變字符串
（1）StringBuffer類的常用方法
1.創建StringBuffer類--必須使用new方法
2.append（）方法--將參數轉化爲字符串，將所得字符串中的字符追加到此序列中
3.setCharAt（int index，char ch）方法--將給定索引處的字符修改爲ch
4.insert（int offset，String str）方法--將字符串插入帶索引處
5.reverse（)方法--將字符串反序輸出
6.delete（int start，int end）方法--移除此序列的子字符串中的字符，該子字符串是從索引start處開始到索引end-1處。
7.其他方法--類似String類的方法
代碼展示
public class StrignBufferTest {
publicstatic void main(String[] args) {
StringBuffersbf = new StringBuffer("ABCDEFG");// 創建字符串序列
intlenght = sbf.length();// 獲取字符串序列的長度
charchr = sbf.charAt(5); // 獲取索引爲5的字符
intindex = sbf.indexOf("DEF");// 獲取DEF字符串所在的索引位置
Stringsubstr = sbf.substring(0, 2);// 截取從索引0開始至索引2之間的字符串
StringBuffertmp = sbf.replace(2, 5, "1234");// 將從索引2開始至索引5之間的字符序列替換成"1234"
System.out.println("sbf的原值爲：" +sbf);
System.out.println("sbf的長度爲：" +lenght);
System.out.println("索引爲5的字符爲：" +chr);
System.out.println("DEF字符串的索引位置爲："+ index);
System.out.println("索引0開始至索引2之間的字符串："+ substr);
System.out.println("替換後的字符串爲："+ tmp);
}
}
結果
sbf的原值爲：AB1234FG
sbf的長度爲：7
索引爲5的字符爲：F
DEF字符串的索引位置爲：3
索引0開始至索引2之間的字符串：AB
替換後的字符串爲：AB1234FG
（2）StringBuider類的使用方法--StringBuider類和StringBuffer類的使用方法一樣
代碼實現：
public classStringBuilderTest {
publicstatic void main(String[] args) {
StringBuildersbd = new StringBuilder();
System.out.println("sbd的原值爲空");
sbd.append("我是StringBuilder類");
System.out.println("sbd追加字符串："+ sbd);
intlength = sbd.length();
System.out.println("sbd的長度爲：" +length);
sbd= sbd.insert(length - 1, "123456");
System.out.println("插入字符串："+ sbd);
sbd= sbd.delete(sbd.length() - 1, sbd.length());
System.out.println("刪除最後一個字："+ sbd);
sbd= sbd.reverse();
System.out.println("反序輸出：" +sbd);
}
}
結果：
sbd的原值爲空
sbd追加字符串：我是StringBuilder類
sbd的長度爲：16
插入字符串：我是StringBuilder123456類
刪除最後一個字：我是StringBuilder123456
反序輸出：654321redliuBgnirtS是我
（3）StringBuffer、StringBuider、String之間的聯繫
1.StringBuffer、StringBuider、String互相轉換
代碼實現：
public class StringInterchange {
public static voidmain(String[] args) {
String str = "String";
// String轉換成StringBuffer
StringBuffer sbf = newStringBuffer(str);
// String轉換成StringBuilder
StringBuilder sbd = newStringBuilder(str);
// StringBuffer轉換成String
str = sbf.toString();
// StringBuilder轉換成String
str = sbd.toString();
// StringBuffer轉換成StringBuilder
StringBuilder bufferToBuilder = newStringBuilder(sbf.toString());
// StringBuilder轉換成StringBuffer
StringBuffer builderToBuffer = newStringBuffer(sbd.toString());
}
}
2.StringBuffer、StringBuider、String的不同之處
StringBuffer、StringBuider、String的區別 | |||
類名 | String | StringBuider | StringBuffer |
對象類型 | 字符串常量 | 字符串變量 | 字符串變量 |
線程安全性 | 不安全 | 不安全 | 安全 |
執行效率 | 低 | 高 | 中 |
適用場景：
（1）操作少、數據少，用String。
（2）單線程、操作多、數據多，用StringBuider
（3）多線程、操作多、數據多，用StringBuffer