第五章 字符串

目录

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.12

代码

结果

5.4  字符串操作

5.4.1  截取字符串

1.substring(int beginIndex) 

5.4字符串的操作

5.4.1  截取字符串

 5.4.2  字符串替换

 5.4.3  字符串分割

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 声明字符串

1,引用字符串常量
    string a= “建团一百周年”；
    string a；
    a= “建团一百周年”；
  2, 利用string 提供的构造方法
    string a = new String ("建团一百周年");
  3，利用字符数组
    char[] ch = {'建','团','一','百','周','年'}；
    string a = new String(ch);

5.1.2 创建字符串 

例5.1

代码

public class WWW1 {                             //创建类
	public static void main(String[] args) {     //主函数
		// TODO Auto-generated method stub
		String a="时间就是金钱，我的朋友。";      //直接引用字符串常量 
		System.out.println("a ="+a);          //输出a =时间就是金钱，我的朋友。
		String b=new String("我爱清汤小肥羊");   //利用构造方法实例化 
		String c=new String(b);                //使用已有字符串变量实例化 
		System.out.println("b ="+b);                //输出b =我爱清汤小肥羊
		System.out.println("c ="+c);            //输出c =我爱清汤小肥羊
		char[] charArray = { 't', 'i', 'm', 'e' };//创建新数组
		String d=new String(charArray);           //利用字符数组实例化
		System.out.println("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对象。除了“+”运算符，“+=”同样可以实现字符串拼接。

string a= “建团";
     string b= “一百周年";
                b = a+b;        //b =“建团一百周年”
    b+ = a;         //b =b+a=“建团一百周年”
使用“+”运算符可实现拼接多个字符串的功能，“+”运算符可以连接多个字”在年共产生 String对象。除了“+”运算符，“+=”同样可以实现字符串拼接。
/5.2使用“+”和“+=”拼接字符串。

代码

结果 

5.2.2  连接其他数据类型

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

5.3  提取字符串信息

字符串作为对象，可以通过相应的方法获取字符串的有效信息，如获取某字符串的长度、某个索引位置的字符等。本节将介绍几种获取字符串信息的方法。

5.3.1  获取字符串长度

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

 例5.3

提取字符串信息

长度 字符串名.length();

5.3.2  获取指定的字符
str .length() ;

String num ="12345 67890";

int size = num. length() ;

这个结果是将字符串num的长度赋值给int型变量size, 此时变量size的值为11,这表示leng()方法返回的字符串长度包括字符串中的空格。

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

str. charAt (index);

str: 任意字符串对象。

 index: char值的索引。
 

代码

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

结果

5.3.2  获取指定的字符

charAt（string index）方法将可指定索引出的字符返回。

例 5.4

代码

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

}

结果

5.3.3  获取子字符索引位置 

 例5.5

代码

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

结果

 

5.3.4  判断字符串首尾内容 

2.indexOf(String srt,int fromindex)

a：任意字符串对象

str：要搜索的子字符串

fromindex：开始搜索的索引位置

 例5.6

代码

public class StringindexOf2 {    //创建主类
	public static void main(String[] args) {   //主方法
		// TODO Auto-generated method stub
		// 创建字符串
				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出现的第一次索引位置
				System.out.println("e第二次出現的索引位置是：" + secondIndex);  //输出e出现的第二次索引位置
				System.out.println("e第三次出現的索引位置是：" + thirdIndex);   //输出e出现的第三次索引位置
			}
}

结果

 

5.3.5  获取字符数组

tocharArray（）方法可以将字符串转换为一个字符数组。

 3.pubile int lastindexOf(String srt)

a：任意字符串对象

str：要搜索的字符串

a：任意字符串

srt：要搜索的字符串

 例5.7

代码

public class StringLastindexOf {    //创建主类
	public static void main(String[] args) {   //主方法
		// TODO Auto-generated method stub
		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“最后一次出现的位置
	}
}

结果

 例5.8

5.3.6   判断子字符串是否存在 

contains（）方法可以判断字符串中是否包含指定的内容。

4.lastindexOf(String srt,int fromindex)

a：任意字符串

srt：要搜索的子字符串

fromindex：开始搜索的索引位置

代码

public class WWW8 {                     //创建类
	public static void main(String[] args) {   //主类
		String str="01a3a56a89";        //定义String 
		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\"中:");//输出字符串
		System.out.println("字母\"a\"最后一次出现的位置是:"+lastIndex);//输出a最后一次出现的位置
		System.out.println("从索引位置5开始往回搜索，字母\"a\"最后一次出现的位置:"+fiveBeforeIndex);//输出
		System.out.println("从索引位置3开始往回搜索，字母\"a\"最后一次出现的位置:"+threeBeforeIndex);//输出
	}

}

结果

例5.9

代码

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

结果 

