第五章 字符串

目录

5.1 String类

5.1.1 声明字符串

5.1.2 创建字符串

5.2 连接字符串

5.2.1 连接字符串

5.2.2 连接其他数据类型

5.3 提取字符串信息

5.3.1 获取字符串长度

5.3.2 获取指定字符串

5.3.3 获取子字符串索引位置

5.3.4 判断字符串首尾内容

5.3.5 获取字符数组

5.3.6 判断字符串是否存在

5.4 字符串的操作

5.4.1 截取字符串

5.4.2 字符串转换

5.4.3 字符串分割

5.4.4 大小写转换

5.4.5 去除空白内容

5.4.6 比较字符串是否相等

5.4.7 格式化字符串

5.5 可变字符串

5.5.1 StringBuffer类的常用方法

5.5.2 StringBuilder类的使用方法

5.5.3 StringBuffer、StringBuilder、String之间的关系

---

5.1 String类

5.1.1 声明字符串

    字符串是常量，它们可以显示任何文字信息，字符串的值在创建之后不能更改。在Java语言中，单引号中的内容表示字符，例如's'，而双引号中的内容则表示字符串，例如：

 "我是字符串”，"123456789" ，" 上下左右东西南北”

     Java通过java lang String这个类来创建可以保存字符串的变量，所以字符串变量是一个对象。声明一个字符串变量a,以及声明两个字符串变量a、b。代码如下:

 String a;
 String a,b;

 注意:在不给字符串变量赋值的情况下，默认值为null,就是空对象，如果此时调用String的方法会发生空指针异常。

5.1.2 创建字符串

 1.引用字符串常量

 例如，直接将字符串常量赋值给String类型变量。代码如下:                                                      String a = "时间就是金钱，我的朋友。";                                                                                        String b = "锄禾日当午"，c = "小鸡炖蘑菇";                                                                              String str1, str2;                                                                                                                          str1=. "We are students";                                                                                                              srt2 = "We are students";

 当两个字符串对象引用相同的常量时，就具有相同的实体，内存示意图如图所示。 

 2.利用构造方法实例化

例如，使用new关键字创建String对象。代码如下:

String a = new String("我爱清汤小肥羊");                                                                                  String b = new String(a) ;

 3.利用字符数组实例化

例如，定义一个字符数组charArray,使用该字符数组创建一个字符串。 代码如下:                     char[ ] charArray = { 't', 'i', 'm', 'e' };                                                                                            String a = new String (charArray) ;

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

 例如，定义一个字符数组charArray从该字符数组索引3的位置开始，提取两个元素，创建一个字符串。代码如下:                                                                                                                            char[ ] charArray = { '时，间，'就'， '是，'金'，'钱，};                                                                    String a = new String (charArray, 3，2);

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

}

5.2 连接字符串

     对于以声明的字符串，可以对其进行相应的操作连接，字符串就是字符操作中较简单的一种，可以对多个字符串进行连接，也可使字符串与其他数据类型进行连接。

5.2.1 连接字符串

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

public class StringConcatenation {//创建类
	public static void main(String[] args) {//主方法
		String a ="abc"; //创建string类型的a并且赋值为abc
		   String b="123";//创建string类型的b并且赋值为123
		   String c=a + b +"！" ;//使用“+”拼接字符串 
		   String d ="拼接字符串";//创建string类型的d并且赋值为拼接字符串
		   d += c; // 使用“+=”拼接字符串 
		   System.out.println("a ="+a);//输出"a = " + a
		   System.out.println("b="+b);//输出"b = " + b
		   System.out.println("c="+c); //输出"c = " + c
		   System.out.println("d="+d);//输出"d = " + d
	}

}

 

5.2.2 连接其他数据类型

   字符串也可同其他基本数据类型进行连接。如果将字符串同这些数据类型进行连接，会将这些数据直接转换成字符串。

