第十章字符串学习总结

最新推荐文章于 2024-05-15 00:15:13 发布

java。。

最新推荐文章于 2024-05-15 00:15:13 发布

阅读量250

点赞数 1

文章标签：学习 java jvm

本文链接：https://blog.csdn.net/weixin_74767865/article/details/130506803

版权

字符串

概述：字符串是Java程序中经常处理的对象，如果字符串运用得不好，将影响到程序的运行效率。在Java中，字符串作为String类的实例来处理。以对象的方式处理字符串，将使字符串更加灵活、方便。了解字符串上可用的操作，可以节省程序编写与维护的时间。

注意：在字符串中，空格占用一个索引位置。

注意：只要“+”运算符的一个操作数是字符串，编译器就会将另一个操作数转换成字符串形式。

注意：在Java中由双引号（"")包围的都是字符串，不能作为其他数据类型来使用，如"1+2"的输出结果不可能是3

10.1String类

单个字符可以用char类型保存，多个字符组成的文本就需要保存在String对象中。String通常被称为字符串，一个String对象最多可以保存（2^32-1）个字节（占用内存4GB空间大小）的文本内容。

10.1.1声明字符串

在Java语言中，字符串必须包含在一对双引号("")之内。例如：

"23.23"、"ABCDE"、"你好"

以上这些都是字符串常量，字符串常量可以是系统能够显示的任何文字信息，甚至可以是单个字符。

可以通过以下语法格式来声明字符串变量：

String str;

String:指定该变量为字符串类型。

str:任意有效的标识符，表示字符串变量的名称。

10.1.2创建字符串

在Java语言中，将字符串作为对象来处理，因此可以像创建其它类对象一样来创建字符串对象。创建对象要使用类的构造方法。String类的常用构造方法如下。

1.String（char a[])

该方法用一个字符数组a创建String对象，代码如下：

char a[]={'g','o','o','d'};
String s=new String(a);

等价于

String s=new String("good")

底层实现就是new String()对象。

2.String(char a[],int offset,int length)

该方法提取字符数组a中的一部分创建一个字符串对象。参数offset表示开始截取字符串的位置，length表示截取字符串的长度。代码如下：

char a[]={'s','t','u','d','e','n','t'};
String s=new String(a,2,4);

等价于

String s=new String("uden");

3.String(char[]value)

该构造方法可分配一个新的String类对象，使其表示字符数组参数中所有元素连接的结果。代码如下：

char a[]={'s','t','u','d','e','n','t'};
String s=new String(a);

等价于

String s=new String("student");

除通过以上几种使用String类的构造方法来创建字符串变量外，还可以通过字符串常量的引用赋值给一个字符串变量来创建字符串。代码如下：

String str1,str2;
str1="We are students"
str1="We are students"

此时，str1和str2引用相同的字符串常量，因此具有相同的实体

课堂Test1代码：

package ten;
public class Test1 {
	public static void main(String[] args) {
	//10.1String类
	//声明变量a
	String a;
	a="Hello";//底层实现为调用new String()方法
	System.out.println(a);
	//new String("内容"）
	String c;
	c=new String("world");
	System.out.println(c);
	//new String char类型数组
	//字符串初始化 传入char类型数组
	char[]ch1= {'a','b','c','d'};
	String b;
	b=new String(ch1);
	System.out.println(b);
	//new String (char类型数组 前索引，截取的长度）
	//字符串初始化 传入char类型数组 ，前索引，截取长度
	char[] ch2= {'a','b','c','b','e','f','g','h'};
	String d=new String(ch2,2,4);
	System.out.println(d);
	char[] ch3= {'大','家','好','，','我','是','练','习','坤','拳','时','长','两','年','半','的','练','习','生','水','牛','丁','国','俊','唱','跳','r','a','p','样','样','精','通'};
	String f1=new String(ch3,0,33);
	System.out.println(f1);
	//字符串的连接
	System.out.println(a+""+c);
	//字符串和整型的连接
	int p=2333;
	System.out.println(a+(p+1));
	}
}

课堂代码截图：

10.2连接字符串