 例5.10

代码

public class WWW10 {//创建类

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

}

结果

例5.11 

代码

public class StringendsWith {   //创建主类
	public static void main(String[] args) {    //主方法
		// TODO Auto-generated method stub
		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.4  字符串操作

5.4.1  截取字符串

str：任意字符串

String：查询子字符串

 例5.12

代码

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

结果

5.4  字符串操作

5.4.1  截取字符串

1.substring(int beginIndex) 

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

例5.13

代码

public class WWW13 {  //创建类

	public static void main(String[] args) {//主函数
		// TODO Auto-generated method stub
		String str ="今天的菜单有:蒸羊羔，蒸熊掌，蒸鹿尾。烧花鸭，烧雏鸡，烧子鹅，酱鸡，腊肉，松花小肚。";// 创建字符串
				System.out.println(str);// 输出字符串
				boolean requestl = str.contains("腊肉");// 判断字符串中是否有“腊肉” 
				System.out.println("今天有腊肉吗?"+requestl);//输出
				boolean request2 = str.contains("汉堡");//判断字符串中是否有“汉堡”的字样 
				System.out.println("今天有汉堡吗?"+request2);//输出
	}

}

结果

5.4字符串的操作

截取字符串

substring(前序号，后序号)

5.4.1  截取字符串

1.substring(int beginIndex) 

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

str. substring (beginIndex);

str:任意字符串。

 5.4.2  字符串替换

1. replace(CharSequence target, CharSequence replacement)
该方法可以实现将指定的字符序列替换成新的字符序列。CharSequence 是一个接口， 代表一个可读的字符序列，String、 StringBuffer 、StringBuilder 都实现了这个接口，所以可以直接将字符当成参数。

代码

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

结果

 5.4.3  字符串分割

1.split(String regex)

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

1. replace(CharSequence target, CharSequence replacement)

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

 str: 任意字符串。

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

newstr:替换后的字符序列。

例5.15

代码

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

}

结果

2. replaceAll(String regex, String replacement)

该方法可以实现将指定的字符串替换成新的字符串，支持正则表达式。

str. replaceAll (regex, replacement) ;

str: 任意字符串。

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

replacement:替换后的字符串。

 例5.16

代码

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

结果 

例5.17

 部分替换             String restr=str.replace

全部替换        正则表达式（数字）      String restrAll=str.replaceAll

代码

public class WWW17 {     //创建类
	public static void main(String[] args) {//主函数
		// TODO Auto-generated method stub
		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()替换的结果
		System.out.println("使用replaceA1l()替换的结果;"+ restrAll);//输出替换后的结果
	}

}

结果 

例5.18

代码

public class WWW18 {  //创建函数