public class Link {//创建类
	public static void main(String[] args) {//主方法
		int booktime=4;//声明的int型变量booktime 
		  float practice = 2.5f; // 声明的float型变量practice
		  //将字符串与整型、浮点型变量相连，并将结果输出
		  System.out.println("我每天花费"+booktime+"小时看书;"+practice+"小时上机练习");//输出我每天花费" + booktime + "小时看书; " + practice + "小时上机练习
	}

}

 

注意:只要“+”运算符的一个操作数是字符串，编译器就会将另一个操作数转换成字符串形式，所以应谨慎地将其他数据类型与字符串相连，以免出现意想不到的结果。 

5.3 提取字符串信息

 字符串作为对象可以通过相应的方法获取字符串的有效信息如何取的各索引位置的字符等。

5.3.1 获取字符串长度

 length()方法返回采用UTF-16的编码表示字符的数量，也就是char的数量。

 str.length ()；

长度 字符串名.length();

String a = “建团一百周年”

Int b = a. length();

注意: 字符串的length( )方法与数组的length虽然都是用来获取长度的，但两者却有些不同。String 的length( )是类的成员方法，是有括号的;数组的length是一个属性，是没有括号的。

5.3.2 获取指定字符串

 charAt(String index)方法可将指定索引处的字符返回。

str. charAt (index);

str: 任意字符串对象。

index: char值的索引。

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

 

5.3.3 获取子字符串索引位置

       String类提供了两种查找字符串的方法，即indexOfO与lastIndexOfO方法。indexOf0方法返回的是搜索的字符或字符串首次出现的位置，lastIndexOfO方法返回的是搜索的字符或字符串最后一次出现的位置。

1.indexOf(String str)

indexOf(substr)；

a：任意字符串对象。

substr：要搜索的字符串。

public class StringIndexOf {//创建类
	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字符串");//输出str中存在abc字符串
		}else {//如果index等于-1，则执行此行代码，说明str中没有“abc”字符串
			System.out.println("str中没有abc字符串");//输出str中没有abc字符串
		}
	}

}

 

 2.indexOf(String srt,int fromindex)

a.indexOf(str,fromIndex);

a：任意字符串对象

str：要搜索的子字符串

fromindex：开始搜索的索引位置

public class StringIndexOf2 {//创建类
	public static void main(String[] args) {//主方法
			// 创建字符串
			String str = "We are the world";
			// 获取字符串中"r"第一次出现的索引位置
			int firstIndex = str.indexOf("r");
			// 获取字符串中"r"第二次出现的索引位置，从第一次出现的索引位置之后开始查找
			int secondIndex = str.indexOf("r", firstIndex + 1);
			// 获取字符串中"r"第三次出现的索引位置，从第二次出现的索引位置之后开始查找
			int thirdIndex = str.indexOf("r", secondIndex + 1);
			// 输出三次获取的索引位置
			System.out.println("e第一次出現的索引位置是：" + firstIndex);//输出e第一次出現的索引位置是：" + firstIndex
			System.out.println("e第二次出現的索引位置是：" + secondIndex);//输出e第二次出現的索引位置是：" + secondIndex
			System.out.println("e第三次出現的索引位置是：" + thirdIndex);//输出e第三次出現的索引位置是：" + thirdIndex
	}
}

 3.pubile int lastindexOf(String srt)

a.last IndexOf(str);

a：任意字符串

srt：要搜索的字符串

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 it 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 srt,int fromindex)

a.lastIndexOf(str,int fromindex);

a：任意字符串

srt：要搜索的子字符串

fromindex：开始搜索的索引位置

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

}

5.3.4 判断字符串首尾内容

 1.starsWith(String prefix)

str.startsWith(prefix);

srt：任意字符串

prefix：作为前缀的字符串

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

		}
	}
}

 2.starsWith(String prefix，int toffset)

str.startsWith(perfix,index);

srt：任意字符串

prefix：作为前缀的字符串

index：开始查询位置

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 + 1);// 换行符在字符串中只占一个字符，所以enterIndex + 1
		if (flag) {// 如果结果为真，则输出此句
			System.out.println("第二行是以\"举\"开始的");//输出第二行是以\"举\"开始的
		} else {// 如果结果为假，则输出第二行开头第一个字符
			System.out.println("第二行是以\"" + str.charAt(enterIndex + 1) + "\"开始的");// 如果结果为假，则输出第二行开头第一个字符
		}
	}
}

 

 3.endsWith(String suffix)