使用“+”运算符可实现多个字符串的功能。“+”运算符可以连接多个String对象并产生一个新的String对象。

10.2.1连接多个字符串

【例10.1】连接一副对联的上、下，在分行输出在控制台上

在项目中创建Join类，在主方法中创建两个String型变量，他们的值分别是“春色绿千里”和“马蹄像万家”。使用“+”运算符连接两个String型变量和“\n”，在控制台上输出连接后的字符串。实例代码如下：

package ten;

public class Join {

	public static void main(String[] args) {
		String s1=new String("春色绿千里");//声明String对象s1
		String s2=new String("马蹄香万家");//声明String对象s2
		String s=s1+"\n"+s2;//将对象s1、"\n"和对象s2连接并将结果赋值给s
		System.out.println(s);//将s输出
	}

}

代码及输出结果如图：

10.2.2连接其他数据类型

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

【例10.2】统计每天阅读和上机的时间

在项目中传创建Link类，在主方法中创建数值型变量，实现将字符串与整型、浮点型变量相连的结果输出。实例代码如下：

package ten;

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相连后的结果输出。在这里booktime和practice都不是字符串，当它们与字符串相连时会自动调用toString()方法并转换为字符串形式，然后参与字符串连接。

如果将10.2例题中的输出语句修改为：

System.out.println("我每天花费"+booktime+"小时看书"+(practice+booktime)+"小时上机练习");

修改后运行结果如图：

10.3获取字符串信息

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

10.3.1获取字符串长度

使用String类的length()方法可获取声明的字符串对象的长度。语法如下：

str.length();

str为字符串对象

获取字符串长度，代码如下：

String str ="We are student";
int size =str.length();

上段代码是将字符串str的长度赋值给int型变量size，此时变量size此时变量size的值为15，这表示length()方法返回的字符串的长度（包括字符串中的空格）。

10.3.2字符串查找

String类提供了两种查找字符串的方法，即indexOf()与lastIndexOf()方法。这两种方法都允许在字符串中搜索指定条件的字符或字符串。indexOf()方法返回的时搜索的字符或字符串首次出现在的位置，lastIndexOf()方法返回的是搜索的字符或字符串最后一次出现的位置。

1.indexOf(String s)

该方法用于返回修改参数字符串s在指定字符串中首次出现的索引位置。当调用String类的indexOf()方法时，会从当前字符串的开始位置搜索s的位置，如果没有检索到字符串s，该方法的返回值是-1。语法如下：

str.indexOf(suber)

str:任意字符串对象。

suber:要搜索的字符串。

查找字符a在字符串str中的索引位置，代码如下：

String str="We are student";
int size=str.inderOf("a");//变量size的值是3

理解字符串的索引位置，要对字符串的下标有所了解。在Java语言中，String对象是用数组表示的。字符串的下标是0~length()-1。因此，字符串“We are students”的下标如图

W	e		a	r	e		s	t	u	d	e	n	t	d
0	1	2	3	4	5	6	7	8	9	10	11	12	13	14

2.lastIndexOf(String str)

该方法用于返回指定字符串最后一次出现的索引位置。当调用String类的lastIdexOf()方法时，会从当前字符串的开始位置检索参数字符串str，并将最后一次出现str的索引位置返回。如果没有检索到字符串str，该方法返回-1.语法如下：

str.lastIndexOf(substr);

str:任意字符串对象。

substr:要搜索的字符串。

说明：如果lastIndexOf()方法中的参数是空字符串""（无空格），则返回的结果与调用length()方法的返回结果相同。

【例10.3】用两种方式判断字符串的长度

在项目中创建Test类，在主方法中创建String对象，先使用lastIndexOf()方法查看字符串str中空字符串的位置，再输出这个字符串的长度，查看这两结果是否相同。示例代码如下：

package ten;
public class Test {
	public static void main(String[] args) {
		String str="We are students";
		int size=str.lastIndexOf("");
		System.out.println("空字符串在字符串str中的索引位置是："+size);
		System.out.println("字符串str的长度是"+str.length());
	}
}

代码及输出截图如下：

10.3.3获取指定索引位置的字符

