java第五章总结（字符串的应用）

最新推荐文章于 2022-04-07 22:49:27 发布

遇見即是上上籤

最新推荐文章于 2022-04-07 22:49:27 发布

阅读量1.5k

点赞数

文章标签： java

本文链接：https://blog.csdn.net/weixin_66935612/article/details/123630286

版权

5.5.1StringBuffer类的常用方法

5.5.2StringBuilder类的使用方法

5.5.3StringBuffer StringBuilder String之间的关系

5.6小结

5.1 String类

例题5.1

5.1.1 声明字符串

字符串是常量，它们可以显示任何文字信息，字符串的值在创建之后不能更改。在Java语言中，
单引号中的内容表示字符，例如's'，而双引号中的内容则表示字符串，例如:
"我是字符串”，"123456789"， "上下左右东西南北”
Java通过java.lang.String这个类来创建可以保存字符串的变量，所以字符串变量是一个对象。
声明一个字符串变量a,以及声明两个字符串变量a、b。代码如下:
String a;
String a,b;
注意:
在不给字符串变量赋值的情况下，默认值为nul,就是空对象，如果此时调用Stirg的方法会发生空指针异常。

5.1.2 创建字符串

1.引用字符串常量
例如，直接将字符串常量赋值给String类型变量。代码如F:
String a = "时间就是金钱，我的朋友。";
String b = "锄禾日当午”，C = "小鸡炖蘑菇";
String strl,str2;
strl = "We are students";
srt2 = "We are students";
当两个字符串对象引用相同的常量时，就具有相同的实体，
内存示意
strl We are students
str2 We are studentsI两个字符串对象引用相同的常量
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.提取字符数组中的一部分创建字符串对象
例如，定义一个字符数组charAay,从该字符数组索引3的位置开始，提取两个元素，创建一
字符串。代码如下:
char[] charArray = {时'，间'，'就'，是'，'金'，'钱，};
String a = new String (charArray, 3, 2);

例题5.1编写一段代码，声明多个字符串变量，用不同的赋值方法对这些字符串变量赋值并输出

package five.one;

public class five {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String a="时间就是金钱，我的朋友。";//直接引用字符串常量
		System.out.println("a="+a);
		String b=new String ("我爱清汤小肥羊");//利用构造方法实例化
		String c=new String (b);//使用已有字符串变量实例化
		System.out.println("b="+b);
		System.out.println("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);
		

	}

}

5.2 连接字符串

对于尺字明的字花中。可以对其进行相应的接作。连桂宇行中就足字有按作中教简单站积
可以对多个字符串进行连接，也可使字符事与其他数据受型进行建我。

5.2.1连接字符串

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

例题5.2 使用+和+=拼接字符串

package five.one;

public class two {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String a="abc";
		String b="123";
		String c=a+b+"!";//使用“+”拼接字符串
		String d="拼接字符串";
		d+=c;//使用“+=”拼接字符串
		System.out.println("a="+a);//输出
		System.out.println("b="+b);
		System.out.println("c="+c);
		System.out.println("d="+d);

	}

}

5.2.2 连接其他数据类型

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

例题5.3在项目中将字符串与整型，浮点型变量相连结果输出

package five.one;

public class three {

	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 提取字符串信息

字符串作为对象，可以通过相应的方法获取字符串的有效信息，如获取某字符串的长度，某个索引位置的字符等，

5.3.1 获取字符串长度

length()方法采用UTF-16的编码表示字符的数量，也就是char的数量，语法如下：

str.leng()

例如，定义一个字符串num,使用lnghO方法获取其长度。代码如下:
String num ="12345 67890";
int size = num. length() ;
将size输出，得出的结果就是:
11
这个结果是将字符串num的长度赋值给int型变量size,此时变量size的值为11,这表示
; lengh()方法返回的字符串长度包括字符串中的空格。
注意:
字符串的length0方法与数组的length虽然都是用来获取长度的，但两者却有些不同。String 的length0是类的成员方法，是有括号的;数组的length是一一个属性，是没有括号的。

5.3.2 获取指定字符

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

str.charAt(index);

str:任意字符串对象

index：char值的索引

例题5.4查看字符串索引位置是4的字符

package five.one;

public class four {

	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);

	}

}

运行结果

5.3.3 获取子字符串索引位置

