5.1 String类

5.1.1 声明字符串

5.1.2 创建字符串

5.2 连接字符串

5.3 提取字符串信息

5.3.1 获取字符串长度

5.3.2 获取指定字符

5.3.3 获取子字符串索引位置

5.3.4 判断字符串首尾内容

5.3.5 获取字符数组

5.4 字符串的操作

5.4.1 截取字符串

5.4.2 字符串替换

5.4.3 字符串分割

5.4.4 大小写转换

5.4.5 去除空白内容

5.4.7 格式化字符串

5.5可变字符

5.5.1 StringBuffer类的常用方法

1.创建StringBuffer类

2.append()方法

3.setCharAt(int index,char ch)方法

4.insert(int offset,String str)方法

5.reverse()方法

6.delete(int start,int end)方法

7.StringBuilder类使用方法

8.StringBuffer、StringBuilder、String之间的相互转换

5.1 String类

5.1.1 声明字符串

字符串常量，可以显示任何文字信息。

String a;//声明字符串
String a,b;//声明字符串

5.1.2 创建字符串

1、引用字符串常量

String a = "时间就是金钱，我的朋友。";//定义string类型的字符串
String b = "锄禾日当午",c = "小鸡炖蘑菇";//定义a，b两个字符串
String str1,str2;//声明两个String类型的变量
str1="we are student.";//传入字符串
str2="I'm a student.";//传入字符串

当两个字符串应用相同的常量时，就具有相同的实体。

2、利用构造方法实例化

例如：使用new关键词创建String对象;

String a = new String ("我爱清汤小肥羊。");//用new关键字创建String对象
String b = new String (a);//用new关键字创建String对象

3、利用字符数组实例化

例如：定义一个字符数组，并创建个字符串；

char[] a = {'t','i','m','e'};//定义字符类型数组创建一个字符串
String b = new String(a);//用new关键字创建String对象

4、提取字符数组中的一部分创建子字符串对象

char[] a = ('时','间','就','是','金','钱');//用字符类型创建字符串
String b = new String(a,3,2);//定义字符串b，从索引3开始提取两个字符

从该字符串索引3的位置开始，提取两个元素。

例1：

package boketask;//java包名public class qwqw {//创建类的名字public static void main(String[] args) {//主函数String a = "时间就是金钱，我的朋友。";//直接应用字符串常量System.out.println("a=" +a);//一个输出语句String b = new String("我爱清汤小肥羊。");//利用构造方法实例化System.out.println("b="+b);//一个输出语句String c= new String(b);//使用已有字符串常量实例化System.out.println("c="+c);//一个输出语句char[] charArray = {'t','i','m','e'};//一个字符类型的数组创建字符串String d = new String (charArray);//利用字符数组实例化System.out.println("d="+d);//一个输出语句char[] charArray2 = {'时','间','就','是','金','钱'};//一个字符类型的数组创建字符串String e = new String(charArray2,4,2);//提取字符数组部分内容，从下标为4的元素开始，截取两个字符System.out.println("e="+e);//一个输出语句}}

运行结果如下

，：

5.2 连接字符串

5.2.1

使用“+”运算符可以实现拼接多个字符串的功能，并产生一个String对象，出来“+”运算符，“+=”运算符同样可以实现字符串拼接。

java中相连的字符串不能直接分为两行。例如：、
System.out.println("I like
Java
");//一句输出语句
这种语法是错误的，可用"+"来连接
System.out.println("I like"+
"Java");//一句输出语句
5.2.2

字符串也可以同其他的基本数据类型进行连接。

注意：字符串在计算公式中的前后顺序会影响运算结果；

例如：
String a = "1" +2+3+4    -->"1234"//碰到字符串后，直接输出后面内容
String b = 1+2+3+"4"     -->"64" //碰到字符串前，先做运算，后输出内容
String c = "1"+(2+3+4)   -->"19" //碰到字符串后，先运算括号中的值，后输出内容

5.3 提取字符串信息

5.3.1 获取字符串长度

定义一个字符串num ，使用length()方法获取其长度。

5.3.2 获取指定字符

package boketask;//包名public class hqzdzf {//创建类public static void main(String[] args) {//主方法String str = "床前明月光，疑是地上霜。";//定义字符串char chr = str.charAt(4);//将字符串str中索引位置为4的字符赋值给chrSystem.out.println("字符串中索引位置为4的字符是："+chr);//输出chr}}

运行结果如下：

5.3.3 获取子字符串索引位置

String类提供了两种查找字符串的方法，即indexOf()与lastIndexOf()方法。

1. indexOf(String str)

语法如下：

a.indexOf(substr);//indexOf的使用方法

a:任意字符串对象

substr：要搜索的字符串

如下所示：

package boketask;//包名public class hqzzfcweizhi {//创建类名public static void main(String[] args) {//主方法String str = "12345abcde";//创建字符串对象int charIndex = str.indexOf("abc");//获取字符串str中"abc"首次出现的索引，赋值给charIndexif (charIndex !=1) {//判断：index的值不等于-1//如果index不等于-1，则执行这串代码，说明str中存在"abc"字符串System.out.println("str中存在abc字符串");//输出内容} else {//如果index=-1，则执行这串代码，说明str中不存在"abc"字符串System.out.println("str中没有abc字符串");//输出内容    }}
}

运行结果如下：

说明：

如果参数是一个字符串，返回的结果是字符串第一个字母所在位置。
String str = "abcdefg";   //定义一个字符串
str.lastInderOf("def");    //返回值是3

2. indexOf(String str,int fromIndex)

从指定的索引 fromIndex 开始至字符串最后，返回指定子字符串中第一次出现处的索引。