	public static void main(String[] args) {//主函数
		// TODO Auto-generated method stub
		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字符串分割 

字符串.split(子串<可传正则表达式>，次数)；

1.split(String regex)

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

str：任意字符串。

regex：分隔符表达式

例5.19

代码

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

结果

例5.20

2. sit(tigi regex, int limit）

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

str，split(regex, limit)

str:任意字符串。

regex: 分隔符表达式。

limit: 限定的分割次数。

代码

public class StringSplit2 {   //创建主类
	public static void main(String[] args) {   //主方法
		// TODO Auto-generated method stub
				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) { //换行
					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) { //换行
					System.out.print("[" + b + "]");//输出b的运行结果
				}
				System.out.println();
				// 输出信息
				System.out.print("使用數字分割：");
				// 使用for-each循环展示数字分割的结果
				for (String b : a4) {  //换行
					System.out.print("[" + b + "]");//输出b的运行结果
				}
				System.out.println();
			//输出信息
				System.out.print("同時使用所有分隔符：");
				// 使用for-each循环展示所有分隔符同时分割的结果
				for (String b : a5) {   //换行
					System.out.print("[" + b + "]");//输出b的运行结果
				}
				System.out.println();  //输出信息
			}
}

结果 

例5.21

代码

public class StringSplit3 {     //创建主类
	public static void main(String[] args) {    //主方法
		// 创建字符串
		String str = "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) { //字符串用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()

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

str. toLowerCase () ;

str: 任意字符串。

2. toUpperCa 大小写转换se()

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

str. toUpperCase() ;

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

例5.22

转换成小写               toLowerCase

转换成大写               toUpperCase 

代码

结果 

*比较字符串是否相等

 a==b           位置

a.equals      值 

a.equalsIgnoreCase(b)

5.4.5  去除空白内容 

例2.23

代码

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

结果

5.4.6  比较字符串是否相等

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

例2.24

代码

public class WWW24 {//创建类

	public static void main(String[] args) {//主函数
		// TODO Auto-generated method stub
		String str="a b cd efg";//利用正则表达式，将字符串中所有的空白内容都换成"";
				String shortstr= str.replaceAll("\\s", "") ;// 创建字符串堆 
				System.out.println("str的原值是:[" + str + "]");//输出结果
				System.out.println("删除空内容之后的值是:["+ shortstr + "]");//输出结果
	}

}

结果

例2.25

代码

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

结果

5.4.7  格式化字符串

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

 例5.26

代码

public class WWW26 {//创建类
public static void main(String[] args) {//主函数
		// TODO 自动生成的方法存根
		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 的结果：" + (str1 == str2)
		System.out.println("str1 == str3 的结果：" + (str1 == str3));//输出"str1 == str3 的结果：" + (str1 == str3)
		System.out.println("str1 == str4 的结果：" + (str1 == str4));//输出"str1 == str4 的结果：" + (str1 == str4)
		System.out.println("str2 == str4 的结果：" + (str2 == str4));//输出"str2 == str4 的结果：" + (str2 == str4)
		System.out.println("str1.equals(str2) 的结果：" + str1.equals(str2));//输出"str1.equals(str2) 的结果：" + str1.equals(str2)
		System.out.println("str1.equals(str3) 的结果：" + str1.equals(str3));//输出"str1.equals(str3) 的结果：" + str1.equals(str3)
		System.out.println("str1.equals(str4) 的结果：" + str1.equals(str4));//输出"str1.equals(str4) 的结果：" + str1.equals(str4)
	}
 
}

结果 

例5.27

代码

public class WWW27 {//创建类

	public static void main(String[] args) {//主函数
		// TODO Auto-generated method stub
		String strl="abc";//创建字符串对象，内容全部小写 
		String str2="ABC";//创建字符串对象，内容全部大写
		System.out.println("区分大小写的结果:"+strl.equals(str2));//比较两个字符串的内容是否相等
		
		System.out.println("不区分大小写的结果:"+strl.equalsIgnoreCase(str2));//比较两个字符串的内容否相等，不区分大小写
	}

}

结果 

例5.28

字符串转换

（1）日期格式化

代码

import java.util.Date; 							//导入java.util.Date类
public class Eavl {       //创建主类
	public static void main(String[] args) {     //主方法
		// TODO Auto-generated method stub
		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 + "号");   //输出天的结果
	}
}

结果 

 

例5.29

代码

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 + "秒");//输出现在的时、分、秒
	}
}

结果 

例5.30

代码

import java.util.Date; //导入java.util.Date类
public class DateAndTime {     //创建主类
	public static void main(String[] args) {    //主方法
		// TODO Auto-generated method stub
		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);  //输出年—月—日格式信息
	}

}

结果  

例5.31

代码

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);//输出结果
		
		String str6 = String.format("%o", 33);// 输出8进制
		System.out.println("33的8进制结果是：" + str6);//输出结果
		
		String str7 = String.format("%x", 33);// 输出16进制
		System.out.println("33的16进制结果是：" + str7);//输出结果
		// 输出科学计数法
		String str8 = String.format("%e", 120000.1);// 输出科学计数法
		System.out.println("120000.1用科学计数法表示：" + str8);//输出结果
		
		String str9 = String.format("%a", 40.0);// 输出带有效位数和指数的16进制浮点值
		System.out.println("40.0的十六进制浮点值：" + str9);
		System.out.println(String.format("天才是由%d%%的灵感，%d%%的汗水 。", 1, 99));// 输出百分号和数字
	}
}