String 类提供了两种查找字符事的方法，甲index010与lsndex0方法idxOf0万法返回
的是搜索的字符或学符串首次出现的位置，lstndexoOl0方法返回的是搜索的字符或字符串最后一次出现的位置。
1. indexOf(String str)
该方法用于返回参数字符串在指定字符串str中首次出现的索引位置。当调用字符串的indexOf0
方法时，会从当前字符串的开始位置搜索str的位置:如果没有检索到字符串str,该方法的返回值
是-1。
语法如下:
a, indexof (substr);
a; 任意字符串对象。
substr：要搜索的字符串。
查找字符e在字符串str中首次出现的索引位置。代码如下:
String str="We are the world";
int size =str, indexOf('e');
//size 的值为1
理解字符串的索引位置，要对字符串的下标有所了解。在计算机中String对象是用数组表示的。
字符串的下标是0~length（）-1

例题5.5判断字符串中是否含有“abc”

public class fivee {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String str="12345abcde";//创建字符串对象
		int charIndex=str.indexOf("abc");
		if(charIndex !=-1) {
			System.out.println("str中存在abc字符串");
		}else {
			System.out.println("str中不存在abc字符串");
		}

	}

}

结果

2. indexOf(String str,int fromindex)

从指定的索引fromindex开始至字符串最后，返回指定子字符串在此字符串中第一次出现的索引，如果没有检索到str，返回值依然是-1；

例题5.6查找字符串”We are the world“中”r",第一，二，三次出现的索引位置。

package five.one;

public class six {

	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);
		System.out.println("e第二次出現的索引位置是：" + secondIndex);
		System.out.println("e第三次出現的索引位置是：" + thirdIndex);
	}

	}

运行结果

a.indexOf(str,fromindex）；

a; 任意字符串对象。
fromindex：要搜索的字符串。

3.public int lastIndexOf(String sir)

a.lastIndexOf(String str)

例题5.7 查找字符串“Let it go！Let it go！”中“go”最后出现的位置

package five.one;

public class seven {

	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);
		System.out.println("\"o\"最后一次出现的位置是：" + oIndex);
		System.out.println("\"go\"最后一次出现的位置是：" + goIndex);
	}



	}

运行结果·

4. lastindexOf(String str,int fromindex)

a.lastindexOf(str,fromindex)

例题5.8查询字符串“01a3a56a89”中字母a的位置

package five.one;

public class eight {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String str = "01a3a56a89";
		// 返回字母"a"最后一次出现的索引位置
		int lastIndex = str.lastIndexOf("a");
		// 返回字母"a"的索引位置otherIndex
		// 满足0<=fiveBeforeIndex<=5条件，在满足条件的结果集中，返回最大的数字
		int fiveBeforeIndex = str.lastIndexOf("a", 5);
		// 返回字母"a"的索引位置otherIndex
		// 满足0<=threeBeforeIndex<=3条件，在满足条件的结果集中，返回最大的数字
		int threeBeforeIndex = str.lastIndexOf("a", 3);
		System.out.println("字符串\"01a3a56a89\"中：\n");
		System.out.println("字母\"a\"最后一次出现的位置是：" + lastIndex);
		System.out.println("从索引位置5开始往回搜索，字母\"a\"最后一次出现的位置：" + fiveBeforeIndex);
		System.out.println("从索引位置3开始往回搜索，字母\"a\"最后一次出现的位置：" + threeBeforeIndex);
	}
}

运行结果

5.3.4 判断字符串首尾内容

首：str.startsWith("字符串内容")

例题5.9 查看一个字符串是否以“我有一个梦想”开始（运行用utf8运行就可以了）

package five.one;

public class nine {

	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 = myDream1.startsWith("我有一个梦想");
		// 判断后半句是否以"我有一个梦想"为前缀
		boolean secondBool = myDream2.startsWith("我有一个梦想");
		// 判断前半句的逻辑结果
		if (firstBool) {
			System.out.println("前半句是以\"我有一个梦想\"开始的。");
			// 判断后半句的逻辑结果
		} else if (secondBool) {
			System.out.println("后半句是以\"我有一个梦想\"开始的。");
			// 如果没有符合条件的字符串
		} else {
			System.out.println("没有以\"我有一个梦想\"开始的。");
		}
	}
}

运行结果