如果没有检索到字符串str，该方法返回的值为-1。

语法如下：

a.indexOf(str,fromIndex);//该方法的使用格式

解释说明：

a：任意字符对象

str：要搜索的子字符串

fromIndex：开始搜索引的位置

例:

package boketask;//包名public class PIPIPI {//创建类public static void main(String[] args) {//主方法String str = "we are the world";//定义一个字符串int firstIndex = str.indexOf("r");//获取字符串中r第一次出现的索引位置//获取字符串中r第二次出现的索引位置，从r第一次出现的索引位置开始查找int secondIndex = str.indexOf("r",firstIndex+1);//获取字符串中r第二次出现的索引位置//获取字符串中r第三次出现的索引位置，从r第二次出现的索引位置开始查找int thirdIndex = str.indexOf("r",secondIndex+1);//获取字符串中r第三次出现的索引位置//输出三次获取的索引位置System.out.println("r第一次出现的索引位置是:"+firstIndex);//输出r第一次出现的索引位置System.out.println("r第二次出现的索引位置是:"+secondIndex);//输出r第二次出现的索引位置System.out.println("r第三次出现的索引位置是:"+thirdIndex);//输出r第三次出现的索引位置}}

运行结果：

该代码注解：

从运行结果可以看出，由于字符串只有两个“r”，所以程序输出了这两个“r”的索引位置，
第三次搜索是找不到“r”，所以返回结果为-1。

3. public int lastIndexOf(String str)

返回指定子字符串在此字符串中最右边出现处的索引，语法如下：

a.lastIndexOf(atr);//该方法的使用格式

解释说明：

a:任何字符串。

str：要搜索的字符串。

例子：

package boketask;//包名public class StringLastIndexOf {//创建类public static void main(String[] args) {//主方法String str = "Let it go!Let it go!";//创建字符串对象int gIndex = str.lastIndexOf("g");//返回“g”最后一次出现的位置int goIndex = str.lastIndexOf("go");//返回“go”最后一次出现的位置int oIndex = str.lastIndexOf("o");//返回“o”最后一次出现的System.out.println("字符串\"Let in go!Let it go!中:\n");//输出提示内容System.out.println("\"g\"最后一次出现的位置是：" + gIndex);//输出“g”最后一次出现的位置System.out.println("\"o\"最后一次出现的位置是：" + oIndex);//输出“o”最后一次出现的位置System.out.println("\"\"go最后一次出现的位置是：" + goIndex);//输出“go”最后一次出现的位置}}

运行结果：

4. lastIndexOf(String str,int fromIndex)

返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。

语法如下：

a. lastIndexOf(str,fronIndex);//该方法使用格式

解释说明：

a:任意字符串。

str：要搜索的子字符串。

fromIndex: 开始搜索的索引位置。

例如下面的代码：

运行结果如下：

package boketask;//包名public class StringLastIndexOf2 {//创建类public static void main(String[] args) {//主方法String str = "01a3a56a89";//创建字符串对象int lastIndex = str.lastIndexOf("a");//返回字母“a”最后一次出现的索引位置//返回字母“a”的索引位置otheerIndex//满足0<=fiveBeforeIndex<=5条件，在满足条件的结果集中，返回最大的数字int fiveBeforIndex = str.lastIndexOf("a",5);//返回字母“a”的索引位置otherIndex//满足0<=threeBeforIndex<=3条件，在满足条件的结果集中，返回最大的数字int threeBeforIndex = str.lastIndexOf("a",3);System.out.println("字符串\"01a3a56a89\"中：\n");//输出括号内的内容System.out.println("字母\"a\"最后一次出现的位置是："+ lastIndex);System.out.println("从索引5开始往回搜索，字母\"a\"最后一次出现的位置："+ fiveBeforIndex);System.out.println("从索引3开始往回搜索，字母\"a\"最后一次出现的位置" + threeBeforIndex);}}

运行结果如下：

5.3.4 判断字符串首尾内容

startWith()方法和 endsWith()方法分别用于判断字符串是否以指定内容开始或结束。

这两个方法返回的值都是boolean类型。

1. startWith(String prefix)

该方法用于判断字符串是否以指定内容开始

语法如下：

str.startWith(prefix);//该方法使用的语法

解释说明：

str：任意字符串。

prefix：作为前缀的字符串。

例：查看一个字符串是否以“我有一个梦想”开始。

package javaProject001;//包名public class StringStartWith {//创建类public static void main(String[] args) {//主方法String myDream1 = "我有一个梦想，幽谷上升，高山下降；";//前半句，创建字符串对象String myDream2 = "坎坷曲折之路成坦途，圣光披露，满照人间。";//后半句 创建字符串对象// 打印整句话System.out.println(myDream1+myDream2 + "\n——马丁·路德金《我有一个梦想》\n");boolean firstBool = myDream1.startsWith("我有一个梦想");//判断前半句是否以“我有一个梦想”为前缀boolean secondBool = myDream2.startsWith("我有一个梦想");//判断后半句是否以“我有一个梦想”为后缀if (firstBool) {System.out.println("前半句是以\"我有一个梦想\"开始的。");//判断前半句逻辑结果}else if (secondBool) {System.out.println("后半句是以\"我有一个梦想\"开始的。");//判断前半句逻辑结果}}}

运行结果如下：

2. startWith(String prefix,int tooffset)

该方法用于判断从指定索引开始的子字符串是否以指定的前缀开始。

语法如下：

str.startWith(prefix,index);//该方法使用方式

解释说明：

str：任意字符串。

prefix:作为前缀的字符串。

index：开始查找的位置。

例：