str.endsWith(suffix)

srt：任意字符串

suffix：指定的后缀字符串

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:表示任意字符串

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 判断字符串是否存在

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

 str.contains (String)；

str：任意字符串

String：查询子字符串

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

5.4 字符串的操作

5.4.1 截取字符串

 1.substring(int beginIndex) 

str. substring (beginIndex);

str:任意字符串

beginIndex:起始索引(包括)

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

 2.substring(int beginIndex,int endIndex)

str. substring (beginIndex, endIndex);

 str:任意字符串

 beginIndex:起始索引(包括)

 endIndex:结束索引(不包括)

public class StringSub2 {//创建类
	public static void main(String[] args) {//主方法
		String str = "闭门造车，出门合辙。";//定义String类型的str赋值为闭门造车，出门合辙
		// 从0开始（即从头开始）截取至4-1索引位置的子字符串
		String substr = str.substring(0, 4);//输入0到4的字符串
		System.out.println("字符串str的前半句是：" + substr);//输出前半句的字符串
	}
}

 

5.4.2 字符串转换

 1. replace(CharSequence target, CharSequence replacement)

str.replace(oldstr,newstr);

str: 任意字符串

oldstr:要被替换的字符序列

newstr:替换后的字符序列

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

public class StringReplace {//创建类
	public static void main(String[] args) {//主方法
		String str="明月几时有，把酒问青天";//定义String类型的str赋值为明月几时有，把酒问青天		
		String restr=str.replace("月", "日");	//将str中的”月“全部替换成”日“
		System.out.println("字符串str替换之后的效果："+restr);//输出字符串str替换之后的效果："+restr
	}
}

 2. replaceAll(String regex, String replacement)

str. replaceAll (regex, replacement) ;

str: 任意字符串

regex: 被替换的字符串或正则表达式

replacement:替换后的字符串

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", "?");// 使用replaceAll()将符合"\\d"表达式的字符串替换"?"
		System.out.println("字符串str：" + str);// 输出结果
		System.out.println("使用replace()替换的结果：" + restr);//输出使用replace()替换的结果：" + restr
		System.out.println("使用replaceAll()替换的结果：" + restrAll);//输出替换后的结果
	}
}

 3. replaceFirst(String regex, String replacement)

str.replaceFirst (regex, replacement) ;

str:任意字符串

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

replacement: 替换后的字符串

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：分隔符表达式

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]);//输出索引的元素
		}
	}
}

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

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.print("使用\",\"分割：");// 使用for-each循环展示","分割的结果
		for (String b : a1) {//使用for循环
			System.out.print("[" + b + "]");//输出"[" + b + "]"
		}
		System.out.println();		// 换行
		System.out.print("使用空格分割：");// 使用for-each循环展示空格分割的结果
		for (String b : a2) {//换行
			System.out.print("[" + b + "]");//输出"[" + b + "]"
		}
		System.out.println();
		System.out.print("使用\"|\"分割：");// 使用for-each循环 展示"|"分割的结果
		for (String b : a3) {//使用for循环
			System.out.print("[" + b + "]");//输出"[" + b + "]"
		}
		System.out.println();
		System.out.print("使用數字分割：");// 使用for-each循环展示数字分割的结果
		for (String b : a4) {//使用for循环
			System.out.print("[" + b + "]");//输出"[" + b + "]"
		}
		System.out.println();
		System.out.print("同時使用所有分隔符：");// 使用for-each循环展示所有分隔符同时分割的结果
		for (String b : a5) {//使用for循环
			System.out.print("[" + b + "]");//输出"[" + b + "]"
		}
		System.out.println();// 换行
	}
}

 2. sit(tigi regex, int limit）

str.split(regex, limit)

str:任意字符串

regex: 分隔符表达式

public class StringSplit3 {//创建类
	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.print("全部分割的结果：");// 输出全部分割的结果
		for (String a : firstArray) {//使用for循环
			System.out.print("[" + a + "]");//输出"[" + a + "]"
		}
		System.out.println();// 换行
		
		System.out.print("分割两次的结果：");// 输出分割两次的结果
		for (String a : secondArray) {//使用for循环
			System.out.print("[" + a + "]");//输出"[" + a + "]"
		}
		System.out.println();//换行
	}
}

 