例题5.10 查询五言绝句《静夜思》第二行是否“举”字开头

package five.one;

public class ten {

	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");
		// 返回从换行符之后开始的子字符串前缀是否为”举“。
		// 换行符在字符串中只占一个字符，所以enterIndex + 1
		boolean flag = str.startsWith("举", enterIndex + 1);
		if (flag) {
			// 如果结果为真，则输出此句
			System.out.println("第二行是以\"举\"开始的");
		} else {
			// 如果结果为假，则输出第二行开头第一个字符
			System.out.println("第二行是以\"" + str.charAt(enterIndex + 1) + "\"开始的");
		}
	}
}

运行结果

尾：str.endsWith(".....")

例题5.11查看是否以句号结尾

package five.one;

public class oneone {

	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.3.5 获取字符数组

toCharArray()方法

如：char[] ch=str.toCharArray();

例题.5.12创建一个字符串，将此字符串转换成一个字符数组

package five.one;

public class onetwo {

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

boolean arr=str.contains("查询的内容")

例题5.13创建字符串，输出相声中的《报菜名》，然后用contains（）方法查看是否有“腊肉”和“汉堡”这两道菜

package five.one;

public class onethree {

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

String newarr=arr.substring(8)//第8位开始

String newarr=arr.substring(0，8)//截取0-8的

例题5.14 输出字符串“为革命保护视力，眼保健操开始”的最后半句话

package five.one;

public class onefour {

	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.15取字符串“闭门造车，出门合辙。”的前半句话

package five.one;

public class onefive {

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

结果

5.4.2 字符串替换

String newarr=arr.replace(旧，新)

例题5.16字符串“明月几时，有把酒问青天”中的月替换成“日”

package five.one;

public class onesix {

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

结果

String newarr=arr.replaceAll(旧，新)、、可用正则表达式

例题5.17分别用replace（）方法和replaceAll（）方法，利用正则表达式将所有数字替换成“？”

package five.one;

public class oneseven {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String str = "0123456789abc\\d";
		// 使用replace()将符合"\\d"表达式的字符串替换"?"
		String restr = str.replace("\\d", "?");
		// 使用replaceAll()将符合"\\d"表达式的字符串替换"?"
		String restrAll = str.replaceAll("\\d", "?");
		// 输出结果
		System.out.println("字符串str：" + str);
		System.out.println("使用replace()替换的结果：" + restr);
		System.out.println("使用replaceAll()替换的结果：" + restrAll);
	}
}

结果

replaceFirst（String a，String b）

例题5.18现有字符串“8I want to marry you，so I need you！”去掉第一个数字，再把第一次出现的“you”换成“her”

package five.one;

public class oneeight {

	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", "");
		// 将第一次出现的"you"替换成"her"
		String youToHer = noNumber.replaceFirst("you", "her");
		// 输出结果
		System.out.println("替换之后的结果是："+youToHer);
	}
}

结果

5.4.3 字符串的分割

注意：可用正则表达式分割

String str = "从前有座山,山里有个庙,庙里有个小松鼠";
       // 让字符串按照","进行分割
       String[] strArray = str.split(",");
       // 使用for循环，循环输出数字所有元素
       for (int i = 0; i < strArray.length; i++) {
           System.out.println("数组第" + i + "索引的元素是：" + strArray[i]);

例题5..19创建一个字符串用“，”分割

package five.one;

public class onenine {

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

例题5.20使用不同分隔符，分割同一字符串

package five.one;

public class twozero {

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

例题5.21将字符串“192.168.0.1”按照“.”拆分2次，第一次全部拆分第二次拆分2次

package five.one;

public class twoone {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		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) {
			System.out.print("[" + a + "]");
		}
		System.out.println();// 换行
		// 输出分割两次的结果
		System.out.print("分割两次的结果：");
		for (String a : secondArray) {
			System.out.print("[" + a + "]");
		}
		System.out.println();
	}
}

5.4.4大小写转换

String str = "abc DEF"; // 创建字符串
System.out.println(str.toLowerCase()); // 按照小写格式输出
System.out.println(str.toUpperCase()); // 按照大写格式输出

例题5.22将“abc DEF”分别用大小写输出

package five.one;

public class twotwo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String str = "abc DEF"; // 创建字符串
		System.out.println(str.toLowerCase()); // 按照小写格式输出
		System.out.println(str.toUpperCase()); // 按照大写格式输出
	}
}

5.4.5去除空白内容

String str = " abc ";
String b = str.trim();

5.23使用trim()方法去掉字符串空白内容

package five.one;

public class twothree {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String str = "       abc            ";
		String shortStr = str.trim();
		System.out.println("str的原值是：[" + str + "]");
		System.out.println("去掉首尾空白的值：[" + shortStr + "]");
	}
}

例题5.24利用正则表达式“\\s”将空白内容换成空字符

package five.one;

public class twofour {

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

b为去除空白之后的string

5.4.6比较字符串是否相等

第一种方法a==b法，若是在不同空间则不能判断相等如a在数组1值等于2，b在数组2等于2，此时若直接判断a==b是不成立的

String tom, jerry;
       // 直接引入字符串常量
       tom = "I am a student";
       jerry = "I am a student";
       System.out.println("直接引入字符串常量的比较结果：" + (tom == jerry));
       // 使用new创建信对象
       tom = new String("I am a student");
       jerry = new String("I am a student");
       System.out.println("使用new创建对象的比较结果：" + (tom == jerry));

例题5.25使用运算符比较两个字符串

package five.one;

public class twofive {

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

第二种方法a.equals（b），这个就是判断值，在不同空间也可以，此时a=b就成立了

如 System.out.println("使用new创建对象的比较结果：“+tom.equals(jerry));、

例题5.26创建String变量分别用“==”和equals()方法比较

package five.one;

public class twesix {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String str1 = "Hello";
		String str2 = new String("Hello");
		String str3 = new String("你好");
		String str4 = 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));
		System.out.println("str1.equals(str3) 的结果：" + str1.equals(str3));
		System.out.println("str1.equals(str4) 的结果：" + str1.equals(str4));
	}
}

例题5.27使用equals()和equalsIgnoreCase()方法判断两个字符串是否相等

package five.one;

public class twoseven {

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

5.4.7格式化字符串

1.日期格式化 Date a=new Date;

String s=String.format("%te",a);

常用的日期格式化转换符

Date date = new Date();                    //创建Date对象date
       String year = String.format("%tY", date);        //将date进行格式化
       String month = String.format("%tB", date);
       String day = String.format("%td", date);
       System.out.println("今年是：" + year + "年");    //输出信息
       System.out.println("现在是：" + month);
       System.out.println("今天是：" + day + "号");

例题5.28实现当前日期的4位年份，月份全称，二位日期形式输出

package five.one;
import java.util.Date;
public class twoeight {

	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);
		String day = String.format("%td", date);
		System.out.println("今年是：" + year + "年"); 	//输出信息
		System.out.println("现在是：" + month);
		System.out.println("今天是：" + day + "号");
	}
}

2.时间格式化跟日期格式化差不多，不过字符变了而已

例题5.29实现当前时间信息以2位小时数，2位分钟数，2位秒数形式输出

package five.one;
import java.util.Date;
public class twonine {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Date date = new Date(); // 创建Date对象date
		String hour = String.format("%tH", date); // 将date进行格式化
		String minute = String.format("%tM", date);
		String second = String.format("%tS", date);
		// 输出的信息
		System.out.println("现在是：" + hour + "时" + minute + "分" + second + "秒");
	}
}

