第五章 字符串 总结

目录

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的字符赋值给chr
		System.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"首次出现的索引，赋值给charIndex
		if (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对象date
		String 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对象date
		String 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转换成StringBuffer
        StringBuilder sbd=new StringBuilder(str);//String转换成Stringbuilder
        str=sbf.toString();//StringBuffer转换成String
        str=sbd.toString();//StringBuilder转换成String
        StringBuilder bufferTobuilder=new StringBuilder(sbf.toString());//StringBuffer转换成StringBuilder
        StringBuffer buliderToBuffer=new StringBuffer(sbf.toString());//StringBuilder转换成StringBuffer
        
 
    }

 
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String 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); // 将操作时间输出
    }
 
}

运行结果如下：