5.4.4 大小写转换

 1. toLowerCase( )

str. toLowerCase ( ) ;

str: 任意字符串。

 2. toUpperCase( )

str. toUpperCase( ) ;

str: 表示任意字符串

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表示任意字符串。

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 + "]");//去掉首尾空白的值
	}
}

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。 

public class StringCompare {//创建类
	public static void main(String[] args) {//主方法
		String tom, jerry;// 直接引入字符串常量
		tom = "I am a student";//定义Tom字符串
		jerry = "I am a student";//定义jerry字符串
		System.out.println("直接引入字符串常量的比较结果：" + (tom == jerry));//输出"直接引入字符串常量的比较结果：" + (tom == jerry)
		tom = new String("I am a student");//定义新的Tom字符串
		jerry = new String("I am a student");//定义新的Jerry字符串
		System.out.println("使用new创建对象的比较结果：" + (tom == jerry));//"使用new创建对象的比较结果：" + (tom == jerry)
	}
}

1. equals(String str);

 a.equals(str);

 a:任意字符串

 st:进行比较的字符串

public class StringEquals {//创建类
	public static void main(String[] args) {//主方法
		String str1 = "Hello";//定义String类型的str1赋值为"Hello"
		String str2 = new String("Hello");//定义String类型的str2赋值为new String("Hello"
		String str3 = new String("你好");//定义String类型的str3赋值为new String("你好")
		String str4 = str2;//定义String类型的str4赋值为str2的值
		System.out.println("str1 == str2 的结果：" + (str1 == str2));//str1结果等于str2
		System.out.println("str1 == str3 的结果：" + (str1 == str3));//str1结果等于str3
		System.out.println("str1 == str4 的结果：" + (str1 == str4));//str1结果等于str4
		System.out.println("str2 == str4 的结果：" + (str2 == str4));//str2结果等于str4
		System.out.println("str1.equals(str2) 的结果：" + str1.equals(str2));//输出结果
		System.out.println("str1.equals(str3) 的结果：" + str1.equals(str3));//输出结果
		System.out.println("str1.equals(str4) 的结果：" + str1.equals(str4));//输出结果
	}
}

 

 2. equalslgnoreCase(String anotherString);

a.equalsIgnoreCase (anotherString) ;

a：任意字符串

 anthrstring： 进行比较的字符串

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));// 比较两个字符串的内容是否相等，不区分大小写
	}
}

5.4.7 格式化字符串

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

(1) format(tring format,Object.. args)

str. format (String format, Object...args)

 format: 格式字符串。

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

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

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

format:格式字符串。

yargs: 格式字符串中由格式说明符引用的参数。如果还有格式说明符以外的参数，则忽略这

些额外的参数。此参数的数目是可变的，可以为0。

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

   在应用程序设计中，经常需要显示时间和日期。如果想输出满意的日期和时间格式，股需要 0-包首现丽编写大量的代码经过各种算法才能实现。format( )方 法通过给定的特殊转换符作为参数来实现对日期和时间的格式化。

(1)日期格式化

先来看下面的例子，返回一个月中的天数。代码如下:

Date date = new Date();  //创建Date对象date

string s = String. format ("&te", date);//通过format ()方法对date进行格式化

import java.util.Date;//导入java.util.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);//输出"现在是:"+month
		System.out.println("今天是：" + day + "号");//输出"今天是:"+day+"号"
	}
}

（2）时间格式化

  使用format()方法不仅可以完成起的格式化，也可以实现时间的格式化，时间格式化转化为仿佛要比日期转换时更多、更精确，它可以将时间格式化为时、分、秒、毫秒。