3.格式化常见时间日期组合

例题5.30实现当前日期时间的全部信息以指定的格式输出

package five.one;
import java.util.Date;
public class threezero {

	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);
		// 将格式化后的日期时间输出
		System.out.println("全部的时间信息是：" + time);
		System.out.println("年-月-日格式：" + form);
	}
}

（2）常规类型格式化

例题5.31实现不同类型格式转换

package five.one;

public class threeone {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		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);
		// 输出哈希散列码，等同Integer.toHexString(3015);
		String str5 = String.format("%h", 3510);
		System.out.println("3510的hashCode值：" + str5);
		// 输出8进制
		String str6 = String.format("%o", 33);
		System.out.println("33的8进制结果是：" + str6);
		// 输出16进制
		String str7 = String.format("%x", 33);
		System.out.println("33的16进制结果是：" + str7);
		// 输出科学计数法
		String str8 = String.format("%e", 120000.1);
		System.out.println("120000.1用科学计数法表示：" + str8);
		// 输出带有效位数和指数的16进制浮点值
		String str9 = String.format("%a", 40.0);
		System.out.println("40.0的十六进制浮点值：" + str9);
		// 输出百分号和数字
		System.out.println(String.format("天才是由%d%%的灵感，%d%%的汗水 。", 1, 99));
	}
}