package javaProject001;//包名public class StringStartWith2 {//创建类public static void main(String[] args) {//主方法String str = "床前明月光，疑是地上霜。\n举头望明月，低头思故乡。";//创建字符串对象System.out.println("  《静夜思》 \n" +str+"\n");//打印古诗int enterIndex = str.indexOf("\n");//返回换行符所在的位置boolean flag = str.startsWith("举",enterIndex);//返回换行符之后开始的子字符串前缀是否为“举”if (flag) {System.out.println("第二行是以\"举\"开始的");//如果结果为真，则输出此句}else {System.out.println("第二行是以\""+str.charAt(enterIndex + 1)+"\"开始的");//如果结果为假，则输出第二行开头的第一个字符}}}

运行结果如下：

3. endsWith(String suffix)

该方法判断字符串是否以指定的后缀结束。

语法如下：

str.endsWith(suffix);//该方法的使用格式

解释说明：

str :任意字符串。

suffix:指定的后缀字符串。

例：

package javaProject001;//包名public class StringEndsWith {//创建类public static void main(String[] args) {//主方法String str1 = "你说完了吗？";//创建字符串对象String str2 = "我说完了。";//创建字符串对象boolean flag1 = str1.endsWith("。");//判断str1是否以“。”结尾boolean flag2 = str2.endsWith("。");//判断str2是否以“。”结尾System.out.println("字符串str1是以句号结尾的吗？"+flag1);//输出结果System.out.println("字符串str2是以句号结尾的吗？"+flag2);//输出结果}}

运行结果如下：

5.3.5 获取字符数组

toCharArray()方法可以将一个字符串转化为一个字符数组。语法如下：

str.toCharArray();//此方法使用格式

其中，str表示任意字符串。

例：

package javaProject001;//包名public class StringToArray {//创建类public static void main(String[] args) {//主方法String str = "这是一个字符串";//创建字符串对象char[] ch = str.toCharArray();//将字符串转化为字符数组for (int i = 0;i<ch.length;i++) {//遍历字符数组System.out.println("数组第"+ i +"个元素为："+ ch[i]);//输出数组的元素}}}

运行结果如下：

5.3.6 判断子字符串是否存在

contains()方法可以判断字符串中是否包括指定的内容。语法如下：

str.contains (String);//该方法的使用方式

解释说明：

str：任意字符串。

String：查询的子字符串。

例：

package javaProject001;//包名public class zszszsxd {//创建类public static void main(String[] args) {//主方法String a = "今日的菜单有：蒸羊羔，蒸熊掌，蒸鹿尾，烤花鸭，烧雏鸡，烧子鹅，卤煮咸鸭，酱鸡，腊肉，松花小肚";//创建字符串对象System.out.println(a);//输出字符串boolean request = a.contains("腊肉");//判断字符串中是否有“腊肉”的字样System.out.println("今天有腊肉吗？" +request);//输出内容boolean request1 = a.contains("汉堡");//判断字符串中是否有“汉堡”的字样System.out.println("今天有汉堡吗？" + request1);//输出内容}}

运行结果如下：

5.4 字符串的操作

5.4.1 截取字符串

1.subString(int bginIndex)

该方法返回一个新的字符串，它是此字符串的一个子字符串。该字符串从指定索引处的字符开始，直到此字符串末尾。

语法如下：

str.substring(beginIndex);//此方法的使用方式

解释说明:

str:任意字符串。

beeginIndex:起始索引（包括）。

例：

package javaProject001;//包名public class StringSub {//创建类public static void main(String[] args) {//主方法String str = "为革命保护视力，眼保健操开始。";//创建字符串对象String substr = str.substring(8);//从第八位截取字符串System.out.println("字符串str的后半句是："+ substr);//输出内容}}

运行结果如下：

2. subString(int beginIndex,int endIndex)

该方法返回一个新字符串，它是此字符串的一个子字符串。该子字符串从指定的 beginIndex 开始，直到索引 endIndex-1处的字符。

语法如下：

str.substring(beginIndex,endIndex);//该方法的使用方式

解释说明：

str：任意字符串。

beginIndex：开始索引（包括）。

endIndex：结束索引（不包括）。

例：

package javaProject001;//包名public class StringSub2 {//创建类public static void main(String[] args) {//主方法String str = "闭门造车，出门踩屎。";//创建字符串对象String substr = str.substring(0,4);//从0开始截取值4-1索引位置的子字符串System.out.println("字符串str的前半句是：" + substr);//输出内容}}

运行结果如下：

5.4.2 字符串替换

1. replace(CharSequence target,CharSequence repalcement)

该方法可以实现将指定的字符替换成新的字符序列。CharSequence 是一个接口，代表一个可读的字符序列，String、StringBuffer、StringBuilder 都实现了这个接口，所以可以直接将字符串当成参数。语法如下：

str.replace(oldstr,newstr);//该方法的使用方式

解释说明：

str：任意字符串。

oldstr：要被替换的字符序列。

newstr：替换后的字符序列。

replcace()方法返回的是一个新的字符串，如果字符串str中没有找到需要被替换的子字符序列oldstr，则将原字符串返回。

例：

package javaProject001;//包名public class Stringreplace {//创建类public static void main(String[] args) {//主方法String str = "明月几时有，把酒问青天。";//创建字符串对象String restr = str.replace("月", "日");//将str中的“月”全部替换成“日”System.out.println("字符串str替换后的效果："+restr);//输出内容}}

运行结果如下：

注意:
如果要替换的字符oldstr在字符串中重复出现多次，replace)方法会将所有oldstr全部替换成newstr。例如 String str = "java project";
String str2 = str.replace("j","J");此时，str2 的值为Java proJecto
需要注意的是，要替换的字符oldstr的大小写要与原字符串中字符的大小写保持一致，否则不能成