转换符	说明	示例
%tH	2位数字的24时制的小时（00~23）	14
%tI	2位数字的12时制的小时（01~12）	05
%tk	1~2位数字的24时制的小时（0~23）	5
%tI	1~2位数字的12时制的小时（1~12）	10
%tM	2位数字的分钟（00~59）	05
%tS	2位数字的秒数（00~60）	12
%tL	3位数字的毫秒数（000~999）	920
%tN	9位数字的微秒数（000000000~999999999）	062000000
%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

import java.util.Date; //导入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 + "分" + second + "秒");// 输出的信息
	}
}

 (3)  格式化常见的日期时间组合

格式化日期与时间的转换符定义了各种日期时间组合的格式。

转换符	说明	示例
%tF	“年-月-日”格式（4位年份）	2008-03-25
%tD	“月/日/年”格式（2位年份）	03/25/08
%tc	全部日期和时间信息	星期二三月 25 15:20:00 CST 2008
%tr	“时:分:秒:pM（AM）格式”（12时制）	03:22:06 下午
%tT	“时:分:秒”格式（24时制）	15:23:50
%tR	“时:分”格式（24时制）	15:25

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

 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 class StringFormat {//创建类
	public static void main(String[] args) {//主方法
		String str1 = String.format("%c", 'X');// 输出字符
		System.out.println("字母x大写：" + str1);//输出结果
		String str2 = String.format("%d", 1251 + 3950);// 输出数字
		System.out.println("1251+3950的结果是：" + str2);//输出结果
		String str3 = String.format("%.2f", Math.PI);// 输出小数点后两位
		System.out.println("π取两位小数点：" + str3);//输出结果
		String str4 = String.format("%b", 2 < 3);// 输出布尔值
		System.out.println("2<3的结果是：" + str4);//输出结果
		String str5 = String.format("%h", 3510);// 输出哈希散列码，等同Integer.toHexString(3015);
		System.out.println("3510的hashCode值：" + str5);//输出"3510的hashCode值：" + str5
		String str6 = String.format("%o", 33);// 输出8进制
		System.out.println("33的8进制结果是：" + str6);//输出"33的8进制结果是：" + str6
		String str7 = String.format("%x", 33);// 输出16进制
		System.out.println("33的16进制结果是：" + str7);//输出"33的16进制结果是：" + str7
		String str8 = String.format("%e", 120000.1);// 输出科学计数法
		System.out.println("120000.1用科学计数法表示：" + str8);//输出"120000.1用科学计数法表示：" + str8
		String str9 = String.format("%a", 40.0);// 输出带有效位数和指数的16进制浮点值
		System.out.println("40.0的十六进制浮点值：" + str9);//输出"40.0的十六进制浮点值：" + str9
		System.out.println(String.format("天才是由%d%%的灵感，%d%%的汗水 。", 1, 99));//输出String.format("天才是由%d%%的灵感，%d%%的汗水 。", 1, 99)
	}
}