使用charAt()方法可将指定索引处的字符返回。语法如下：

str.charAt(int index)

str:任意字符串

index:整型值，用于指定要返回字符的下标

【例10.4】查看指定索引位置的字符

在项目中创建Ref类，在主方法中创建String对象，使用charAr()方法查看字符串str中索引位置时6的字符。实例代码如下：

package ten;

public class Ref {

	public static void main(String[] args) {
		String str="hello world";
		char mychar=str.charAt(6);//将字符串str中索引位置是
		System.out.println("字符串str中索引位置是6的字符为："+mychar);//输出信息
	}

}

截图如下：

课堂代码如下：

package ten;

public class Test2 {

	public static void main(String[] args) {
		//10.3获取字符串信息
		//获取字符串的长度
		String str="helloworld";
		int length=str.length();
		System.out.println(length);
		//查找字符串第一次出现该元素的位置
		int size=str.indexOf("o");
		System.out.println(size);
		//查找字符串最后一次出现该元素的位置
		int size1=str.lastIndexOf("o");
		System.out.println(size1);
		//获取指定索引号的字符
		char mychar=str.charAt(0);
		System.out.println(mychar);
		//
	}

}

代码输出截图如下：

10.4字符串操作

String类中包含了很多方法，允许程序员对字符串进行操作来满足实际编程中的需要。下面时几种常见的字符串操作。

10.4.1获取子字符串

通过String类的substring()方法可对字符串进行截取。substring()方法被两种不同的重载形式，来满足不同的需要。这些形式的共同点就是都利用字符串的下取进行截取，且应明确字符串下标是从0开始的

1.substring(int beginIndex)

该方法返回的是从指定的索引位置开始截取直到该字符串结尾的子串。语法如下：

str.substring(int beginIndex)

其中，beginIndex指定从某一索引处开始截取字符串。截取字符串，代码如下：

String str="Hello World"//定义字符串str
String substr=str.substring(3);//获取字符串，此时substr值为lo World

2.substring(int beginIndex,int endIndex)

该方法返回的是从字符串某一索引位置开始截取至某一索引位置结束的子串。语法如下：

substring(int beginIndex,int endIndex)

beginIndex:开始截取子字符串的索引位置

endIndex:子字符串在整个字符串中的结束位置。

【例10.5】《将进酒》的作者是哪位诗人？

在项目中创建Subs类，在主方法中创建String对象，实现使用substring（）方法对字符串进行截取，并将截取后形成的新串输出。实例代码如下：

package ten;

public class Subs {

	public static void main(String[] args) {//主方法
		String str="《将进酒》：李白（唐）";//定义的字符串
		String substr=str.substring(6,8);//对字符串进行截取
		System.out.println("《将进酒》的作者是"+substr);//输出截取后的字符串
	}
}

代码截图如下：

10.4.2去除空格

trim()方法返回字符串的副本，忽略前导空格和尾部空格。语法如下：

str.trim();

其中，str为任意字符串对象

【例10.6】去掉自负首、尾的空格

package ten;

public class Blak {

	public static void main(String[] args) {
		
		String str="   Java  Class  ";//定义字符串str
		System.out.println(str+"的长度"+str.length());//将str原来的长度输出
		//将str去掉前导和尾部的空格后的长度输出
		System.out.println("去掉空格后的长度为"+str.trim().length());
	}
}

代码截图如下：

10.4.3字符串替换

replace()方法可实现将指定的字符或字符串替换成新的字符或字符串。语法如下：

str.replace(CharSequence target,ChatSequence replacement)

target:要替换的字符或字符串。

replacement:用于替换原来字符串的内容

replace（）方法返回的结果是一个新的字符串。如果字符或字符串oldChar没有出现在该对象表达式中的字符串序列中，则将则字符串返回。

【例10.7】将单词中的字母a替换为字母A

在项目中创建NEWStr类，在主方法中创建String型变量，将改变量中的字母a替换成A，，并将替换后的字符串输出。实例代码如下：

package ten;

public class NewStr {//创建类

