第十章总结(字符串)
目录
一.String类
1.声明字符串
2.创建字符串
1.String(char a[])
2.String(char a[] , int offset, int length)
3.String(char[] value)
每节总结示例代码：
二.连接字符串
1.连接多个字符串
例1：先连接一副对联的上、下联，再分行输出在控制台上
2.连接其他数据类型
例2：统计每天的阅读和上机时间
每节总结示例代码：
三.获取字符串信息
1.获取字符串长度
2.字符串查找
1.inexOf(String s)
2.lastlndexOf(String str)
例3：用两种方式判断字符串的长度
3.获取指定索引位置的字符
例4：查看指定索引位置上的字符
每节总结示例代码：
四.字符串操作
1.获取子字符串
1.substring(int beginlndex)
2.substring(int beginlndex,int endlndex)
例5：《将进酒》的作者是哪位诗人？
2.去除空格
例6：去掉字符首、尾的空格
3.字符串的替换
例7：将单词中的字母a替换为字母A
4.判断字符串的开始和结尾
1.startsWith()方法
2.endsWith()方法
例8:判断字符串是否以指定的内容开始或结束
5.判断字符串是否相等
1.equals()方法
2.equalsLgnoreCase()方法
例9：判断“abc”与“ABC”是否相等
6.按字典顺序比较两个字符串
例10：判断字母b的位置
7.字母大小写转换
1.toLowerCase()方法
2.toUpperCase()方法
例11：字母大小写转换
8.字符串分割
1.split(String sign)
2.split(String sign,int limit)
例12：按要求分割“192.168.0.1”
每节总结示例代码：
五.格式化字符串
1..format(String format,Object...args)
2.format(Local l,String format,Object...args)
1.日期和时间字符串格式化
1.日期格式化
例13：按照格式输出今天的年、月、日
2.时间格式化
例14：按照格式输出当下的时、分、秒
3.格式化常见的日期时间组合
例15：按照格式输出当下的年、月、日
2.常规类型格式化
例16：使用转换符获取表达式的结果
每节总结示例代码：
六.使用正则表达式
例:17验证E-mail地址是否“合法”
七.字符串生成器
例18:效率比拼
1.append()方法
2.insert(int offset, arg)方法
3.delete(int start , int end)方法
一.String类
单个字符可以用char类型保存，多个字符组成的文本就需要保存在String对象中。String通常被称为字符串，一个String对象可以保存(2的32个次方 - 1)个字节(占用4GB空间大小)的文本内容。
1.声明字符串
在java语言中，字符串必须包含在一对双引号(“”)之内，如：
“23.23”、“ABCDE”、“你好”
以上这些都是字符串常量，字符串常量可以是系统能够显示的任何信息。甚至可以是单个字符。
可以通过以下语法格式来声明字符串变量：
String str;
String:
指定该变量为字符串类型。
str：
任何有效的标识符，表示字符串变量的名称。
声明字符串变量s，代码如下：
String s；
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”);
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(a);
除通过以上几种使用String类的构造方法来创建字符串变量外，还可创建将字符串常量的引用赋值给一个字符串变量来创建字符串。代码如下：
String str1，str2
str1 = “We are students”
str2 = “We are students”
每节总结示例代码：
public class Test1 {
public static void main(String[] args) {
//字符串变量的申请
String s;
//字符串变量初始化
// s = "你好";
s = new String("你好");
System.out.print(s);
//字符串变量初始化 传入字符类型数组
char[] ch = {'g','o','o','d'};
String st = new String(ch);
System.out.println(st);
//字符串变量初始化 传入字符串类型数组，初始索引号，个数
char[] cha = {'s','t','u','d','e','n','t'};
String str = new String(cha,2,4);
System.out.println(str);
}
}二.连接字符串
1.连接多个字符串
使用“+”运算符可实现连接多个字符串的功能。“+”运算符可以连接多个String对象并产生一个新的String对象。
例1：先连接一副对联的上、下联，再分行输出在控制台上
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输出
}
}
结果如下
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相连接后的结果输出。在这里booktime和practice都不是字符串，当它们与字符串相连时会自动调用String()方法并转换成字符串形式，然后参与字符串连接。
如果将例2中的输出语句修改为：
System.out.println("我每天花费" + booktime + "小时看书；" + (practice+booktime)+ "小时上机练习");
结果如下
为啥会这样？这是由于运算符是有优先级的，圆括号的优先级更高，所以先被执行，然后再将结果与字符串相连。
每节总结示例代码：
public class Test1 {
public static void main(String[] args) {
//字符串变量的申请
String s;
//字符串变量初始化
// s = "你好";
s = new String("你好");
System.out.print(s);
//字符串变量初始化 传入字符类型数组
char[] ch = {'g','o','o','d'};
String st = new String(ch);
System.out.println(st);
//字符串变量初始化 传入字符串类型数组，初始索引号，个数
char[] cha = {'s','t','u','d','e','n','t'};
String str = new String(cha,2,4);
System.out.println(str);
//字符串相连接
System.out.println(s + st);
//字符串和其他类型相连接
System.out.println(1.6 + str + 3);
}
}结果如下
三.获取字符串信息
字符串作为对象，可通过相应方法获取字符串的有效信息，如获取某字符串的长度、某个索引位置的字符等。
1.获取字符串长度
使用String类的length()方法可获取声明的字符串对象的长度。语法如下：
str.length();
其中，str为字符串对象。
获取字符串长度，代码如下：
String str = "We are students";
int size = str.length();
上段代码是将字符串str的长度赋值给int型变量size，此时变量size的值为15，这表示length()方法返回的字符串的长度（包括字符串中的空格）。
2.字符串查找
String类提供了两种查找字符串的方法，即indexOf()与lastindxOf()方法。这两种方法都允许在字符串中搜索指定条件的字符或字符串。indexOf()方法返回的是搜索的字符或字符串首次出现的位置，lastIndexOf()方法返回的是搜索的字符或字符串最后一次的位置。
1.inexOf(String s)
该方法用于返回参数字符串s在指定字符串中首次出现的索引位置。当调用String类的indexOf()方法时，会从当前字符串的开始位置搜索s的位置。如果没有检索到字符串s，该方法的返回值是-1。
语法如下：
str.indexOf(substr)
str:
任意字符串对象。
substr：
要搜索的字符串。
查找字符a在字符串str中的索引位置，代码如下:
String str = "We are students";
int size = str.indexOf("a");//变量size的值为3
2.lastlndexOf(String str)
该方法用于指定字符串最后一次出现的索引位置。当调用String类的lastlndexOf()方法时，会从当前字符串的开始位置检索参数字符串str，并将最后一次出现str的索引位置返回。如果没有检索到字符串str，该方法返回-1。语法如下：
str.lastlndexOf(substr)
str:
任意字符串对象。
substr：
要搜索的字符串。
例3：用两种方式判断字符串的长度
public class Text { //创造类
public static void main(String[] args) { //主方法
String str = "We are students"; //定义字符串str
int size = str.lastIndexOf(""); //将空字符串在str中的索引位置赋值给变量size
System.out.println("空字符串在字符串str中的索引位置是："+size); //将变量size输出
System.out.println("字符串str的长度是："+str.length()); //将字符串str的长度输出
}
}
结果如下：
3.获取指定索引位置的字符
使用charAt()方法可将指定索引处的字符返回。语法如下：
str.charAt(int index)
str:
任意字符串。
index:
整型值，用于指定要返回字符的下标。
例4：查看指定索引位置上的字符
public class Ref { //创造类
public static void main(String[] args) { //主方法
String str = "hello world"; //定义字符串str
char mychar = str.charAt(6); //将字符串str中索引位置6的字符返回
System.out.println("字符串str中索引位置是6的字符为："+mychar); //输出信息
}
}
结果如下：
每节总结示例代码：
public class Test2 {
public static void main(String[] args) {
//获取字符串长度
String str = new String("helloworld");
int length = str.length();
System.out.println(length);
//查找字符串里第一次出现该元素的位置str.indexOf("1")
int indexof = str.indexOf("l");
System.out.println(indexof);
//查找字符串里最后一次出现该元素的位置str.lastIndexOf("1")
int lastIndexof = str.lastIndexOf("l");
System.out.println(lastIndexof);
//获取指定索引号的字符
char charAt = str.charAt(3);
System.out.println(charAt);
}
}
结果如下：
四.字符串操作
1.获取子字符串
通过String类的substring()方法可对字符串进行截取。substring()方法被两种不同的重载形式，来满足不同的需要。这些形式的共同点就是都利用字符串的下标进行截取，且应明确字符串下标是从0开始的。
1.substring(int beginlndex)
该方法返回的是从指定的索引位置开始截取直到该字符串结尾的子串。语法如下：
str.substring(int beginlndex)
其中，beginlndex指定从某一索引处开始截取字符串。
截取字符串，代码如下：
String str = "Hello Word";
String substr = str.substring(3);
2.substring(int beginlndex,int endlndex)
该方法返回的是从字符串某一索引位置开始截取至某一索引位置结束的子串，代码如下：
substring(int beginlndex,int endlndex)
beginlndex:
开始截取子字符串的索引位置。
endlndex:
子字符串在整个字符串中的结束位置。
例5：《将进酒》的作者是哪位诗人？
public class Subs { //创建类
public static void main(String[] args) { //主方法
String str = "《将进酒》:李白（唐）"; //定义字符串
String substr = str.substring(6,8); //对字符串进行截取
System.out.println("《将进酒》的作者是"+substr); //输出截取后的字符串
}
}结果如下：
2.去除空格
trim()方法返回字符串的副本，忽略前导空格和尾部空格。语法如下：
str.trim();
其中，str为任何字符串对象。
例6：去掉字符首、尾的空格
public class Blak { //创建类
public static void main(String[] args) { //主方法
String str = " java class "; //定义字符串str
System.out.println("字符串原来的长度："+str.length()); //将str原来的长度输出
System.out.println("去掉空格后的长度："+str.trim().length());
}
}
结果如下：
3.字符串的替换
replace()方法可实现将指定的字符或字符串替换成新的字符或字符串。
str.replace(charSequence target, CharSequence replacement)
1.targt: 要替换的字符或字符串。
2.replacement：用于替换原来字符串的内容。
replace()方法返回的结果是一个新的字符串。如果字符或字符串 oldChar 没有出现在该对象表达式中的字符串序列中，则将原字符串返回。
例7：将单词中的字母a替换为字母A
public class NewStr { //创建类
public static void main(String[] args) { //主方法
String str = "address"; //定义字符串str
String newstr = str.replace("a", "A"); //将str中"a"替换成"A"并返回新字符串newstr
System.out.println(newstr); //将字符串newstr输出
}
}结果如下：
4.判断字符串的开始和结尾
startsWith()方法与endsWith()方法分别用于判断字符串是否以指定的内容开始或结束。这两个方法的返回值都为boolean类型。
1.startsWith()方法
该方法用于判断当前字符串对象的前缀是否为参数指定的字符串。语法如下：
str.startsWith(String prefix)
其中，prefix是指作为前缀的字符串。
2.endsWith()方法
该方法用于判断当前字符串是否为给定的子字符串。语法如下：
str.endsWith(String suffix)
其中，suffix是指作为后缀的字符串。
例8:判断字符串是否以指定的内容开始或结束
public class StartOrEnd { //创造类
public static void main(String[] args) { //主方法
String num1 = "22045612"; //定义字符串num1
String num2 = "21304578"; //定义字符串num2
boolean b = num1.startsWith("22"); //判断字符串num1是否以‘22’开头
boolean b2 = num2.endsWith("78"); //判断字符串num2是否以‘78‘结束
System.out.println("字符串num1是以'22'开始的吗？"+b);
System.out.println("字符串num2是以'78'结束的吗？"+b2); //输出信息
}
}
结果如下：
5.判断字符串是否相等
对字符串对象进行比较不能简单地使用比较运算符“==”，因为比较运算符比较的是两个字符串的地址是否相同。即使两个字符串的内容相同，两个对象的内存地址也是不同的，使用两个字符串的内容相同，两个对象的内存地址也是不同的，使用比较运算符仍然会返回false。使用比较运算符比较两个字符串，代码如下：
String tom = new String("l am a student");
String jerry = new String("l am a 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()方法对字符串进行比较时是否分大小写的，而使用equalsLgnoreCase()方法是在忽略了大小写的情况下比较两个字符串是否相等，返回结果仍为boolean类型。语法如下：
equalsLgnoreCase(String otherstr)
其他，str、otherstr是要比较的两个字符串对象。
例9：判断“abc”与“ABC”是否相等
public class Opinion { //创造类
public static void main(String[] args) { //主方法
String s1 = new String("abc"); //创建字符串对象s1
String s2 = new String("ABC"); //创建字符串对象s2
boolean b = s1.equals(s2); //使用equals()方法比较s1与s2
boolean b2 = s1.equalsIgnoreCase(s2); //使用equalsIgnoreCase()方法比较s1与s2
System.out.println(s1+ " equals " +s2 +":"+ b); //输出信息
System.out.println(s1+ " equalsIgnoreCas "+s2+":"+b2);
}
}
结果如下：
6.按字典顺序比较两个字符串
compareTo()方法为按字典顺序比较两个字符串，该比较基于字符串中各个字符的Unicode值，按字典顺序将String对象表示的字符序列与参数字符串所表示的字符序列进行比较。如果按字典顺序此String对象位于参数字符串之前，则比较结果为一个负整数；如果按字典顺序此String对象位于参数字符串之后，则比较结果为一个正整数；如果这两个字符串相等，则结果为0。语法如下：
str.compareTo(String otherstr)
其中，str、otherstr是要比较的两个字符串对象。
例10：判断字母b的位置
public class Wordbook { //创造类
public static void main(String[] args) { //主方法
String str = new String("b"); //用于比较的3个字符串
String str2 = new String("a");
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比较的结果输出
}
}结果如下：
7.字母大小写转换
String类的toLowerCase()方法可将字符串中的所有大小字母改写为小写字母，而toUpperCase()方法可将字符串中的所有小写字母改写为大写字母。
1.toLowerCase()方法
该方法将字符串中的所有大写字母转换为小写。如果字符串中没有应该被转换的字符，则将原字符串返回；否则将返回一个新的字符串，将原字符串中每个大写字母都转换成小写，字符串长度不变。语法如下：
str.toLowerCase()
其中，str是要进行转换的字符串。
2.toUpperCase()方法
该方法将字符串中所有的小写字母转换为大写。如果字符串中没有应该被转换的字符，则将原字符串返回；否则返回一个新字符串，将原字符串中每个小写字母都转换为大写，字符串长度不变，语法如下：
str.toUpperCase()
其中，str是要进行转换的字符串。
例11：字母大小写转换
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);
}
}
结果如下：
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:
限制的分割次数。
例12：按要求分割“192.168.0.1”
ublic 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.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();
}
}
结果如下：
每节总结示例代码：
public class Test3 {
public static void main(String[] args) {
//获取子串
String str = new String("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 s = st.trim();
System.out.println(s + "长度为" + s.length());
//字符串的替换
String stri = "address";
String replace = stri.replace("d","D");
System.out.println(replace);
//判断字符串开头
String num1 = "22045612";
boolean b1 = num1.startsWith("22");
System.out.println(b1);
//判断字符串结尾
String num2 = "21304578";
boolean b2 = num2.startsWith("78");
System.out.println(b2);
//判断字符串是是否相等
String str1 = new String("abc");
String str2 = new String("abc");
boolean b = (str1 == str2);
System.out.println(b);
boolean equals = str1.equals(str2);
System.out.println(equals);
String str3 = new String("ABC");
boolean equalsIgnnore = str1.equalsIgnoreCase(str3);
System.out.println(equalsIgnnore);
//按照Unicode的值去比较两个字符串的顺序
String st1 = "a";
String st2 = "b";
String st3 = "c";
System.out.println(st1.compareTo(st2));
System.out.println(st2.compareTo(st2));
System.out.println(st3.compareTo(st2));
//字符串中字母的大小写转换
String s1 = "Oh My God";
System.out.println(s1.toLowerCase());
System.out.println(s1.toUpperCase());
//字符串的分割
String srtin = "192.168.0.1";
String[] split1 = srtin.split("\\.");
for(String temp : split1) {
System.out.println(temp);
}
String[] split2 = srtin.split("\\.",2);
for(String temp : split2) {
System.out.println(temp);
}
}
}结果如下：
五.格式化字符串
Sting 类的静态format()方法用于创建格式化的字符串。format()方法有两种重载形式。
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)
l:
格式化过程中要应用的语言环境。如果1为null，则不进行本地化。
format:
格式字符串。
args:
格式字符串中由格式说明符引用的参数。如果还有格式说明符以外的参数，则忽略这些额外的参数。此参数的数目是可变的，可以为0。
1.日期和时间字符串格式化
在应用程序设计中，经常需要显示日期和时间。如果想输出满意的日期和时间格式，一般需要编写大量的代码、经过各种算法才能实现。formatI()方法通过给定的特殊转换符作为参数来实现对日期和时间的格式化。
1.日期格式化
例子。返回一个月中的天数，代码如下:
Date date = new Date();//创建 Date 对象
dateStrings=String.format(“%te”date) ; //通过format()方法对 date 进行格式化
上述代码中变量 s的值是当前日期中的天数，如今天是 15 号，则 s 的值为 15;%te 是转换符。常用的日期格式化转换符如图所示。
例13：按照格式输出今天的年、月、日
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);
String day = String.format("%td",date);
System.out.println("今年是："+year+"年"); //输出信息
System.out.println("现在是："+month);
System.out.println("今天是："+day+"号");
}
}
结果如下：
2.时间格式化
使用 format()方法不仅可以完成日期的格式化也可以实现时间的格式化。时间的格式化转换符要比日期的格式化转换符更多、更精确，它可以将时间格式化为时、分、秒、毫秒等。
例14：按照格式输出当下的时、分、秒
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);
String second = String.format("%tS",date);
System.out.println("现在是："+hour+"时"+minute+"分"+second+"秒");
//输出的信息
}
}结果如下：
3.格式化常见的日期时间组合
格式化日期与时间组合的转换符定义了各种日期时间组合式，其中常见的如图所示。
例15：按照格式输出当下的年、月、日
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);
System.out.println("全部的时间信息是："+time); //将格式化后的日期时间输出
System.out.println("年-月-日格式："+form);
}
}
结果如下：
2.常规类型格式化
常规类型格式化可应用于任何参数类型，可通过表中的转换符来实现。
例16：使用转换符获取表达式的结果
package Package10;
public class General {//新建类
public static void main(String[] args) {//主方法
String str = String.format("%d", 400 / 2);//将结果以十进制格式显示//将结果以 boolean 型显示//将结果以十六进制格式显示
String str2 = String.format("%b", 3 > 5);//将结果以 boolean 型显示//将结果以十六进制格式显示
String str3 = String.format("%x", 200);//将结果以十六进制格式显示
System.out.println("400 的一半是:"+ str);//输出格式化字符串
System.out.println("3>5 正确吗:"+ str2);
System.out.println("200 的十六进制数是:"+ str3);
}
}结果如下：
每节总结示例代码：
import java.util.Date;
public class Tast4 {
public static void main(String[] args) {
//格式化字符串
//String 格式化后的字符串 = String.format(格式,字符串);
//日期与时间格式化
Date date = new Date();
System.out.println(date);
//日期格式化
String year = String.format("%tY", date);
String month = String.format("%tm", date);
String day = String.format("%td", date);
System.out.println(year + "年" + month + "月" + day +"日");
//时间格式化
String hour = String.format("%tH", date);
String minute = String.format("%tM", date);
String second = String.format("%tS", date);
System.out.println(hour + "时" + minute + "分" + second + "秒");
//常用日期时间组合格式化
String dateFormat = String.format("%tF", date);
String timeFormat = String.format("%tT", date);
System.out.println(dateFormat + " " + timeFormat);
}
}结果如下：
六.使用正则表达式
正则表达式通常被用于判断语句中，用来检查某一字符串是否满足某一格式。正则表达式是含有-些具有特殊意义字符的字符串，这些特殊字符称为正则表达式的元字符。例如，“\\d”表示数字0~9中的任何一个，“\d”就是元字符。正则表达式中的元字符及其意义如表中所示。
在正则表达式中，可以使用方括号括起若干个字符来表示一个元字符，该元字特可代表方括号中的任何一个字符。例如，reg ="[abc]4”，这样字符串 a4、b4、c4 都是和正则表达式匹配的字符串，方括号元字符还可以为其他格式。如：
1.[456]: 表 4、5、6之外的任何字符。
2.[a-r]: 代表 a~r中的任何一个字母。
3.[a-zA-Z]: 可表示任意一个英文字母。
4.[a-e[g-z]]: 代表a~e或 g~z中的任何一个字母(并运算)。
5.[a-o&&[def]]: 代表字母 d、e、f (交运算)。
6.[a-d&&[bc]]: 代表字母a、d (差运算)。
在正则表达式中允许使用限定修饰符来限定元字符出现的次数。例如：“A*”代表A可在字符串中出现0次或多次。限定修饰符的用法如表所示。
例:17验证E-mail地址是否“合法”
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 = "aaaaaa";
String str3 = "[email protected]";
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地址格式");
}
String er = "\\d{13}";
String b = "1234567890123";
if(b.matches(er)) {//判断字符串变量是否与正则表达式匹配
System.out.println(b + "是一个合法的E-mail地址格式");
}
}
}结果如下：
正则表达式分析:
通常情况下E-mail的格式为“[email protected]”字符 X 表示任意的一个或多个字符，@为 E-mail 地址中的特有符号，符号@后还有一个或多个字符，之后是字符“.com”，也可能后面还有类似“.cn”的标记。总结 E-mail 地址的这些特点，可以书写正则表达式“\\w+@\\w+(\\.\\w{2,3})\\w{2,3}”来匹配E-mail地址。字符集“\\w”匹配任意字符,符号“+”表示字符可以出现 1次或多次，表达式“(\\.\\w{2,3})*”表示形如“com”格式的字符串可以出现0次或多次。而最后的表达式“\\.\\w{2,3}”用于匹配 E-mail 地址中的结尾字符，如“.cn”。
七.字符串生成器
创建成功的字符串对象，其长度是固定的，内容不能被改变和编译。虽然使用“+”可以达到附加新字符或字符串的目的，但“+”会产生一个新的 String 实例，会在内存中创建新的字符串对象。如重复地对字符串进行修改，将极大地增加系统开销。而JDK 新增了可变的字符序列 StringBuilder类大大提高了频繁增加字符串的效率。
例18:效率比拼
package Package10;
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 i= 0;i< 10000; i++){//利用 for 循环进行操作
builder.append(i);//循环追加字符
}
endTime = System.currentTimeMillis();//更新操作后的时间//将操作时间输出
time = endTime - starTime;//更新追加操作执行的时间
System.out.println("StringBuilder 消耗时间:"+ time);//将操作时间输出
}
}结果如下:
通过这一实例可以看出，两种操作执行的时间差距很大。如果在程序中频繁地附加字符串，建议使用 StringBuilder类新创建的 StringBuilder对象初始容量是16个字符,可以自行指定初始长度。如果附加的字符超过可容纳的长度，则StringBuilder 对象将自动增加长度以容纳被附加的字符。若要使用StringBuilder类最后输出字符串结果，可使用 toString()方法。利用 StringBuilder 类中的方法可动态地执行添加、删除和插入等字符串的编辑操作。该类的常用方法如下。
1.append()方法
该方法用于向字符串生成器中追加内容。通过该方法的多个重载形式，可实现接受任何类型的数据，如int、boolean、char、String、double 或者另一个字符串生成器等。语法如下:
append(content)
其中，content表示要追加到字符串生成器中的内容，可以是任何类型的数据或者其他对象。
2.insert(int offset, arg)方法
该方法用于向字符串生成器中的指定位置插入数据内容。通过该方法的不同重载形式，可实现向字符串生成器中插入int、float、char 和 boolean 等基本数据类型的数据或其他对象。语法如下:
insert(int offset arg)
ofset:
字符串生成器的位置。该参数必须大于等于0，且小于等于此序列的长度。
arg:
将插入至字符串生成器的位置。该参数可以是任何数据类型的数据或其他对象。
向字符串生成器中指定的位置添加字符，代码如下:
StringBuilder bf = new StringBuilder("hello");//创建字符生成器
bf.insert(5，"world");//添加至字符生成器的位置及内容
System.out.println(bf.toString());//此时输出信息为hellword
3.delete(int start , int end)方法
移除此序列的子字符串中的字符。该子字符串从指定的 stat 处开始，一直到索引 end-1 处的字符如果不存在这种字符，则一直到序列尾部。如果 start 等于 end，则不发生任何更改。语法如下:
delete(int start , int end)
1.start: 将要删除的字符串的起点位置。
2. end:将要删除的字符串的终点位置。
删除指定位置的子字符串，代码如下：
StringBuilder bf = new StringBuilder("StringBuilder");//创建字符串生成器
bf.delete(5,10);//删除的子字符串
System.out.println(bf.toString());//此时输出的信息为Strinder