功地替换例如，上面的实例如果写成如下语句，则不能成功替换。

String str = "java project";
String str3 = str.replace("P","t");

2.replaceAll(String regex,String replacement)
该方法可以实现将指定的字符串替换成新的字符串，支持正则表达式。语法如下:

str.replaceAll(regex,replacement);//该方法的使用方式

解释说明：

str:任意字符串。
regex:被替换的字符串或正则表达式。

replacement:替换后的字符串
则表达式是含有一些具有特殊意义字符的字符串，这些特殊字符称为正则表达式的元字符。例如，“ild”示数字0-9中的任何一个，“\ld”就是元字符
例：分别使用replace0方法和replaceA110方法，利用正则表达式将字符串中所有的数字的
换成“?”。

package javaProject001;//包名public class StringReplaceAll {//创建类public static void main(String[] args) {//主方法String str = "0123456789abc\\d";//创建字符串对象String restr = str.replace("\\d", "？");//使用replace()将符合"\\d"的表达式字符串替换“？”String restrAll = str.replaceAll("\\d","?");//使用replace()将符合"\\d"的表达式字符串替换“?”//输出结果System.out.println("字符串str："+str);//输出结果System.out.println("使用replace()替换的结果："+restr);//输出结果System.out.println("使用replaceAll()替换的结果："+restrAll);//输出结果}}

运行结果如下：

代码注解:
从这个运行结果可以直观地看出，replace()方法不知道"lld"表达式代表的含义，只是将"lld"当成一个子字符串在str中替换成了"?";而replaceA110知道正则表达式的含义，将所有的数字替换成了"?"，但对于字符串中出现的子字符串"lld"没有做任何操作。

3. replaceFirst(String regex,String replacement)
该方法可以实现将第一个指定的字符串替换成新的字符串，支持正则表达式。

str.replaceFirst(regex,replacement);//该方法的使用方式

解释说明：

str:任意字符串。
regex:第一个被替换的字符串或正则表达式。

replacement:替换后的字符串。

例5.18 现有字符串"8I want to marry you,so I need you!"，去掉第一个数字，再把第一次出现的"you"替换成"her"。

package javaProject001;//包名public class StringReplaceFirst {//创建类public static void main(String[] args) {//主方法String str = "8I want to marry you, so I need you!";//创建字符串对象String noNumber = str.replaceFirst("\\d", "");//将开头的数字替换成两个双引号“”String youToHer = noNumber.replaceFirst("you", "her");//将第一次出现的“you”替换成“her”System.out.println("替换之后的结果是：" +youToHer);//输出结果}}

运行结果如下:

5.4.3 字符串分割

1. split (String regex)

该方法可根据给定的分隔符对字符串进行拆分，支持正则表达式，最后返回一个字符串数组。

语法如下：

str.split(regex);//该方法的使用方式

解释说明：

str：任意字符串。

regex：分隔符表达式。

例：创建一个字符串，用“，”分割

package javaProject001;//包名public class StringSplit {//创建类public static void main(String[] args) {//主方法String str = "从前有座山，山里有个庙，庙里有个小松鼠。";//创建字符串对象String[] strArray = str.split("，");//让字符串按照“，”进行分割for (int i = 0; i<strArray.length;i++)//使用for循环，循环输出数字所有元素{System.out.println("数组第" + i + "索引的元素是：" +strArray[i]);//输出内容}}}

运行结果如下：

如果想定义多个分隔符，可以使用符号“|”。如果用“|”分割字符串，需要用到转义字符“\\|”。

例：同时使用不同的分隔符分割同一个字符串。

package javaProject001;//包名public class StringSplit2 {//创建类public static void main(String[] args) {//主方法String str = "a1b2,c,d e f|gh";//创建字符串对象String[] a1 = str.split(",");//使用“，”分隔String[] a2 = str.split(" ");//使用“ ”分隔String[] a3 = str.split("\\|");//使用“|”分隔String[] a4 = str.split("\\d");//使用正则表达式分割，本行用数字分割String[] a5 = str.split(",| |\\||\\d");//同时使用“，”、“空格”、“|”、数字分割，用“|”连接所有分隔符System.out.println("str的原值："+str);//显示str原值System.out.println("使用\",\"分割：");//输出内容for(String b:a1) {//使用for-each循环展示结果System.out.print("["+b+"]");//输出，分割后的结果}System.out.println();//换行System.out.println("使用空格分割：");//输出内容for(String b:a2) {//使用for-each循环展示结果System.out.print("["+b+"]");//输出，分割后的结果}System.out.println();//换行System.out.println("使用\"|\"分割：");for(String b:a3) {//使用for-each循环展示结果System.out.print("["+b+"]");//输出，分割后的结果}System.out.println();//换行System.out.println("使用数字分割：");for(String b:a4) {//使用for-each循环展示结果System.out.print("["+b+"]");//输出，分割后的结果}System.out.println();//换行System.out.println("同时使用所有分隔符：");//使用for-each循环展示数字分割结果for(String b:a5) {//使用for-each循环展示结果System.out.print("["+b+"]");//输出，分割后的结果}System.out.println();//换行}}

运行结果如下：

2.spilt(String regex,limit)

该方法可根据给定的分隔符对字符串进行拆分，并限定拆分的次数，支持正则表达式。

语法如下：

str.split(regex,limit);//该方法的使用方式

解释说明：

str：任意字符串。

regex:分隔符表达式。

limit：限定的分割次数。

例：将字符串“192.168.0.1”按照“.”拆分两次，第一次全部拆分，第二次拆分两次。