	public static void main(String[] args) {//主方法
		String str="address";//定义字符串str
		String newstr=str.replace("a","A");//将str中"a"替换成"A"并返回新字符串new str
		System.out.println(newstr);//将字符串newstr输出
	}

}

运行结果如图：

说明：要替换的字符重复多次出现会全部替换，大小写要保持一致

10.4.4判断字符串的开始与结尾

startsWith()方法与endsWith()方法分别用于判断字符串是否以指定内容开始或结束。这两个方法的返回值都为boolean类型。

1.startsWith()方法

该方法用于判断当前字符串对象的前缀是否为参数指定的字符串。语法如下：

str.startWith(String prefix)

其中，prefix是指作为前缀的字符串。

2.endWith()方法

该方法用于判断当前字符串是否为以给定的子字符串结束。语法如下：

str.sendWith(String suffix)

其中，suffix是指作为后缀的字符串。

【例10.8】判断字符串是否以指定的内容开始或结束

在项目中创建StartOrEnd类，在主方法中创建两个String型变量，它们的值分别为“22045612”和“21304578”，先判断“22045612”是否是以“22”开始的,再判断“21304578”是否是以“78”结束的。实例代码如下：

package ten;

public class StartOrEnd {

	public static void main(String[] args) {

			String num1="22045612";//定义字符串num1
			boolean startsWith=num1.startsWith("22");//判断字符串的开头
			System.out.println("字符串num1是以22开始的吗？ "+startsWith);//输出信息
			String num2="21304578";//定义字符串num2
			boolean endsWith=num2.endsWith("78");//判断字符串的结尾
			System.out.println("字符串num2是以78结束的吗？ "+endsWith);//输出信息
	}

}

截图如下：

10.4.5判断字符串是否相等

对字符串对象进行比较不能煎蛋使用比较运算符“==”，因为比较运算符比较的是两个字符串的地址是否相同。即使两个字符串的内容相同，两个对象的内存地址也是不同的，使用比较运算符仍然会返回false。使用运算符比较两个字符串，代码如下：

String tom=new String("I am student");
String jerry=new String("I am student");
boolean b=(tom==jerry);

此时，布尔型变量b的值为false，因为字符串是对象，tom、jerry是引用。因此，要比较两个字符串是否相等，应使用equals()方法和equalsIgnoreCase()方法。

1.equals()方法

如果两个字符串具有相同的字符和长度，则使用equals()方法进行比较时，返回true。否则，返回false。语法如下：

str.equals(String otherstr)

其中，str、otherstr是要比较的两个字符串对象

2.equalslgnoreCase()方法

使用equals()方法对字符串进行比较时是区分大小写的，而使用equalsIgnoreCase()方法是在忽略了大小写的情况下比较两个字符串是否相等，返回结果仍未boolean类型。语法如下：

str.equalslgonreCase(String otherstr)

其中str和otherstr是要比较的两个字符串对象

【例10.9】判断“abc”与“ABC”是否相等

在项目中创建Opinion类，在主方法中创建两个String型变量，它们的值分别为“abc”和“ABC”判断这两个字符串是否相等，实例代码如下：

package ten;

public class Opinion {

	public static void main(String[] args) {
		String s1=new String("abc");//创建字符串对象1
		String s2=new String("ABC");//创建字符串对象2
		boolean b=s1.equals(s2);//使用equals()方法比较s1和s2
		boolean b2=s1.equalsIgnoreCase(s2);//使用equalsIgonreCase()方法比较s1s2
		System.out.println(s1+" equals "+s2+" :"+b);//输出信息
		System.out.println(s1+" equalsIgnoreCase "+s2+" :"+b2);

	}

}

代码截图：

10.4.6按照字典顺序比较两个字符串

compareTo()方法为字典顺序比较两个字符串，该比较基于Unicode值，按字典顺序将String对象标识的字符序列与参数字符串所表示的字符串序列进行比较。如果按字典顺序此String对象位于参数字符串之前，则比较结果为一个负整数；如果按字典顺序此String对象位于参数字符串后，则比较哦啊为一个正整数，如果这两个字符串相等，则结果为0。语法如下：

str.compareTo(String otherstr);