例题5.32使用标识输出控制字符串

package five.one;

public class threetwo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String str1 = String.format("%5d", 123);
		System.out.println("输出长度为5的字符串|" + str1 + "|");
		// 让字符串左对齐
		String str2 = String.format("%-5d", 123);
		System.out.println("左对齐|" + str2 + "|");
		// 在8进制前加一个0
		String str3 = String.format("%#o", 33);
		System.out.println("33的8进制结果是：" + str3);
		// 在16进前加一个0x
		String str4 = String.format("%#x", 33);
		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);
		// 让字符串输出的最大长度为5，不足长度在前端补0
		String str9 = String.format("%05d", 12);
		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可变字符串

String 常量
StringBuffer 变量有synchronized(锁)
StringBuilder 变量

5.5.1StringBuffer类的常用方法

1.创建StringBuffer类，这里只能用new方法不能像String一样直接引用字符串

StringBuffer sbf=new StringBuffer();

StringBuffer sbf=new StringBuffer("abc");

StringBuffer sbf=new StringBuffer(32);

2.append()方法,追加值，每追加一次会有一个逗号

sbf.append(obj);

obj为追加值

例题5.33使用append（）追加字符序列

package five.one;

public class threethree {

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

3.setCharAt(int index,char ch)方法，给指定字符索引处修改为ch，即index是索引位置，ch为修改的值

sbf.setCharAt(index,ch);

例题5.34将索引位置为3的字符修改成A

package five.one;

public class threefour {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		StringBuffer sbf = new StringBuffer("0123456");
		System.out.println("sbf的原值是：" + sbf);
		sbf.setCharAt(3, 'A'); 						// 将索引为3的字符改成'A'
		System.out.println("修改后的值是：" + sbf);
	}
}

4.insert(int offset,String str)方法，插入字符串，即ioffset是索引位置，str是插入的值，注意是插入索引位置的前面

sbf.insert(offset,str)

例题5.35将索引位置为5插入一个"F"

package five.one;

public class threefive {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		StringBuffer sbf = new StringBuffer("0123456");
		System.out.println("sbf的原值为："+sbf);
		sbf = sbf.insert(5, "F");	//在索引为5的位置插入"F"，将返回值赋给sbf自己
		System.out.println("修改之后的值为："+sbf);
	}
}

5.reverse()方法，将字符串反向输出，

sbf.reverse();

例题5.36将字符序列反序输出，

package five.one;

public class threesix {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		StringBuffer sbf = new StringBuffer("同一个世界，同一个梦想");
		System.out.println("sbf的原值为：" + sbf);
		sbf = sbf.reverse();// 将字符序列sbf反转
		System.out.println("修改之后的值为：" + sbf);
	}
}

6.delete(int start,int end)方法，删除字符串的字符，从指定索引位置start开始到end-1位置为删除的部分如果start=end将不会删除任何东西

sbf.delete(start.end);

例题5.37删除索引位置从4到7之前的内容

package five.one;

public class threeseven {

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

7.其他方法

例题5.38

package five.one;

public class threeeight {

	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);
		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);
	}
}

5.5.2StringBuilder类的使用方法

例题5.39 对字符串对象做追加，插入，删除，反序输出

package five.one;

public class threenine {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		StringBuilder sbd = new StringBuilder();
		System.out.println("sbd的原值为空");
		sbd.append("我是StringBuilder类");
		System.out.println("sbd追加字符串：" + sbd);
		int length = sbd.length();
		System.out.println("sbd的长度为：" + length);
		sbd = sbd.insert(length - 1, "123456");
		System.out.println("插入字符串：" + sbd);
		sbd = sbd.delete(sbd.length() - 1, sbd.length());
		System.out.println("删除最后一个字：" + sbd);
		sbd = sbd.reverse();
		System.out.println("反序输出：" + sbd);
	}
}

5.5.3StringBuffer StringBuilder String之间的关系

String 字符串常量
　　StringBuffer 字符串变量（线程安全）
　　StringBuilder 字符串变量（非线程安全）

