Java 基础学习——复习第三天--字符串

最新推荐文章于 2024-07-25 16:04:24 发布

婧中横卧听雨声

最新推荐文章于 2024-07-25 16:04:24 发布

阅读量627

点赞数

本文链接：https://blog.csdn.net/qq_35428214/article/details/80919519

版权

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
对象类型	字符串常量	字符串变量	字符串变量
线程安全性	不安全	不安全	安全
执行效率	低	高	中