说明：compareTo()方法只有在equals(Object)方法返回ture时才返回0。

【例10.10】判断字母b的位置

package ten;

public class Wordbook {

	public static void main(String[] args) {
		//compare比较 compare比较到
		String str=new String("b");
		String str2=new String("a");//用于比较3个字符串
		String str3=new  String("c");
		System.out.println(str+" compareTo "+str2+":"+str.compareTo(str2));//将str与str2比较的结果输出
		System.out.println(str+" compareTo "+str3+":"+str.compareTo(str3));将str与str3比较的结果输出
	}
}

代码截图如下：

10.4.7字母大小写转换

String类的toLowerCase()方法可将字符串中的所有大写字母改写为小写字母，而与toUpperCase()方法可将字符串中的所有小写字母改写为大写字母

1.toLowerCase()方法

该方法将字符串中的所有大写字母转换为小写。如果字符串中没有应该被转换的字符，则将原字符串返回；否则将返回一个新的字符串，将原字符串中每个大写字母都转换成小写，字符串长度不变。语法如下：

str.toLowerCase()

其中，str是要进行转换的字符串

2.toUpperCase（）方法

该方法将字符串中的所有小写字母转换为大写。如果字符串中没有应该被转换的字符，则将原字符串返回；否则返回一个新字符串，将原字符串中每个小写字母都转换成大写，字符串长度不变。语法如下：

str.toLowerCase()

其中，str是要进行转换的字符串。

说明：使用toLowerCase()方法和toUpperCase()方法进行大小写转换时，数字或其他非英文字母类字母不受影响。

【例10.11】字母大小写转换

package ten;

public class UpAndLower {

	public static void main(String[] args) {
		String str=new String("Oh My God");//创建字符串str
		String newstr=str.toLowerCase();//使用toLowerCase()方法实现小写转换
		String newstr2=str.toUpperCase();//使用toUpperCase()方法实现大写转换
		System.out.println(newstr);//将转换后的结果输出
		System.out.println(newstr2);
		
	}

}

代码截图如下：

10.4.8字符串分割

使用split()方法可以使字符串按指定的分割字符或字符串进行分割，并将分割后的结果存放在字符串数组中。split()方法提供了以下两种字符串分割形式。

1.split（String sign）

该方法可根据给定的分隔符对字符串进行拆分。语法如下：

str.split(String sign)

其中，sign为分割字符串的分割符，也可以使用正则表达式。

说明：没有统一的对字符进行分割的符号。如果想定义多个分割符，可使用符号“|”。例如，“|=”表示分割符分别为“，”和“=”。

2.split（String sign,int limit）

该方法可根据给定的分割符对字符串进行拆分，并限定拆分的次数，语法如下：

str.split(String sign,int limit)

sign:分割字符串的分割符，也可以使用正则表达式

limit：限制的分割次数

【例10.12】按要求分割“192.168.0.1”

package ten;

public class Division {

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

代码截图：

课堂代码如下：

package ten;

public class Test3 {