package javaProject001;//包名public class StringSpilit3 {//创建类public static void main(String[] args) {//主方法String str = "192.168.0.1";//创建字符串对象String[] firstArray = str.split("\\.");//按照“.”进行分割String[] secondArray = str.split("\\.",2);//按照“.”进行分割System.out.println("str的原值为：["+str+"]");//输出str原值System.out.println("全部分割的结果：");//输出全部结果for(String a:firstArray) {//for-each循环展示分割结果System.out.print("["+a+"]");//输出结果}System.out.println();//换行System.out.println("分割两次的结果：");//输出分割两次的结果for(String a:secondArray) {//for-each循环展示分割结果System.out.print("["+a+"]");//输出结果}System.out.println();//换行}}

运行结果：

5.4.4 大小写转换

1. toLowerCase()

该方法将String转换为小写，如果字符串中没有应被转换的字符，则将原字符串返回；否则将返回一个新的字符串，将原字符串中每个可进行小写转换的字符都转换成等价的小写字符，字符串长度与原字符串长度相同。

语法如下：

str.toLowerCase();//该方法的使用方式

其中 str代表任意字符串。

2. toUpperCase()

该方法将String转换为大写，如果字符串中没有应被转换的字符，则将原字符串返回；否则将返回一个新的字符串，将原字符串中每个可进行大写转换的字符都转换成等价的大写字符，字符串长度与原字符串长度相同。

语法如下：

str.toUpperCase();//该方法的使用方式

其中 str代表任意字符串。

例：将字符串“abc DEF”分别用大写、小写两种格式输出。

package javaProject001;//包名public class StringTransform {//创建类public static void main(String[] args) {//主方法String str = "abc DEF";//创建字符串对象System.out.println(str.toLowerCase());//按照小写格式输出System.out.println(str.toUpperCase());//按照大写格式输出}}

运行结果如下：

5.4.5 去除空白内容

trim()方法可以返回字符串的副本，忽略首尾处空白。语法如下：

str.trim();//该方法的使用方式

其中str代表任意字符串。

例：使用trim()方法去掉字符串两边的空白内容。

package javaProject001;//包名public class StringTrim {//创建类public static void main(String[] args) {//主方法String str = "         abc          ";//创建字符串对象String shortStr = str.trim();//使用trim()方法 处System.out.println("str的原值是：["+str+"]");//输出str的原值System.out.println("去掉首尾空白的值：["+ shortStr +"]");//输出去除空白后的值}}

运行结果如下：

例2：去除字符串中所有的空白

package javaProject001;//包名public class StringRemoveBlank {//创建类public static void main(String[] args) {//主方法String str= "a b cd e    f  g      ";//创建字符串对象String shortstr = str.replaceAll("\\s", "");//利用正则表达式，将字符串中所有的空白内容替换成“ ”System.out.println("str的原值是：["+str+"]");//输出内容System.out.println("删除空内容之后的值是：["+shortstr+"]");//输出删除空内容之后的值}}

运行结果如下：

5.4.6 比较字符串是否相等

对字符串对象进行比较不能简单的使用比较运算符“==”，因为比较运算符比较的是两个字符串的内存地址是否相同，因为即使两个字符串的文本值相同，两个对象的内存地址也可能不同，所以使用比较运算符会返回false.

例：使用比较运算符计较两个字符串。

package javaProject001;//包名public class StringCompare {//创建类public static void main(String[] args) {//主方法String a,b;//引入字符串常量a = "I am a student";//给a赋值b = "I am a student";//给b赋值System.out.println("直接引入字符串常量的比较结果："+ (a==b));//直接引入字符串常量的比较a = new String("I am a student");//使用new创建对象b = new String("I am a student");//使用new创建对象System.out.println("使用new创建对象的比较结果："+ (a==b));//使用new创建对象的比较}}

运行结果如下：

注解：

为什么第一个结果是true,第二个结果是false呢?因为两种赋值方法在计算机中处理的方不同。像字符串常量这样的字面值，会直接放在栈中。例子5.25中tom和jerry直接用字符串常赋值时，其字符串值保存的是一个指向栈中数据的引用。又因为两个对象引用的是同一个常量，用“一”比较发现两者指向了相同的地址，所以结果会返回 true，如图 5.32 所示。
如果tom和jerry创对象，算处理方式就不一样了。当tom使用new方法时，会在堆中创建一个新的 String对象，并为这个对象单独在栈中创建值，即使与栈中已有相同数据，也不会共享。用“-”比较发现两者指向不同的对象地址，结果会返回 false，如图 5.33 所示。

想要比较两个字符串对象的内容是否相同，就需要用equalsO和equalsIgnoreCaseO方法。
1. equals(String str);
将此字符串与指定的对象比较。当且仅当该参数不为null，并且是与此对象表示相同字符序列的String 对象时，结果才为true。
语法如下:

a.equals(str);//该方法的使用方式

解释说明：

a:任意字符串。
str:进行比较的字符串。
例5.26创建String变量，分别用“=”和equals()方法判断两个字符串是否相等。

package javaProject001;//包名public class StringEquals {//创建类public static void main(String[] args) {//主方法String str1 = "Hello";//创建字符串对象String str2 = new String ("Hello");//用new创建字符串对象String str3 = new String ("你好");//用new创建字符串对象String str4 = str2;//创建和str2相同内容的字符串System.out.println("str1==str2 的结果：" + (str1 == str2));//输出结果System.out.println("str1==str3 的结果：" + (str1 == str3));//输出结果System.out.println("str1==str4 的结果：" + (str1 == str4));//输出结果System.out.println("str2==str4 的结果：" + (str2 == str4));//输出结果System.out.println("str1.equals(str2) 的结果" + str1.equals(str2));//使用equals方法比较System.out.println("str1.equals(str3) 的结果" + str1.equals(str3));//使用equals方法比较System.out.println("str1.equals(str4) 的结果" + str1.equals(str4));//使用equals方法比较}}

