一、String类
(1)、声明字符串
在java语言中字符串必须包含在一对双引号(" ")之内，但不能作为其他数据类型来使用，如"1+2"的输出结果不可能是3；
可以通过以下语法格式来声明字符串变量：
String str;
String:指定该变量为字符串类型。
str：任意有效的标识符，表示字符串变量的名称。
声明字符串变量s，代码如下：
1 String s ;
声明字符串变量必须经过初始化才能使用，否则编译器会报出“变量未被初始化错误”。
(2)、创建字符串
①、利用构造方法直接实例化
语法
构造方法：public Sting (String original) //original文本内容
示例：
1 Sting a = new Sting ("hello world");
2 Sting b = new Sting (a);
②、利用字符数组实例化第一种用法
语法
构造方法：public Sting (char[]value) //value字符数组
示例：创建字符数组，用一个字符数组charArray所有元素连接成一个String对象；
1 char[] charArray={'1','2','3','4','5','6'};
2 String a = new String(charArray);
③、利用字符数组实例化第二种用法
语法
构造方法：public Sting (char[] calue,int offset,int count) //value字节数组；offset起始位置；count获取个数
示例：提取字符数组charArray中的一部分创建一个字符串对象；
1 char[] charArray={'1','2','3','4','5','6'};
2 String a = new String(charArray,4,2);
④、利用字节数组实例化
语法
构造方法：public String(byte[] bytes)//bytes字节数组
示例：创建byteArray字节数组，其字符编码序列结果输出为“您好”；
1 byte[] byteArray = {-60,-6,-70,-61};
2 String a = new String(byteArray);//String.getBytes()
⑤、引用字符串常量来创建字符串变量
示例：
1 String str1,str2;
2 str1="We are students"
3 str2="We are students"
此时str1与str2引用相同的字符串常量，因此具有相同的实体。
二、连接字符串
①、连接多个字符串
使用“+”或者“+=”运算符可实现连接多个字符串的功能。“+”或者“+=”运算符可以连接多个运算符并产生一个String对象。
示例：“+=”与“+”的区别；
1 public class Demo {
2 public static void main(String[] args) {
3 String s1 = new String("hello");
4 String s2 = new String("world");
5 String s = s1 + " " + s2;
6 }
7 }
1 public class Demo {
2 public static void main(String[] args) {
3 String s1 = new String("hello");
4 s1 += new String(" world");
5 }
6 }
一句相连的字符串不能分开在两行中写。
例如：下列语句的写法就是错误的。
System.out.println("I like
java")
如果一个字符串太长，为了便于阅读，必须将这个字符串分在两行中书写，则需要使用“+”将两个字符串连起来，之后在加号处换行。
因此，上面的语句可以修改为：
System.out.println("I like"+
"java")
②、连接其他数据类型
字符串也可同其他基本数据类型进行连接，如果将字符串同这些数据类型进行连接，会将这些数据直接转换成字符串。
示例：
1 public class Demo {
2 public static void main(String[] args) {
3 int booktime = 4; // 声明的int型变量booktime
4 float practice = 2.5f; // 声明的float型变量practice
5 // 将字符串与整型、浮点型变量相连
6 System.out.println("我每天花费" + booktime + "小时看书；" + practice + "小时上机练习");
7 }
8 }
结果为：
我每天花费4小时看书；2.5小时上机练习
本实例实现的是将字符串常量与整型变量booktime和浮点型变量practice相连后的结果输出，
在这里booktime和practice都不是字符串，当它们与字符串相连时会自动调用toString()方法，将其转换成字符串形式，然后参与连接；
只要“+”运算符的一个操作数是字符串，编译器就会将两一个操作数转换成字符串形式，
所以应谨慎地将其他数据类型与字符串相连，以免出现意想不到的结果。
假如将上例中的输出语句修改为：
System.out.println("我每天花费" + booktime + "小时看书；" +( practice +booktime)+ "小时上机练习");
结果为：
我每天花费4小时看书；6.5小时上机练习
为什么会这样呢？这是由于运算符是有优先级的，圆括号的优先级最高，所以先被执行，然后再将结果与字符串相连。
三、获取字符串信息
（1）、获取字符串长度
语法
public int length()
示例：
1 String a = "1 234567890";
2 int size = a.length();//变量size的值是11
注意：length()方法返回的字符串长度包括字符串中的空格；
（2）、字符串查找
String类提供了两种查找字符串的方法，即indexOf()与lastIndexOf()方法。
①、indexOf()方法返回的是搜索的字符或字符串首次出现的位置；
示例：查找字符“e”在字符串str中的索引位置，注：返回“e”第一次出现的位置。
1 public class Demo {
2 public static void main(String[] args) {
3 String str = "We are the world";
4 int size = str.indexOf("e");
5 System.out.println(size);// 变量size的值是1
6 }
7 }
理解字符串的索引位置，要对字符串的下标有所了解，在计算机中String对象使用数组表示的，字符串的下标是0~length()~-1。
示例：查找字符“e”在字符串str中起始位置3之后的索引位置，注：返回“e”是在索引3之后第一次出现的位置。
1 public class Demo {
2 public static void main(String[] args) {
3 String str = "We are the world";
4 int size = str.indexOf("e", 3);
5 System.out.println(size);// 变量size的值是5
6 }
7 }
从下面这张图上可以看出来，
②、str.indexOf("B"),判断字符串中是否有“B”这个子字符串，如果有，返回“B”的索引位置（这个值肯定是大于等于0的），
如果不存在这个子字符串，那结果返回的是-1（这个值就是-1）。
示例：
1 public class Demo {
2 public static void main(String[] args) {
3 String str1 = "8888";
4 String str2 = "B888";
5 if (str1.indexOf("B") == -1) {
6 System.out.println(str1 + "不包含B这个字母");//8888不包含B这个字母
7 }
8 if (str2.indexOf("B") > -1) {
9 System.out.println(str2 + "包含B这个字母");//B888包含B这个字母
10 }
11 }
12 }
③、lastIndexOf()方法返回的是搜索的字符或字符串最后一次出现的位置。当调用字符串的lastIndexOf()方法时，
会从字符串的结尾处，从右向左反方向查找指定的字符串，如果找到指定的字符串，则返回该字符串中第一个字符的索引；如果没有查找到字符串，该方法返回-1。
示例：使用lastIndexOf()方法查看字符串str中空字符串的位置，然后输出字符串的长度，看它们是否相同，并查找”t“在字符串中的最后一次出现的索引位置；
1 public class Demo {
2 public static void main(String args[]) {
3 String str = "Let it go!Let it go!";
4 // 将空格在str中的索引位置赋值给变量size
5 int size = str.lastIndexOf("");// ("")空字符串，没有空格
6 // 将变量size输出
7 int size1 = str.lastIndexOf("t");
8 // 将变量size1输出
9 System.out.println("t在字符串str中的最后一次出现的索引位置是："+size1);//t在字符串str中最后一次出现的索引位置是：15
10 //返回t最后一次出现的位置
11 System.out.println("空格在字符串str中的最后一次出现的索引位置是：" + size);// 空格在字符串str中的最后一次出现的索引位置是：20
12 // 将字符串str的长度输出
13 System.out.println("字符串str的长度是：" + str.length());// 字符串str的长度是：20
14 }
15 }
如果lastIndexOf()方法中的参数是空字符串""(注意没有空格)，则返回的结果与调用该字符串length()方法的返回结果相同。
从下面的图中可以看出来；
示例：获取“t”在字符串str中起始位置14之后出现的索引位置，注：返回“t”是在索引14之后第一次出现的位置，往前查。
1 public class Demo {
2 public static void main(String args[]) {
3 String str = "Let it go!Let it go!";
4 int size = str.lastIndexOf("t", 14);
5 // 将变量size输出
6 System.out.println("t在字符串str中的索引位置是：" + size);// t在字符串str中的索引位置是：12
7 // 返回t最后一次出现的位置
8 }
9 }
从下面的图中可以看出来；
(3)、获取指定索引位置的字符
使用charAt()方法可将指定索引处的字符返回。
语法
public char charAt(int index)//index要获取的索引位置
示例：
1 public class Demo {
2 public static void main(String[] args) {
3 String name = "peter";
4 char ch = name.charAt(0);
5 System.out.println(ch);// 变量ch的值是P
6 }
7 }
四、字符串操作
（1）、获取子字符串
通过String类的substring()方法可对字符串进行截取。这些方法的共同点就是都是利用字符串的下标进行截取，且应明确字符串下标是从0开始的。
substring()方法被两种不同的方法重载，来满足不同的需要。
①、substring(int beginIndex)
该方法返回的是从指定的索引位置开始截取直到该字符串结尾的子串。
语法
public String substring(int beginIndex)//beginIndex开始截取的位置
其中beginIndex指定从某一索引开始截取字符串。
示例： 创建String对象，实现substring()方法对字符串进行截取
1 public class Demo {
2 public static void main(String[] args) {
3 String id = "123456198707014425";
4 String substr = id.substring(6);
5 System.out.println(substr);//变量substr的值是198707014425
6 }
7 }
注意：在字符串中，空格占用一个索引位置。
②、substring(int beginIndex,int endIndex)
该方法返回的是从字符串某一索引位置开始截取至某一索引位置结束的子串。
语法
substring(int beginIndex,int endIndex)//beginIndex开始截取的位置，endIndex截取结束的位置
示例：创建String对象，实现substring()方法对字符串进行截取
1 public class Demo {
2 public static void main(String[] args) {
3 String id = "123456198707014425";
4 String substr = id.substring(6,14);
5 System.out.println(substr);//变量substr的值是19870701
6 }
7 }
(2)、去除首尾空格
语法
public String trim()
示例：
1 public class Demo {
2 public static void main(String[] args) {
3 String str = " java class ";
4 System.out.println("保留空格后的内容：[" + str + "]");// 保留空格后的内容：[ java class ]
5 System.out.println("原来的长度：" + str.length());// 原来的长度：15
6
7 String shortstr = str.trim();
8 System.out.println("去掉空格后的内容：[" + shortstr + "]");// 去掉空格后的内容：[java class]
9 // trim()方法只去除首尾空格,中间空格不忽略。
10 System.out.println("去掉空格后的长度：" + str.trim().length());// 去掉空格后的长度：10
11 }
12 }
(3)、去除字符串中所有空格
示例：
1 public class Demo {
2 public static void main(String[] args) {
3 String str = " java class ";
4 String shortstr = str.replaceAll("\s", "");// \s正则表达式，“”替换成空内容
5 System.out.println("去除所有空格后的内容：[" + shortstr + "]");// 去除所有空格后的内容：[javaclass]
6 }
7 }
（4）、字符串替换
语法
public String replace(char oldChar,char newChar)
oldChar:要替换的字符或字符串。
newChar:用于替换原来字符串的内容。
replace()方法返回的结果是一个新的字符串。如果字符串oldChar没有出现在该对象表达式中的字符串序列中，则将原字符串返回。
示例：
1 public class Demo {
2 public static void main(String[] args) {
3 String str = "馒头一文一个";
4 String newstr = str.replace("一", "壹");
5 System.out.println(newstr);// 馒头壹文壹个
6 }
7 }
（5）、判断字符串的开始与结尾
startsWith()方法与endsWith()方法分别用于判断字符串是否以指定的内容开始或结束，这两个方法的返回值都是boolean值。
①、startsWith()方法
该方法用于判断当前字符串对象的前缀是否为参数指定的字符串。
语法
str.startsWith(String prefix)// prefix是指作为前缀的字符串
②、endsWith()方法
该方法用于判断当前字符串是否为以给定的子字符串结束。
语法
str.endsWith(String suffix)// suffix是指作为后缀的字符串
示例：
1 public class Demo {
2 public static void main(String[] args) {
3 String num1 = "22045612"; // 定义字符串num1
4 String num2 = "21304578"; // 定义字符串num2
5 boolean b = num1.startsWith("22"); // 判断字符串num1是否以'22'开头
6 boolean b2 = num1.endsWith("78"); // 判断字符串num1是否以'78'结束
7 boolean b3 = num2.startsWith("22"); // 判断字符串num2是否以'22'开头
8 boolean b4 = num2.endsWith("78"); // 判断字符串num2是否以'78'结束
9 System.out.println("字符串num1是以'22'开始的吗？" + b);// 字符串num1是以'22'开始的吗？true
10 System.out.println("字符串num1是以'78'结束的吗？" + b2); // 字符串num1是以'78'结束的吗？false
11 System.out.println("字符串num2是以'22'开始的吗？" + b3);// 字符串num2是以'22'开始的吗？false
12 System.out.println("字符串num2是以'78'结束的吗？" + b4);// 字符串num2是以'78'结束的吗？true
13 }
14 }
(6)、判断字符串是否相等
对字符串对象进行比较不能简单的使用比较运算符“==”，因为比较运算符比较的是两个字符串的地址是否相同。
即使两个字符串的内容相同，两个对象的内存地址也是不同的，使用比较运算符仍然会返回false。
示例：使用比较运算符比较两个字符串
1 public class Demo {
2 public static void main(String[] args) {
3 String name = new String("tom");
4 String dbvalue = new String("tom");
5 System.out.println(name == dbvalue);// 结果返回的是false
6 }
7 }
从下面图中可以看出来为什么会不相等
因此，要比较两个字符串内容是否相等，应使用equals()方法和equalsIgnoreCase()方法。
①、 equals()方法
如果两个字符串具有相同的字符和长度，则使用equals()方法进行比较时，则返回true。
语法
str.equals(String otherstr)// str、otherstr是要比较的两个字符串对象。
示例：
1 public class Demo {
2 public static void main(String[] args) {
3 String name = new String("tom");
4 String dbvalue = new String("tom");
5 System.out.println(name.equals(dbvalue));// 结果返回的是true
6 }
7 }
②、equalsIgnoreCase()方法
使用equals()方法对字符串进行比较时是区分大小写的，而使用equalsIgnoreCase()方法是在忽略了大小写的情况下比较两个字符串是否相等，返回结果仍为boolean类型。
str.equalsIgnoreCase(String otherstr)// str、otherstr是要比较的两个字符串对象。
示例： equals()方法和equalsIgnoreCase()方法的区别
①、
1 public class Demo {
2 public static void main(String[] args) {
3 String s1 = new String("abc");
4 String s2 = new String("ABC");
5 String s3 = new String("abc");
6 boolean b = s1.equals(s2); // 使用equals()方法比较s1与s2
7 boolean b2 = s1.equals(s3);// 使用equals()方法比较s1与s3
8 boolean b3 = s1.equalsIgnoreCase(s2);// 使用equalsIgnoreCase()方法比较s1与s2
9 System.out.println(s1 + " equals " + s2 + " :" + b); // abc equals ABC :false
10 System.out.println(s1 + " equals " + s3 + " :" + b2);// abc equals abc :true
11 System.out.println(s1 + " equalsIgnoreCase " + s2 + " :" + b3);// abc equalsIgnoreCase ABC :true
12 }
13 }
②、
1 public class Demo {
2 public static void main(String[] args) {
3 String s1 = new String("abc");
4 String s2 = new String("ABC");
5 String s3 = new String("abc");
6 System.out.println(s1 + " equals " + s3 + " :" + s1.equals(s3));// abc equals abc :true
7 System.out.println(s1 + " == " + s3 + " :" + (s1 == s3));// abc == abc :false
8 System.out.println(s1 + " equalsIgnoreCase " + s2 + " :" + s1.equalsIgnoreCase(s3));// abc equalsIgnoreCase ABC ：true
9 }
10 }
①和②使用方法意义一样。
特殊情况示例：创建的字符串不是用new方法创建的，而是直接引用字符串常量，像下面的代码示例，那结果就是“true”。
1 public class Demo {
2 public static void main(String[] args) {
3 String name = "tom";
4 String dbValue = "tom";
5 //不是使用new方法创建的字符串
6 String str1 = new String("tom");
7 String str2 = new String("tom");
8
9 System.out.println(name == dbValue);// true
10 System.out.println(str1 == str2);// false
11 }
12 }
从下图就可以看出来为什么相等。
(7)、按字典顺序比较两个字符串
compareTo()方法为按字典顺序比较两个字符串，该比较基于字符串中各个字符的Unicode值，按字典顺序将此String对象表示的字符序列与参数字符串所表示的字符序列进行比较。
如果按字典顺序此String对象位于参数字符串之前，则比较结果为一个负整数；如果按字典顺序此String对象位于参数字符串之后，则比较结果为一个正整数；如果这两个字符串相等，则结果为0。
语法
str.compareTo(String otherstr)// str、otherstr是比较的两个字符串对象。
说明
compareTo()方法只有在equals(Object)方法返回true时才返回0。
示例：使用compareTo()方法将字符变量进行比较，并将结果输出。
1 public class Demo {
2 public static void main(String[] args) {
3 String str = new String("b");
4 String str2 = new String("a");// 用于比较的3个字符串
5 String str3 = new String("c");
6 System.out.println(str + "compareTo " + str2 + ":" + str.compareTo(str2));// bcompareTo a:1
7 // 将str与str2比较的结果输出
8 System.out.println(str + "compareTo " + str3 + ":" + str.compareTo(str3));// bcompareTo c:-1
9 // 将str与str3比较的结果输出
10 }
11 }
(8)、字母大小写转化
字符串的toLowerCase()方法可将字符串中所有字符从大写字母改写为小写字母，而toUpperCase()方法可将字符串中的小写字母改写为大写字母。
①、toLowerCase()方法
该方法是将String转换为小写。如果字符串中没有应该被转换的字符，则将原字符串返回；否则将返回一个新的字符串，将原字符串中每个该进行小写转换的字符都转换成等价的小写字符。字符长度与原字符相同。
语法
str.toLowerCase()// str是要进行转换的字符串。
②、toUpperCase()方法
该方法将String转换为大写。如果字符串中没有应该被转换的字符，则将原字符串返回；否则将返回一个新的字符串，将原字符串中每个该进行大写转换的字符都转换成等价的大写字符。新字符长度与原字符相同。
语法
str.toUpperCase()// str是要进行转换的字符串。
说明
使用toLowerCase()方法和toUpperCase()方法进行大小写转换时，数字或非字符不受影响。
示例：在主方法中创建String型变量，实现字符变量的大小写转换，并将转换后的结果输出。
1 public class Demo {
2 public static void main(String[] args) {
3 String str = new String("abc DEF");
4 String newstr = str.toLowerCase();
5 String newstr2 = str.toUpperCase();
6 System.out.println(newstr);// abc def
7 System.out.println(newstr2);// ABC DEF
8 }
9 }
(9)、字符串分割
使用split()方法可以使字符串按指定的分割字符或字符串对内容进行分割，并将分割后的结果存放在字符串数组中。split()方法提供了两种字符串分割形式。
①、split(String sign)
该方法可根据给定的分割符对字符串进行拆分。
语法
str.split(String sign)// sign 为分割字符串的分隔符，也可以使用正则表达式。
说明
没有统一的对字符进行分割的符号。如果想定义多个分隔符，可使用符号“|”。例如，“,|=”表示分割符分别为“,”和“=”。
②、split(Sting sign,int limit)
该方法可根据给定的分割符对字符串进行拆分，并限定拆分的次数。
语法
str.split(String sign,int limit) // sign:分割字符串的分隔符，也可以使用正则表达式。limit:模式匹配次数，如果值设置为N，那么将根据正则表达式匹配n-1次，得到的结果数组长度不会大于n，数组的最后一项是最后匹配的分隔符以后的全部内容。
示例：在主方法中创建String型变量，并将字符变量进行分割，将分割后的结果输出。
1 public class Demo {
2 public static void main(String[] args) {
3 // 创建字符串
4 String str = "192.168.0.1";
5 // 按照"."进行分割
6 String[] firstArray = str.split("\.");
7 // 按照"."进行两次分割
8 String[] secondArray = str.split("\.", 2);
9 // 输出str原值
10 System.out.println("str的原值为：[" + str + "]");
11 // 输出全部分割的结果
12 System.out.print("全部分割的结果：");
13 for (String a : firstArray) {
14 System.out.print("[" + a + "]");
15 }
16 System.out.println();// 换行
17 // 输出分割两次的结果
18 System.out.print("分割两次的结果：");
19 for (String a : secondArray) {
20 System.out.print("[" + a + "]");
21 }
22 System.out.println();
23 }
24 }
五、格式化字符串
String类的静态format()方法用于创建格式化的字符串。format()方法有两种重载形式。
①、 format(String format,Obiect…args)
该方法使用指定的格式字符串和参数返回一个格式化字符串，格式化后的新字符串使用本地默认的语言环境。
语法
str.format(String format,Obiect…args)// format:格式字符串。args：格式字符串中由格式说明符引用的参数。如果还有格式说明符以外的参数，则忽略这些额外的参数，此参数的数目是可变的，可以为0.
②、format(Local 1,String format,Object …args)
语法
str.format(Local 1,String format,Object …args)// 1:格式化过程中要应用的语言环境，如果1为null，则不进行本地化。format:格式字符串。args：格式字符串中由格式说明符引用的参数。如果还有格式说明符以外的参数，则忽略这些额外的参数，此参数的数目是可变的，可以为0.
(1)、日期和时间字符串格式化
在应用程序设计中，经常需要显示时间和日期。如果想输出满意的日期和时间格式，一般需要编写大量的代码经过各种算法才能实现。format()方法通过给定的特殊转换符作为参数来实现对日期和时间的格式化。
①、日期格式化
语法
String.format(String format,Object…args)
示例：
1 import java.util.Date;
2
3 public class Demo {
4 public static void main(String[] args) {
5 Date date = new Date();
6
7 String year = String.format("%tY", date);
8 String month = String.format("%tB", date);
9 String day = String.format("%td", date);
10
11 System.out.println("今年是：" + year + "年");// 今年是：2019年
12 System.out.println("现在是：" + month);// 现在是：十二月
13 System.out.println("今天是：" + day + "日");// 今天是：23日
14
15 String hour = String.format("%tH", date);
16 String minute = String.format("%tM", date);
17 String second = String.format("%tS", date);
18 System.out.println("今年是：" + hour + "时" + minute + "分" + second + "秒");// 今年是：19时45分29秒
19
20 String str1 = String.format("%tF", date);
21 System.out.println("tF格式：" + str1);// tF格式：2019-12-23
22 String str2 = String.format("%tD", date);
23 System.out.println("tD格式：" + str2);// tD格式：12/23/19
24 String str3 = String.format("%tc", date);
25 System.out.println("tc格式：" + str3);// tc格式：星期一 十二月 23 19:45:29 CST 2019
26 String str4 = String.format("%tr", date);
27 System.out.println("tr格式：" + str4);// tr格式：07:45:29 下午
28 }
29 }
常用的日期格式化转化符
| 转 换 符 |
说 明 | 示 例 |
| %te | 一个月中某一天(1~31) | 2 |
| %tb | 指定语言环境的月份简称 | Feb(英文)、二月(中文) |
| %tB | 指定语言环境的月份全称 | February(英文)、二月(中文) |
| %tA | 指定语言环境的星期几全称 | Monday(英文)、星期一(中文) |
| %ta | 指定语言环境的星期几简称 | Mon(英文)、星期一(中文) |
| %tc | 包括全部日期和时间信息 | 星期一 十二月 23 19:45:29 CST 2019 |
| %tY | 4位年份 | 2019 |
| %tj | 一年中的第几天(001~366) | 085 |
| %tm | 月份 | 03 |
| %td | 一个月中的第几天(01~31) | 02 |
| %ty | 2位年份 | 08 |
②、时间格式化
使用format()方法不仅可以完成日期的格式化，也可以实现时间的格式化。时间格式化转换符要比日期转换符更多、更精确，它可以将时间格式化分为时、分、秒、毫秒。如下表所示。
时间格式化转换符
| 转 换 符 |
说 明 | 示 例 |
| %tH | 2位数字的24时制的小时(00~23) | 14 |
| %tI | 2位数字的12时制的小时(01~12) | 05 |
| %tk | 2位数字的24时制的小时(0~23) | 5 |
| %tl | 2位数字的12时制的小时(1~12) | 10 |
| %tM | 2位数字的分钟(00~59) | 05 |
| %tS | 2位数字的秒数(00~60) | 12 |
| %tL | 3位数字的毫秒数(000~999) | 920 |
| %tN | 9位数字的微秒数(000000000~999999999) | 062000000 |
| %tp | 指定语言环境下上午或下午标记 | 下午(中文)、pm(英文) |
| %tz | 相对于GMT RFC 82格式的数字时区偏移量 | +0800 |
| %tZ | 时区缩写形式的字符串 | CST |
| %ts | 1970-01-01 00:00:00至现在经过的秒数 | 1206426646 |
| %tQ | 1970-01-01 00:00:00至现在经过的毫秒数 | 1206426737453 |
示例：在项目中创建类GetDate，实现将当前时间信息以2位小时数、2位分钟数、2位秒数形式输出。
1 import java.util.*;
2
3 public class GetDate { // 新建类
4 public static void main(String[] args) { // 主方法
5 Date date = new Date(); // 创建Date对象date
6 String hour = String.format("%tH", date); // 将date进行格式化
7 String minute = String.format("%tM", date);
8 String second = String.format("%tS", date);
9 // 输出的信息
10 System.out.println("现在是：" + hour + "时" + minute + "分" + second + "秒");// 现在是：20时39分46秒
11 }
12 }
③、格式化常见的日期时间组合
格式化日期与时间的转换符定义了各种日期时间组合的格式，其中最常用的日期和时间的组合格式如下表所示。
常见的日期和时间组合的格式
| 转 换 符 | 说 明 | 示 例 |
| %tF | “年-月-日”格式(4位年份) | 2019-12-23 |
| %tD | “月/日/年”格式(2位年份) | 12/23/19 |
| %tc | 全部日期和时间信息 | 星期一 十二月 23 20:47:00 CST 2019 |
| %tr | “时:分:秒 PM(AM)”格式(12时制) | 20:47:38 下午 |
| %tT | “时:分:秒”格式(24时制) | 20:48:40 |
| %tR | “时:分”格式(24时制) | 20:50 |
示例：在项目中创建类DateAndTime,在主方法中实现将当前日期时间的全部信息以及指定格式的日期输出。
1 import java.util.*;
2
3 public class DateAndTime { // 创建类
4 public static void main(String[] args) { // 主方法
5 Date date = new Date(); // 创建Date对象date
6 String time = String.format("%tc", date); // 将date格式化
7 String form = String.format("%tF", date);
8 // 将格式化后的日期时间输出
9 System.out.println("全部的时间信息是：" + time);// 全部的时间信息是：星期一 十二月 23 20:50:56 CST 2019
10 System.out.println("年-月-日格式：" + form);// 年-月-日格式：2019-12-23
11 }
12 }
(2)、常规类型格式化
常规类型的格式化可应用于任何参数类型，可使用下表所示的转换符来实现。
| 转 换 符 | 说 明 | 示 例 |
| %b、%B | 结果被格式化为布尔类型 | true |
| %h、%H | 结果被格式化为散列码 | A05A5198 |
| %s、%S | 结果被格式化为字符串类型 | "abcd" |
| %c、%C | 结果被格式化为字符类型 | 'a' |
| %d | 结果被格式化为十进制整数 | 40 |
| %o | 结果被格式化为八进制整数 | 11 |
| %x、%X | 结果被格式化为十六进制整数 | 4b1 |
| %e | 结果被格式化为用计算机科学记数法表示的十进制数 | 1.700000e+01 |
| %a | 结果被格式化为带有效位数和指数的十六进制浮点值 | 0X1.C000000000001P4 |
| %n | 结果为特定于平台的行分隔符 | |
| %% | 结果为字面值'%' | % |
示例：在项目中创建General，在主方法中实现不同数据类型到字符串的转换。
1 public class General { // 新建类
2 public static void main(String[] args) { // 主方法
3 String str = String.format("%d", 400 / 2); // 将结果以十进制显示
4 String str2 = String.format("%b", 3 > 5); // 将结果以布尔形式显示
5 String str3 = String.format("%x", 200); // 将结果以十进制格式显示
6 System.out.println("400的一半是：" + str); // 400的一半是：200
7 System.out.println("3>5正确吗：" + str2); // 3>5正确吗：false
8 System.out.println("200的十六进制数是：" + str3); // 200的十六进制数是：c8
9 }
10 }
(六)、使用正则表达式
正则表达式通常被用于判断语句中，用来检查某一字符串是否满足某一格式。正则表达式是含有一些具有特殊意义字符的字符串，这些特殊字符称为正则表达式的元字符。例如，“\d”表示数字0~9中的任何一个，“\d”就是元字符。正则表达式中元字符及其意义如下表所示。
正则表达式中的元字符
| 元 字 符 | 正则表达式中的写法 | 意 义 |
| . | . | 代表任意一个字符 |
| d | \d | 代表0~9的任何一个数字 |
| D | \D | 代表任何一个非数字字符 |
| s | \s | 代表空白字符,如' '、' ' |
| 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{Digit} | \p{Digit} | 十进制数字，即0~9 |
| p{Alnum} | \p{Alnum} | 数字或字母字符 |
| p{Punct} | \p{Punct} | 标点符号:!"#$%&'()*+,-./:;<=>?@[]^_`{|}~ |
| p{Graph} | \p{Graph} | 可见字符:[p{Alnum}p{Punct}] |
| p{Print} | \p{Print} | 可打印字符:[p{Graph}x20 |
| p{Blank} | \p{Blank} | 空格或制表符:[ ] |
| p{Cntrl} | \p{Cntrl} | 控制字符:[x00-x1Fx7F] |
说明
在正则表达式中"."代表任何一个字符，因此在正则表达式中如果想使用普通意义的点字符“.”，必须使用转义字符“”。
在正则表达式中可以使用方括号括起若干个字符来表示一个元字符，该元字符可代表方括号中的任何一个字符。
例如，reg = "[abc]4",这样字符串a4、b4、c4都是正则表达式匹配的字符串。
方括号元字符还可以为其他格式。如：
[^456]：代表4、5、6之外的任何字符。
[a-r]：代表a~r中的任何一个字母。
[a-zA-Z]：可表示任意一个英文字母。
[a-e[g-z]]：代表a~e或g~z中的任何一个字母(并运算)。
[a-o&&[def]]：代表字母d、e、f(交运算)。
[a-d&&[^bc]]：代表字母a、d(差运算)。
在正则表达式中允许使用限定修饰符来限定元字符出现的次数。例如：“A*”代表A可在字符串中出现0次或多次。
限定修饰符
| 限 定 修 饰 符 | 意 义 | 示 例 |
| ？ | 0次或1次 | A? |
| * | 0次或多次 | A* |
| + | 一次或多次 | A+ |
| {n} | 正好出现n次 | A{2} |
| {n,} | 至少出现n次 | A{3,} |
| {n,m} | 出现n~m次 | A{2,6} |
示例：在项目中创建类Judge，在主方法中实现使用正则表达式来判断指定的变量是否为合法的E-mail地址。
1 public class Judge {
2 public static void main(String[] args) {
3 // 定义要匹配E_mail地址的正则表达式
4 String regex = "\w+@\w+(\.\w{2,3})*\.\w{2,3}";
5 String str1 = "aaa@"; // 定义要进行验证的字符串
6 String str2 = "aaaaa";
7 String str3 = "1111@111ffyu.dfg.com";
8 if (str1.matches(regex)) { // 判断字符串变量是否与正则表达式匹配
9 System.out.println(str1 + "是一个合法的E-mail地址格式");
10 }
11 if (str2.matches(regex)) {
12 System.out.println(str2 + "是一个合法的E-mail地址格式");
13 }
14 if (str3.matches(regex)) {
15 System.out.println(str3 + "是一个合法的E-mail地址格式");// 1111@111ffyu.dfg.com是一个合法的E-mail地址格式
16 }
17 }
18 }
正则表达式分析：
通常情况下E-mail的格式为“X@X.com.cn”。字符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地址中的结尾字符，如“.com”。
(七)、字符串生成器
创建成功的字符串对象，其长度是固定的，内容不能被改变和编译。虽然使用“+”可以达到附加新字符或字符串的目的，但“+”会产生一个新的String实例，会在内存中创建新的字符串对象。如果重复地对字符串进行修改，将极大的增加系统开销。而J2SE5.0新增了可变的字符序列String-Builder类，大大提高了频繁增加字符串的效率。
示例：在项目中创建类Jerque，在主方法中编写如下代码，验证字符串操作和字符串生成器操作的效率。
1 public class Jerque {
2 public static void main(String[] args) {
3 String str = ""; // 创建空字符串
4 // 定义对字符串执行操作的起始时间
5 long starTime = System.currentTimeMillis();
6 for (int i = 0; i < 10000; i++) { // 利用for循环执行10000次操作
7 str = str + i; // 循环追加字符串
8 }
9 long endTime = System.currentTimeMillis(); // 定义对字符串操作后的时间
10 long time = endTime - starTime; // 计算对字符串执行操作的时间
11 System.out.println("Sting消耗时间：" + time); // Sting消耗时间：307（将执行的时间输出）
12 StringBuilder builder = new StringBuilder(""); // 创建字符串生成器
13 starTime = System.currentTimeMillis(); // 定义操作执行前的时间
14 for (int j = 0; j < 10000; j++) { // 利用for循环进行操作
15 builder.append(j); // 循环追加字符
16 }
17 endTime = System.currentTimeMillis(); // 定义操作后的时间
18 time = endTime - starTime; // 追加操作执行的时间
19 System.out.println("StringBuilder消耗时间：" + time); // StringBuilder消耗时间：1（将操作时间输出）
20 }
21 }
通过这一示例可以看出，两种操作执行的时间差距很大。如果在程序中频繁地附加字符串，建议使用StringBuilder。新创建的StringBuilder对象初始容量是16个字符，可以自行指定初始长度。如果附加的字符超过可容纳的长度，则StringBuilder对象将自动增加长度以容纳被附加的字符。若要使用StringBuilder最后输出字符串的结果，可使用toString()方法。利用StringBuilder类中的方法可动态地执行添加、删除和插入等字符串的编辑操作。该类的常用方法如下。
①、append()方法
该方法用于向字符串生成器中追加内容。通过该方法的多个重载形式，可实现接受任何类型的数据。如int、boolean、char、String、double或者另一个字符串生成器等。
语法如下
append(content)// content表示要追加到字符串生成器中的内容，可以是任何类型的数据或者其他对象。
②、insert(int offset,arg)方法
该方法用于向字符串生成器中的指定位置插入数据内容。通过该方法的不同重载形式，可实现向字符串生成器中插入Int、float、char和boolean等基本数据类型或其他对象。
语法如下
insert(int offset arg)//offset:字符串生成器的位置。该参数必须大于等于0，且小于等于此序列的长度。arg：将插入至字符串生成器的位置。该参数可以是任何的数据类型或其他对象。
示例：向字符串生成器中指定的位置添加字符。
1 StringBuilder bf = new StringBuilder("hello");// 创建字符生成器
2 bf.insert(5,"world") ;// 添加至字符生成器的内容
3 System.out.println(bf.toString());// 此时输出信息为helloworld
③、delete(int start,int end)方法
移除此序列的子字符串中的字符。该子字符串从指定的start处开始，一直到索引end-1处的字符，如果不存在这种字符，则一直到序列尾部。如果start等于end，则不发生任何更改。
语法如下
delete(int start,int end)// start:将要删除的字符串的起点位置。end:将要删除的字符串的终点位置。
示例：删除指定位置的子字符串。
1 StringBuilder bf = new StringBuilder("StringBuilder");// 创建字符串生成器
2 bf.delete(5,10);//删除的子字符串
3 System.out.println(bf.toString());//此时输出的信息为Strinder。
说明
想要了解更多的StringBuilder类方法，可查询java.lang.StringBuilder的API说明。