	public static void main(String[] args) {
		//10.4字符串操作
		String str="helloworld";
		//获取子串subString(索引号）
		String substring1=str.substring(3);
		System.out.println(substring1);
		//获取子串substring(前索引号，后索引号）,前含后不含
		String substring2=str.substring(3,5);
		System.out.println(substring2);
		//去除首尾空格
		String st="    Java Class   ";
		System.out.println(st+"的长度"+st.length());
		String trim=st.trim();
		System.out.println(trim+"的长度为"+trim.length());
		//字符串的替换
		String s="address";
		String replaces=s.replace("a","A");
		System.out.println(replaces);
		String replacetrim=trim.replace(" ","");
		System.out.println(replacetrim+replacetrim.length());
		//判断字符串的开头
		String num1="22045612";
		boolean startsWith=num1.startsWith("22");
		System.out.println(startsWith);
		//判断字符串的结尾
		String num2="21304578";
		boolean endsWith=num2.endsWith("78");
		System.out.println(endsWith);
		
	}
}

代码截图：

10.5格式化字符串

String 类的静态 format（）方法用于创建格式化的字符串。format0方法有两种重载形式1.format(String format,Object...args)
该方法使用指定的格式字符串和参数返回一个格式化字符串，格式化后的新字符串使用本地默认的语言环境。语法如下:

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

format:格式字符串
args:格式字符串中由格式说明符引用的参数。如果还有格式说明符以外的参数，则忽略这些额外的参数。此参数的数目是可变的，可以为0。
2. format(Local l,String format,Object...args)
该方法使用指定的语言环境、格式字符串和参数返回一个格式化字符串，格式化后的新字用其指定的语言环境。语法如下:

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

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

forma：格式字符串。

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

10.5.1日期和时间字符串格式化

在应用程序设计中，经常需要显示日期和时间。如果想输出满意的日期和时间格式，一般需要编写大量的代码，经过各种算法才能实现。format（）方法通过给定的特殊转换符作为参数来实现对日期时间的格式化。
1.日期格式化
先来看一个例子。返回一个月中的天数，代码如下:

Date date=new Date();
String s=String.format("%te",date);

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

【例10.13】按照格式输出今天的年、月、日

package ten;

import 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进行格式化
		System.out.println(year);//输出信息
		String month=String.format("现在是%tB",date);//将date进行格式化
		System.out.println(month);//输出信息
		String day=String.format("今天是%td号",date);//将date进行格式化
		System.out.println(day);//输出信息
		//System.out.println(year+"年"+month+"月"+day+"日");//输出信息
	}

}

代码截图：

2.时间格式化

使用 format0)方法不仅可以完成日期的格式化，也可以实时间的格式化。时间的格式化转换符要比日期的格式化转-更多、更精确，它可以将时间格式化为时、分、秒、毫移等格式化时间的转换符如表 10.2 所示

【例10.14】按照格式输出当下的时、分、秒

package ten;

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);
		String second=String.format("%tS",date);
		System.out.println("现在是："+hour+"时"+minute+"分"+second+"秒");
	}

}

运行结果截图：

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

格式化日期与时间组合的转换符定义了各种日期时间组合的格式，其中最常用的如表：

转换符	说明	示例
%tF	“年-月-日”格式（4位年份）	2008-03-25
%tD	“月/日/年”格式（2位年份）	03/25/08
%tc	“时：分：秒PM(AM)”格式（12时制）	星期二三月 25 15：20：00CST 2008
%tT	“时：分：秒”格式（24时制）	15：23：50
%tr	“时：分：秒PM(AM)”格式（12时制）	03.22.06
%tR	“时：分”格式（24时制）	15：25

【例10.15】按照格式输出当下的年、月、日

package ten;

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

}

代码运行截图：

10.5.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.C00000000001p4
%n	结果为特定于平台的行分隔符
%d	结果被字面值“%”	%

【例10.16】使用转换符获取表达式的结果

package ten;

public class General {

	public static void main(String[] args) {
		String str=String.format("%d",400/2);//将结果以十进制格式显示
		System.out.println("400的一半是"+str);
		String str2=String.format("%b",3>5);//将结果以boolean型显示
		System.out.println("3>5正确吗："+str2);
		String str3=String.format("%x",200);//将结果以十六进制格式
		System.out.println("200的十六进制数是："+str3);
		
	}

}

代码截图如下：

10.6使用正则表达式

正则表达式通常被用于判断语句中，用来检查某一字符串是否满足某一格式。正则表达式是含有一些具有特殊意义字符的字符串，这些特殊字符称为正则表达式的元字符。例如，“wd”表示数字09中的任何一个，“d”就是元字符。正则表达式中的元字符及其意义如表 10.5 所示。