运行结果如下：

注意：

String str = null;和String str = "";是两种不同的概念。前者是空对象，没有指向任何引用地址，调用String的API会抛出NullPointerException 空指针异常，""是一个字符串，分配了内存空间，可以调用String的API，只是没有显示任何东西而已。

2. equalslgnoreCase(String anotherString)

此字符串对象与指定的对象比较，不考虑大小写。如果两个字符串的长度相同，并且其中相应的字符都相等(忽略大小写) 则认为这两个字符串是相等的。

语法如下：

a.equalsIgnoreCase(String anotherString);//此方法的使用方式

解释说明:a:任意字符串。

anotherString：进行比较的字符串。

例：使用equals()和equalsIgnoreCase()方法判断两个字符串支付相等。

package javaProject001;public class StringEqualsIgnoreCase {public static void main(String[] args) {String str1 = "abc";//创建字符串对象，内容全部小写String str2 = "ABC";//创建字符串对象，内容全部大写System.out.println("区分大小写的结果：" +str1.equals(str2));//比较两个字符串的内容是否相等System.out.println("不区分大小写的结果：" +str1.equalsIgnoreCase(str2));//比较两个字符串的内容是否相等}}

运行结果如下：

多学两招：

(1)字符串常量也可以使用equals和equalsIgnoreCase()方法，例如：

boolean a = "一闪一闪".equals.("亮晶晶");//布尔类型数据判断两个字符串是否相等
boolean b = "功夫".equals.("java");//布尔类型数据判断两个字符串是否相等

（2）判断一个字符串str是否为空，需要分别判断str是否等于null或""。判断null用“==”，判断""用equals()方法，两者不可混淆。str一个作为equals的参数，否则当str是空对象时，调用equals()会抛出空指针异常

String str = "123";//创建字符串对象
if ( null == str || "".equals(str)){//if语句判断字符串是否为空
System.out.println("str时候空的");//输出结果

5.4.7 格式化字符串

String类的静态format()方法用于创建格式化的字符串。format()方法有两种重载形式。

（1） format(String format,Object...args)

该方法使用指定的格式字符串和参数返回一个格式化字符串，格式化后的新字符串使用本地默认的语言环境。

语法如下：

str.format(String format,Object ...args)//该方法的使用方式

解释说明：

format：格式化字符串。

args ：格式字符串中由格式说明符引用的参数。如果还有格式说明符以外的参数，则忽略这些额外的参数。此参数的数目是可变的，可为0。

（2）format(Local 1,String format,Object...args)

1：格式化过程中要应用的语言环境。如果1为null，则不进行本地化。

format：格式化字符串。。

args：格式化字符串中有格式说明符引用的参数。如果还有格式说明符以外的参数，则忽略这些额外的参数。此参数的数目是可变的，可为0。

1.日期和时间字符串格式化

在应用程序设计中，需要经常使用时间和日期。如果想输出满意的日期和时间格式，一般需要编写大量的代码。format()方法通过给定的特殊转换符作为参数来实现对日期和时间的格式化。

（1）日期格式化

返回一个月中的天数。实例代码如下：

Date date = new Date();//创建Date对象date
String s = String.format("%te",date);//通过format()方法对大同人进行格式化

上述代码中变量s的值是当前日期中的天数，如果建团是15号，则s的值为15；%te是转换符，常用的日期格式化转换符如下表所示。

例：显示当前日期

package boketask;//包名
import java.util.Date;//引入Date方法
public class Eval {//创建类public static void main(String[] args) {//主方法Date date = new Date();//新建Date对象dateString year = String.format("%tY", date);//将date进行格式化String month = String.format("%tB",date);//将date进行格式化String day = String.format("%td", date);//将date进行格式化System.out.println("今年是：" + year+"年");//输出信息System.out.println("现在是：" + month);//输出信息System.out.println("今天是：" + day+"号");//输出信息}}

运行结果如下：

（2）时间格式化

使用format()方法也能实现时间的格式化，可以将时间格式化为时、分、秒、毫秒。如下图所示：

例：显示当前的时间

package boketask;//包名
import java.util.Date;//引入方法
public class getDate {//创建类public static void main(String[] args) {//主方法Date date = new Date();//创建Date对象dateString hour = String.format("%tH",date);//将date进行格式化String minute = String.format("%tM",date);//将date进行格式化String second = String.format("%tS",date);//将date进行格式化System.out.println("现在是："+hour + "时"+ minute+ "分");//输出内容}}

运行结果如下：

（3）格式化常见的日期时间组合

例:：显示日期时间

package boketask;//包名
import java.util.Date;//导入java.util.Date类
public class DateAndTime {//创建类public static void main(String[] args) {//主方法Date date = new Date();//创建Date对象String time = String.format("%tc",date);//将date格式化String form = String.format("%tF", date);//将date格式化System.out.println("全部的时间信息是：" +time);//输出格式化的日期时间System.out.println("年-月-日格式："+form);//输出格式化的日期时间}}

运行结果如下：

2.常规类型格式化

常规类型格式化可应用于他人和类型参数，可以通过下表的转换符来实现。

例：实现不同类型的格式转化

package boketask;//包名public class StringFormat {//创建类public static void main(String[] args) {//主方法String str1 = String.format("%c", 'X');//输出字符System.out.println("字母x大写：" + str1 );//输出字符String str2 = String.format("%d",125+231);//格式转化System.out.println("123+312d的结果：" +str2);//输出字符String str3 = String.format("%.2f",Math.PI);//格式转化System.out.println("n取连伟小数点："+ str3);//输出字符String str4 = String.format("%b",2<3);//格式转化System.out.println("2<3的结果为："+str4);//输出字符String str5 = String.format("%h",3521);//格式转化System.out.println("3521的hashCode值：" + str5);//输出内容String str6 = String.format("%o",33);//格式转化System.out.println("33的八进制结果："+str6);//输出内容String str7 = String.format("%x",33);//格式转化System.out.println("33的16进制结果："+str7);//输出内容String str8 = String.format("%e",12000.1);//格式转化System.out.println("12000.1用科学计数法表示："+str8);//输出内容String str9 = String.format("%a",40.0);//格式转化System.out.println("40.0的16进制浮点值："+ str9);//输出内容System.out.println(String.format("天才是由%d%%的灵感,%d%%的汗水。",1,99));//输出百分号和数字}}

运行结果如下：

5.5可变字符

类名对象类型执行效率线程安全性

String 指向另外的空间常量慢不安全

StringBuffer 指向在原来的基础上添加变量中有锁安全

Stringbuilder 在原来的基础上添加变量快无锁不安全

5.5.1 StringBuffer类的常用方法

1.创建StringBuffer类

StringBuffer sbf=new StringBuffer();//创建StringBuffer对象
StringBuffer sbf=new StringBuffer("abc");//创建对象并传入值
StringBuffer sbf=new StringBuffer(32);//创建对象并传入值

2.append()方法

将参数转换成字符串，将所有字符串中的字符追加到此序列中。

str.append(obj);//该方法的使用方法

解释说明:
sbf:任意StringBuffer对象

obj:任意数据类型的对象，使append()方法都转变成字符串的表示形式。

public static void main(String[] args) {StringBuffer sbf=new StringBuffer("门前大桥下,");//创建StringBuffer对象sbf.append("游过一群鸭,");//追加字符串常量StringBuffer tmp=new StringBuffer("快来快来数一数,");//追加StringBuffer对象sbf.append(tmp);//追加字符串常量int x=24678;//定义一个整型常量sbf.append(x);//追加字符串常量System.out.println(sbf.toString());//输出}

3.setCharAt(int index,char ch)方法

将给定索引处的字符修改成ch.

sbf.setCharAt(index,ch);//该方法的使用方法

解释说明：
sbf:任意StringBuffer对象

index:被替换字符的索引

替换后的字符

public static void main(String[] args) {StringBuffer sbf=new StringBuffer("0123456");//创建StringBuffer对象System.out.println("sbf的原值是："+sbf);//输出信息sbf.setCharAt(3, 'A');//将索引为3的字符改成‘A’System.out.println("修改后的值是："+sbf);//输出信息}

4.insert(int offset,String str)方法

将字符串插入此字符序列中

sbf.insert(offset,str);//该方法的使用方法

解释说明：
sbf:任意StringBuffer对象

offset:插入的索引

str:插入的字符串

public class test35 {public static void main(String[] args) {StringBuffer sbf=new StringBuffer("0123456");//创建StringBuffer对象System.out.println("sbf的原值为："+sbf);//输出信息sbf=sbf.insert(5, "F");//在索引为5的位置插入“F”，将返回值赋给sbf自己System.out.println("修改之后的值为："+sbf);//输出信息}}

运行结果如下：

5.reverse()方法

sbf.reverse();//该方法的使用方法

例：

public static void main(String[] args) {StringBuffer sbf=new StringBuffer("同一个世界，同一个梦想");//创建一个StringBuffer对象System.out.println("sbf的原值为："+sbf);//输出信息sbf=sbf.reverse();//将字符序列sbf反转System.out.println("修改之后的值为："+sbf);//输出信息}

6.delete(int start,int end)方法

sbf.delete(start,end);
sbf:任意StringBuffer对象

start:起始索引

end:结束索引

例：

public static void main(String[] args) {StringBuffer sbf=new StringBuffer("天行健，君子以自强不息");//创建StringBuffer对象System.out.println("sbf的原值为："+sbf);//输出信息sbf=sbf.delete(4, 7);//删除从索引4开始至索引7之前的内容System.out.println("删除之后的值为："+sbf);//输出信息}

运行结果如下：

其他方法：

public static void main(String[] args) {StringBuffer sbf=new StringBuffer("ABCDEFG");//创建字符串序列int lenght=sbf.length();//获取字符串序列的长度char chr=sbf.charAt(5);//获取索引为5的字符int index=sbf.indexOf("DEF");//获取DEF字符串所在的索引位置String substr=sbf.substring(0,2);//截取从索引0开始至索引2之间的字符串StringBuffer tmp=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);//输出信息}

运行结果如下：

7.StringBuilder类使用方法

public static void main(String[] args) {StringBuffer sbd=new StringBuffer();//创建一个StringBuffer对象System.out.println("sbd的原值为空");//输出信息sbd.append("我是StringBuffer类");//追加字符串System.out.println("sbd追加字符串："+sbd);//输出信息int length=sbd.length();//获取sbd字符串的长度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);//输出}

8.StringBuffer、StringBuilder、String之间的相互转换

public static void main(String[] args) {String str="String";//创建一个字符串StringBuffer sbf=new StringBuffer(str);//String转换成StringBufferStringBuilder sbd=new StringBuilder(str);//String转换成Stringbuilderstr=sbf.toString();//StringBuffer转换成Stringstr=sbd.toString();//StringBuilder转换成StringStringBuilder bufferTobuilder=new StringBuilder(sbf.toString());//StringBuffer转换成StringBuilderStringBuffer buliderToBuffer=new StringBuffer(sbf.toString());//StringBuilder转换成StringBuffer}

 public static void main(String[] args) {// TODO Auto-generated method stubString str = ""; // 创建空字符串// 定义对字符串执行操作的起始时间long starTime = System.currentTimeMillis();for (int i = 0; i < 10000; i++) { // 利用for循环执行10000次操作str = str + i; // 循环追加字符串}long endTime = System.currentTimeMillis(); // 定义对字符串操作后的时间long time = endTime - starTime; // 计算对字符串执行操作的时间System.out.println("String循环1万次消耗时间：" + time); // 将执行的时间输出StringBuilder builder = new StringBuilder(""); // 创建字符串生成器starTime = System.currentTimeMillis(); // 定义操作执行前的时间for (int j = 0; j < 10000; j++) { // 利用for循环进行操作builder.append(j); // 循环追加字符}endTime = System.currentTimeMillis(); // 定义操作后的时间time = endTime - starTime; // 追加操作执行的时间System.out.println("StringBuilder循环1万次消耗时间：" + time); // 将操作时间输出StringBuilder builder2 = new StringBuilder(""); // 创建字符串生成器starTime = System.currentTimeMillis(); // 定义操作执行前的时间for (int j = 0; j < 50000; j++) { // 利用for循环进行操作builder2.append(j); // 循环追加字符}endTime = System.currentTimeMillis(); // 定义操作后的时间time = endTime - starTime; // 追加操作执行的时间System.out.println("StringBuilder循环5万次消耗时间：" + time); // 将操作时间输出}}

运行结果如下：

第五章字符串总结相关推荐

PHP:第五章——字符串的概念
<?php header("Content-Type:text/html;charset=utf-8"); //字符串概念://1.单引号.//里面的变量不会被解释 //例: ...
《程序员代码面试指南》第五章字符串问题拼接所有字符串产生字典顺序最小的大写字符串...
题目拼接所有字符串产生字典顺序最小的大写字符串 java代码努力中.... 转载于:https://www.cnblogs.com/lizhouwei/p/8955158.html
《高性能JavaScript》第五章字符串和正则表达式
5.1 字符串连接当连接少量字符串时,这些方法运行速度都很快.随着要合并的字符串长度和数量增加时,有些方法就开始展现优势. 5.1.1 加(+)和加等(+=)操作符这是一个常见的字符串连接: st ...
PHP:第五章——字符串输出函数
<?php header("Content-Type:text/html;charset=utf-8"); /*字符串输出函数*/ //1.echo 输出一个或多个字符//2 ...
《程序员代码面试指南》第五章字符串问题找到字符串的最长无重复字符子串...
题目找到字符串的最长无重复字符子串 java代码努力中.... 转载于:https://www.cnblogs.com/lizhouwei/p/8955166.html
第五章---字符串+序列转化
1."""判断回文数""" s = "123321" if s == s[::-1]:print("是回文数& ...
程序员代码面试指南刷题--第五章.字符串的调整II
题目描述给定一个字符类型的数组chas[],chas右半区全是空字符,左半区不含有空字符.现在想将左半区的空格字符串替换成"%20",假设chas右半区足够大,可以满足替换需要的 ...
程序员代码面试指南刷题--第五章.字符串的调整I
题目描述给定一个字符串chas[],其中只含有字母字符和""字符,现在想把所有""全部挪到chas的左边,字母字符移到chas的右边.完成调整函数. 输入描述 ...
java十五章_java：第十五章
第十五章字符串1.字符串(String)的定义 String str="内容"; String str=new String(); //内容为null String str=ne ...

第五章字符串总结

5.1 String类

5.1.1 声明字符串

5.1.2 创建字符串

5.2 连接字符串

5.3 提取字符串信息

5.3.1 获取字符串长度

5.3.2 获取指定字符

5.3.3 获取子字符串索引位置

5.3.4 判断字符串首尾内容

5.3.5 获取字符数组

5.4 字符串的操作

5.4.1 截取字符串

5.4.2 字符串替换

5.4.3 字符串分割

5.4.4 大小写转换

5.4.5 去除空白内容

5.4.7 格式化字符串

5.5可变字符

5.5.1 StringBuffer类的常用方法

1.创建StringBuffer类

2.append()方法

3.setCharAt(int index,char ch)方法

4.insert(int offset,String str)方法

5.reverse()方法

6.delete(int start,int end)方法

7.StringBuilder类使用方法

8.StringBuffer、StringBuilder、String之间的相互转换

第五章字符串总结相关推荐

最新文章

热门文章

第五章 字符串 总结

5.1 String类

5.1.1 声明字符串

5.1.2 创建字符串

5.2 连接字符串

5.3 提取字符串信息

5.3.1 获取字符串长度

5.3.2 获取指定字符

5.3.3 获取子字符串索引位置

5.3.4 判断字符串首尾内容

5.3.5 获取字符数组

5.4 字符串的操作

5.4.1 截取字符串

5.4.2 字符串替换

5.4.3 字符串分割

5.4.4 大小写转换

5.4.5 去除空白内容

5.4.7 格式化字符串

5.5可变字符

5.5.1 StringBuffer类的常用方法

1.创建StringBuffer类

2.append()方法

3.setCharAt(int index,char ch)方法

4.insert(int offset,String str)方法

5.reverse()方法

6.delete(int start,int end)方法

7.StringBuilder类使用方法

8.StringBuffer、StringBuilder、String之间的相互转换

第五章 字符串 总结相关推荐

最新文章

热门文章

第五章字符串总结

第五章字符串总结相关推荐