　　简要的说，String 类型和 StringBuffer 类型的主要性能区别其实在于 String 是不可变的对象, 因此在每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象，然后将指针指向新的 String 对象，所以经常改变内容的字符串最好不要用 String ，因为每次生成对象都会对系统性能产生影响，特别当内存中无引用对象多了以后，JVM 的 GC 就会开始工作，那速度是一定会相当慢的。
　　而如果是使用 StringBuffer 类则结果就不一样了，每次结果都会对 StringBuffer 对象本身进行操作，而不是生成新的对象，再改变对象引用。所以在一般情况下我们推荐使用 StringBuffer ，特别是字符串对象经常改变的情况下。而在某些特别情况下， String 对象的字符串拼接其实是被 JVM 解释成了 StringBuffer 对象的拼接，所以这些时候 String 对象的速度并不会比 StringBuffer 对象慢，而特别是以下的字符串对象生成中， String 效率是远要比 StringBuffer 快的：
　　String S1 = “This is only a” + “ simple” + “ test”;
　　StringBuffer Sb = new StringBuilder(“This is only a”).append(“ simple”).append(“ test”);
　　你会很惊讶的发现，生成 String S1 对象的速度简直太快了，而这个时候 StringBuffer 居然速度上根本一点都不占优势。其实这是 JVM 的一个把戏，在 JVM 眼里，这个
　　String S1 = “This is only a” + “ simple” + “test”; 其实就是：
　　String S1 = “This is only a simple test”; 所以当然不需要太多的时间了。但大家这里要注意的是，如果你的字符串是来自另外的 String 对象的话，速度就没那么快了，譬如：
　　String S2 = “This is only a”;
　　String S3 = “ simple”;
　　String S4 = “ test”;
　　String S1 = S2 +S3 + S4;
　　这时候 JVM 会规规矩矩的按照原来的方式去做

　　在大部分情况下 StringBuffer > String
　　StringBuffer
　　Java.lang.StringBuffer线程安全的可变字符序列。一个类似于 String 的字符串缓冲区，但不能修改。虽然在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。
　　可将字符串缓冲区安全地用于多个线程。可以在必要时对这些方法进行同步，因此任意特定实例上的所有操作就好像是以串行顺序发生的，该顺序与所涉及的每个线程进行的方法调用顺序一致。
　　StringBuffer 上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数据。每个方法都能有效地将给定的数据转换成字符串，然后将该字符串的字符追加或插入到字符串缓冲区中。append 方法始终将这些字符添加到缓冲区的末端；而 insert 方法则在指定的点添加字符。
　　例如，如果 z 引用一个当前内容是“start”的字符串缓冲区对象，则此方法调用 z.append("le") 会使字符串缓冲区包含“startle”，而 z.insert(4, "le") 将更改字符串缓冲区，使之包含“starlet”。

　　在大部分情况下 StringBuilder > StringBuffer
　　java.lang.StringBuilde
　　java.lang.StringBuilder一个可变的字符序列是5.0新增的。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。两者的方法基本相同。

例题5.40StringBuffer StringBuilder String之间互相转换，只是描述转换，没有运行结果的

package five.one;

public class fourzero {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		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());
	}
}

例题5.41验证字符串生成效率

package five.one;

public class fourone {

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

5.6小结

因为在日常开发工作中,处理字符串的代码在程序中占据很大比例,所以对理解、学习和操作特序列打下基础,可谓是学习编程的重中之重、本章学习了很多字符串操作:如何获取字符串的内容和长度:如阿查找某个位置的字符内容:还有如何将字符串改成读者想要的内容。针对不同的需求,还要懂特如何将已有的字符串用最简洁的方式变成我们需要的结果。
另外,从找堆的角度，描述了字符串是如何在内存中操作的，这使读者可以更好地了解不同类在不同场景下的优势与劣势,今后不管是开发小程序,还是大型项目,都能够找到合适的解决方案,让编写的膛字更加健壮、稳定。

遇見即是上上籤

关注

0
点赞
踩
5

收藏

觉得还不错? 一键收藏
打赏
0
评论
java第五章总结（字符串的应用）

5.1 String类例题5.15.1.1 声明字符串5.1.2 创建字符串5.2 连接字符串5.2.1连接字符串例题5.25.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 字符串替换..
复制链接

扫一扫