元字符	正则表达式中的写法	意义
.	.	任意一个字符
\d	\\d	0~9的任何一个数字
\D	\\D	任意一个非数字字符
\s	\\s	空白字符如'\t'、'\n'
\S	\\S	非空白字符
\w	\\w	可用于标识符的字符，但不包括“$”
\W	\\W	不可用于标识符的字符
\p{Lower}	\\p{Lower}	小写字母a~z
\p{Upper}	\\p{Upper}	大写字母A~Z
\p{ASCII}	\\p{ASCII}	ASCII字符
\p{Alpha}	\\p{Alpha}	字母字符
\p{Dight}	\\p{Dight}	十进制数字，即0~9
\p{Alnum}	\\p{Alnum}	数字或字母字符
\p{Punct}	\\p{Punct}	标点符号：！"#$%&'()+,-/:;<=>?@[\]^{\|}~`
\p{Graph}	\\p{Graph}	可见字符：[\p{Alnum}\p{Pinct}]
\p{Print}	\\p{Print}	可打印字符：[\p{Graph}\x20]
\p{Blank}	\\p{Blank}	空格或制表符：[\t]
\p{Cntrl}	\\p{Cntrl}	控制字符：[\x00-\x1F\x7F]

【例10.17】验证E-mail地址是否“合法”

package ten;

public class Judge {

	public static void main(String[] args) {
		String regex="\\w+@\\w+(\\.\\w{2,3})*\\.\\w{2,3}";//定义要匹配E-mail地址的正则表达式
		String str1="aaa@";//定义要进行验证的字符串
		String str2="aaaaa";
		String str3="1111@111ffyu.dfg.com";
		if(str1.matches(regex)) {//判断字符串变量是否与正则表达式匹配
			System.out.println(str1+"是一个合法的E-mail地址格式");
		}
		if(str2.matches(regex)) {
			System.out.println(str2+"是一个合法的E-mail地址格式");
		}
		if(str3.matches(regex)) {
			System.out.println(str3+"是一个合法的E-mail地址格式");
		}
		
		
	}

}

代码截图如下：

10.7字符串生成器

【例10.18】效率比拼

package ten;

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消耗时间："+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 消耗时间："+time);
	}

}

代码截图如下：

1/append()方法
该方法用于向字符串生成器中追加内容。通过该方法的多个重载形式，可实现接受任何类型的数据，如 int、boolean、char、String、double 或者另一个字符串生成器等。语法如下:

append(content)
其中，content 表示要追加到字符串生成器中的内容，可以是任何类型的数据或者其他对象。

2. insert(int offset, arg)方法
该方法用于向字符串生成器中的指定位置插入数据内容。通过该方法的不同重载形式，可实现向字符串生成器中插入 int、float、char 和 boolean 等基本数据类型的数据或其他对象。语法如下:

insert(int offset arg)

offset: 字符串生成器的位置。该参数必须大于等于 0，且小于等于此序列的长度。

arg: 将插入至字符串生成器的位置。该参数可以是任何数据类型的数据或其他对象。向字符串生成器中指定的位置添加字符，代码如下:


StringBuilder bf=newStringBuilder("hello");//创建字符生成器
bf.insert(5，"world");//添加至字符生成器的位置及内容
System.out.println(bf.toString());//此时输出信息为 helloworld
————————————————
版权声明：本文为CSDN博主「^O^」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/2302_76545499/article/details/130505749

3.delete(int start , int end)方法
移除此序列的子字符串中的字符。该子字符串从指定的 start 处开始，一直到索引 end-1处的字如果不存在这种字符，则一直到序列尾部。如果 start 等于 end，则不发生任何更改。语法如下:

delete(int start , int end)

start: 将要删除的字符串的起点位置。

end: 将要删除的字符串的终点位置。

删除指定位置的子字符串，代码如下:


StringBuilder bf=new StringBuilder("StringBuilder");//创建字符串生成器
bf.delete(5,10);//删除的子字符串
System.out.println(bf.toString());//此时输出的信息为Strinder

java。。

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
第十章字符串学习总结

indexOf()方法返回的时搜索的字符或字符串首次出现在的位置，lastIndexOf()方法返回的是搜索的字符或字符串最后一次出现的位置。当调用String类的indexOf()方法时，会从当前字符串的开始位置搜索s的位置，如果没有检索到字符串s，该方法的返回值是-1。理解字符串的索引位置，要对字符串的下标有所了解。在项目中创建Test类，在主方法中创建String对象，先使用lastIndexOf()方法查看字符串str中空字符串的位置，再输出这个字符串的长度，查看这两结果是否相同。
复制链接

扫一扫