标识	说明
‘-’	在最小宽度内左对齐，不可以与‘0’填充标识同时使用
‘#’	用于8进制和16进制格式，在8进制前加一个0,在16进制前加一个0x
‘+’	显示数字的正负号
‘’	在正数前加空格，在负数前加负号
‘0’	在不够最小位数的结果前用0填充
‘,’	只适用用10进制，每三位数字用‘,’分隔
‘(’	用括号把负数括起来

public class StringFormat2 {//创建类
	public static void main(String[] args) {//主方法
		String str1 = String.format("%5d", 123);// 让字符串输出的最大长度为5，不足长度在前端补空格
		System.out.println("输出长度为5的字符串|" + str1 + "|");//输出"输出长度为5的字符串|" + str1 + "|"
		String str2 = String.format("%-5d", 123);// 让字符串左对齐
		System.out.println("左对齐|" + str2 + "|");//输出"左对齐|" + str2 + "|"
		String str3 = String.format("%#o", 33);// 在8进制前加一个0
		System.out.println("33的8进制结果是：" + str3);//输出"33的8进制结果是：" + str3
		String str4 = String.format("%#x", 33);// 在16进前加一个0x
		System.out.println("33的16进制结果是：" + str4);//输出"33的16进制结果是：" + str4
		String str5 = String.format("%+d", 1);// 显示数字正负号
		System.out.println("我是正数：" + str5);//输出"我是正数：" + str5
		String str6 = String.format("%+d", -1);// 显示数字正负号
		System.out.println("我是负数：" + str6);//输出"我是负数：" + str6
		String str7 = String.format("% d", 1);// 在正数前补一个空格
		System.out.println("我是正数，前面有空格" + str7);//输出"我是正数，前面有空格" + str7
		String str8 = String.format("% d", -1);// 在负数前补一个负号
		System.out.println("我是负数，前面有负号" + str8);//输出"我是负数，前面有负号" + str8
		String str9 = String.format("%05d", 12);// 让字符串输出的最大长度为5，不足长度在前端补0
		System.out.println("前面不够的数用0填充：" + str9);//输出"前面不够的数用0填充：" + str9
		String str10 = String.format("%,d", 123456789);// 用逗号分隔数字
		System.out.println("用逗号分隔：" + str10);//输出"用逗号分隔：" + str10
		String str11 = String.format("%(d", 13);// 正数无影响
		System.out.println("我是正数，我没有括号：" + str11);//输出"我是正数，我没有括号：" + str11
		String str12 = String.format("%(d", -13);// 让负数用括号括起来
		System.out.println("我是负数，我有括号的：" + str12);//输出"我是负数，我有括号的：" + str12
	}
}

5.5 可变字符串

       StringBuffer是线程安全的可变字符序列，一个类似于 String的字符串缓冲区。前面内容介绍过String创建的字符串对象是不可修改的，这一节介绍的SuigBufter类创造的字字符串序列是可修改的且实体容量会随着存放的字符串增加而自动增加。StringBulder 与StringBuffer有完全相同的API.只是为了提高效率而放弃了线程安全控制。

5.5.1 StringBuffer类的常用方法

 1.创建StringBuffer类

StringBuffer sbf = new StringBuffer() ；//创建一个对象，无初始值

StringBuffer sbf = new StringBuffer ("abc") ；//创建一个对象，初始值为“abc"

StringBuffer sbf = new StringBuffer(32)； //创建一个对象， 初始容量为32个字符

 2. append()方法

sbf.append (obj);

sbf：任意StingBuffer 对象。

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

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

sbf . setCharAt (index, ch) ;

sbf:任意StringBuffer对象

index:被替换字符的索引

ch:替换后的字符

public class StringBufferSetCharAt {//创建类
	public static void main(String[] args) {//主方法
		StringBuffer sbf = new StringBuffer("0123456");//创建新的字符串
		System.out.println("sbf的原值是：" + sbf);//输出sbf的原值
		sbf.setCharAt(3, 'A'); 						// 将索引为3的字符改成'A'
		System.out.println("修改后的值是：" + sbf);//输出sbf修复后的值
	}
}

 4. iner(int offet, String str）放法

sbf. insert (offset,str) ;

sbf: 任意 StringBuffer 对象

offset:插入的索引

str:插入的字符串

public class StringBufferInsert {//创建类
	public static void main(String[] args) {//主方法
		StringBuffer sbf = new StringBuffer("0123456");//创建新的字符串
		System.out.println("sbf的原值为："+sbf);//输出sbf的原值
		sbf = sbf.insert(5, "F");	//在索引为5的位置插入"F"，将返回值赋给sbf自己
		System.out.println("修改之后的值为："+sbf);//输出sbf修复后的值
	}
}

 

5. reverse()方法

 sbf. reverse( ) ;

sbf：表示任意StringBuffer对象。

public class StringBufferReverse {//创建类
	public static void main(String[] args) {//主方法
		StringBuffer sbf = new StringBuffer("同一个世界，同一个梦想");//定义新的值
		System.out.println("sbf的原值为：" + 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 class StringBufferDelete {//创建类
	public static void main(String[] args) {//主方法
		StringBuffer sbf = new StringBuffer("天行健，君子以自强不息"); //定义新的字符串
		System.out.println("sbf的原值为："+sbf);//输出sbf的原值
		sbf = sbf.delete(4, 7);	//删除从索引4开始至索引7之前的内容
		System.out.println("删除之后的值为："+sbf);//输出删除后的值
	}
}

 7.其他方法

除了这几个常用方法以外，StringBuffer 还有类似String类的方法。

public class StrignBufferTest {//创建类
	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);//输出sbf的原值
		System.out.println("sbf的长度为：" + lenght); //输出sbf的长度
		System.out.println("索引为5的字符为：" + chr); //输出索引为5的字符
		System.out.println("DEF字符串的索引位置为：" + index);//输出索引位置
		System.out.println("索引0开始至索引2之间的字符串：" + substr);//输出索引0到2之间的字符串
		System.out.println("替换后的字符串为：" + tmp);//输出替换后的字符串
	}
}

5.5.2 StringBuilder类的使用方法

StringBuilder类与StringBuffer类具有兼容的API,所以两者的使用方法也相同。

public class StringBuilderTest {//创建类
	public static void main(String[] args) {//主方法
		StringBuilder sbd = new StringBuilder();//定义新的值
		System.out.println("sbd的原值为空"); //输出sbd的原值
		sbd.append("我是StringBuilder类");//输出信息
		System.out.println("sbd追加字符串：" + sbd);//输出字符串sbd
		int length = sbd.length();//定义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); //输出反序的值
	}
}

5.5.3 StringBuffer、StringBuilder、String之间的关系

 1. StringBuffer、 StringBuilder、 String 互相转换

  StringBuffer类和StringBuilder 类都有toStringO方法，可以返回字符序列的字符串表示形式。这两个类在初始化的时候，可以通过字符串作为参数，指定初始化的字符序列内容。

public class StringInterchange {//创建类
	public static void main(String[] args) {//主方法
		String str = "String";// String转换成StringBuffer
		StringBuffer sbf = new StringBuffer(str);// String转换成StringBuilder
		StringBuilder sbd = new StringBuilder(str);// StringBuffer转换成String
		str = sbf.toString();// StringBuilder转换成String
		str = sbd.toString();// StringBuffer转换成StringBuilder
		StringBuilder bufferToBuilder = new StringBuilder(sbf.toString());// StringBuilder转换成StringBuffer
		StringBuffer builderToBuffer = new StringBuffer(sbd.toString());// StringBuilder转换成StringBuffer
	}
}

 2. StringBuffer、 StringBuilder、 String 的不同之处

      String只能赋值一次， 每二次内容发生改变都生成了一个新的对象，然后原有的对象引用新的象，所以说String本身是不可改变。每一次改变String的字符串内容，都会在内存创建新的对象，每一次生成新对象都会对系统性能产生影响。

     StringBuffer和StringBuilder不同，每次操作都是对自身对象做操作，而不是生成新的对象。           SrigBufer和SrngBider也存在不同之处。StringBuffer 的方法都使用"synchronized"关键字进行修饰，这样保证了同时最多只有一个线程可以运行这些方法，也就是保证了线程安全。StringBuilder则不具备这样的特点。反过来说，正因为StringBuilder 没有线程安全机制，运行起来就不用考虑给线程加锁，所以运行效率会比StringBuffer 要高。

public class Jerque { // 新建类
	public static void main(String[] args) { // 主方法
		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); // 将操作时间输出
	}
}

类名	String	StringBuilder	StringBuffer
对象类型	字符串常量	字符串常量	字符串常量
线性安全性	不安全	不安全	安全
执行效率（大部分情况下）	低	高	中

根据上内容，还可以总结这些类的适用场景:                                                                                  (1)操作少、数据少，用 String。                                                                                                     (2)单线程，操作多，数据多，用 StringBuilder。                                                                          (3)多线程，操作多，数据多，用 StringBuffer。