结果

例5.32

代码

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

}

结果

5.5  可变字符串

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

5.5.1 StringBuffer 类的常用方法
 

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

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

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

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

例5.33

StringBuffer和Stringbuilder 的使用方法：

追加 字符串名.append (需要追加的值)；

修改某个元素的值  字符串名.setCharAT(序号，值)；
1.创建StringBuffer类

创建一一个新的StringBuffer对象必须用new方法，而不能像String对象那样直接引用字符串常量。

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("门前大桥下,");// 创建StringBuffer对象
		
		sbf.append("游过一群鸭,");// 追加字符串常量
		
		StringBuffer tmp = new StringBuffer("快来快来数一数,");// 追加StringBuffer对象
		sbf.append(tmp);// 追加整型变量
		int x = 24678;//定义x值
		sbf.append(x);// 输出
		System.out.println(sbf.toString());  //换行
	}
}

结果

例5.34

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

将给定索引处的字符修改为ch。

sbf . setCharAt (index, ch) ;

sbf:任意StringBuffer对象。

index:被替换字符的索引。

ch:替换后的字符。

代码

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

结果

5.5.2 StringBuilder类的使用方法

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

例5.35

StringBuffer和Stringbuilder 的使用方法：

插入   字符串名.insert(序号，值)；

反转   字符串名.reverse();

删除   字符串名.delate(前序号，后序号)；

代码

public class StringBufferInsert {     //创建主类
	public static void main(String[] args) {     //主方法
		// TODO Auto-generated method stub
		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.5.3 StringBuffer、 StringBuilder、 String 之间的关系

StringBuffer、 StringBuilder、 String 之间的关系

1. StringBuffer、 StringBuilder、 String 互相转换

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

例5.36

代码

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);  //输出修复后的值
    }
}

结果

例5.37

代码

public class StringBufferDelete {        //创建主类
	public static void main(String[] args) {        //主方法
		// TODO Auto-generated method stub
		StringBuffer sbf = new StringBuffer("天行健，君子以自强不息");     //定义新的字符串
		System.out.println("sbf的原值为："+sbf);     //输出sbf的原值
		sbf = sbf.delete(4, 7);	//删除从索引4开始至索引7之前的内容
		System.out.println("删除之后的值为："+sbf);   //输出删除后的值
	}
}

结果

String

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

而StringBuffer和StringBuilder不同，每次操作都是对自身对象做操作，而不是生成新的对象

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

例5.38

代码

public class StringBufferTest {     //创建主类
	public static void main(String[] args) {     //主方法
		// TODO Auto-generated method stub
		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);  //输出替换后的字符串
	}
}

结果

1）操作少，数据少，用string。

（2）单线程，操作多，数据多，用stringBuilder。

（3）多线程，操作多，数据多，用stringBuffer

例5.39

代码

结果

例5.40

代码

public class StringInterchange {        //创建主类
    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 builderToBuffer = new StringBuffer(sbd.toString());// StringBuilder转换成StringBuffer
    }
}

无运行结果 

String只能赋值一次

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

    而StringBuffer和StringBuilder不同，每次操作都是对自身对象做操作，而不是生成新的对象

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

例5.41 

代码

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); // 将操作时间输出
	}
}

结果