学习笔记——《Java面向对象程序设计》-常用实用类

参考教材：

Java面向对象程序设计（第3版）微课视频版 清华大学出版社

1、String类

java.lang包中的String类为final类，因此用户不能扩展String类，即String类不能有子类。

（1）构造String对象

String常量：用双引号括起来的字符序列，例如"hello"、"12.97"等。

String对象（变量）

String s;
s = new String("We are Student");
//s中存放着引用，s的实体是字符序列：We are Student

String常量也是对象，Java把用户程序的String常量放入常量池。String常量也有自己的引用和实体。

String s1,s2;
//s1 s2对象的实体相同，都为"student"
s1="student";
s2="student";

public class Test {public static void main(String[] args) {String s;s=new String("student");//显式通过new在堆内存中创建了一个新的String对象//s1 = "student"; 和 s2 = "student"; 是通过字面量赋值。Java会将字符串字面量存储在字符串常量池中。当直接使用字面量时，JVM会从池中复用已有的对象（若存在），因此 s1 和 s2 指向同一个对象，s1 == s2 为 true。   s1和s2具有相同的引用，因此具有相同的实体。String s1,s2;s1="student";s2="student";//== 比较的是对象的引用（内存地址）是否相同System.out.println(s == s1);System.out.println(s2 == s1);System.out.println(s); //等效于s.toString()}
}/*执行结果：falsetruestudent
*/

2、String类常用方法

（1）public boolean equals(String s)

 String对象调用equals(String s)方法，比较当前String对象的字符序列是否与参数s指定的String对象的字符序列相同。

public class Test {public static void main(String[] args) {String tom = new String("We are students");String boy = new String("You are students");String jerry = new String("We are students");System.out.println(tom.equals(boy));System.out.println(tom.equals(jerry));		}
}/*falsetrue
*/

在程序中可以通过“==”和equals()两种方式对字符串进行比较，但这两种方式有明显的区别。equals()方法用于比较两个字符串中的字符序列是否相等；==用于比较两个字符串对象的地址是否相同。

String str1 = new String("abc");
String str2 = new String("abc");
System.out.println(str1 == str2);  // 结果为false，因为str1和str2是两个对象，地址不同
System.out.println(str1.equals(str2)); // 结果为true，因为str1和str2字符序列内容相同

（2）public int indexOf(String s)

String对象调用方法indexOf(String s)，从当前String对象的字符串索引位置0开始检索，并返回首次出现s的字符序列的位置，若没有检索到，则返回值-1。

（3）int lastIndexOf(String str)

返回指定子字符串str在此字符串中最后一次出现位置的索引

（4）int length()

返回此字符串的长度

（5）char charAt(int index)

返回字符串中index位置上的字符，其中index的取值范围是0~(字符串长度-1)

public class Example02 {public static void main(String[] args) {String s = "ababcdedcba"; // 定义字符串s// 获取字符串长度，即字符个数System.out.println("字符串的长度为：" + s.length());System.out.println("字符串中第一个字符:" + s.charAt(0));System.out.println("字符c第一次出现的位置:" + s.indexOf('c'));System.out.println("字符c最后一次出现的位置:" + s.lastIndexOf('c'));System.out.println("子字符串ab第一次出现的位置：" + s.indexOf("ab"));System.out.println("子字符串ab字符串最后一次出现的位置：" + s.lastIndexOf("ab"));}
}/*字符串的长度为：11字符串中第一个字符:a字符c第一次出现的位置:4字符c最后一次出现的位置:8子字符串ab第一次出现的位置：0子字符串ab字符串最后一次出现的位置：2
*/

（6）char[] toCharArray()

将此字符串转换为一个字符数组

（7）static String valueOf(int i)

将int变量i转换成字符串

（8）String toLowerCase()

使用默认语言环境的规则将String中的所有字符都转换为小写

（9）String toUpperCase()

使用默认语言环境的规则将String中的所有字符都转换为大写

public class Example03 {public static void main(String[] args) {String str = "abcd";System.out.print("将字符串转为字符数组后的结果:");char[] charArray = str.toCharArray(); // 字符串转换为字符数组for (int i = 0; i < charArray.length; i++) {if (i != charArray.length - 1) {System.out.print(charArray[i] + ",");} else {			System.out.println(charArray[i]);}}System.out.println("将int值转换为String类型之后的结果:" + String.valueOf(12));System.out.println("将字符串转换成大写之后的结果:" + str.toUpperCase());System.out.println("将字符串转换成小写之后的结果:" + str.toLowerCase());}
}/*将字符串转为字符数组后的结果:a,b,c,d将int值转换为String类型之后的结果:12将字符串转换成大写之后的结果:ABCD将字符串转换成小写之后的结果:abcd
*/

（10）String replace(CharSequence oldstr, CharSequence newstr)

返回一个新的字符串，它是通过用 newstr替换此字符串中出现的所有oldstr得到的

（11）String trim()

返回一个新字符串，去除了原字符串首尾的空格。

trim()方法只能去除两端的空格，不能去除中间的空格。若想去除字符串中间的空格，需要调用String类的replace()方法。

public class Example04 {public static void main(String[] args) {String s = "itcast";// 字符串替换操作System.out.println("将it替换成cn.it的结果:" + s.replace("it", "cn.it"));// 字符串去除空格操作String s1 = "     i t c a s t     ";System.out.println("去除字符串两端空格后的结果:" + s1.trim());System.out.println("去除字符串中所有空格后的结果:" + s1.replace(" ", ""));}
}/*将it替换成cn.it的结果:cn.itcast去除字符串两端空格后的结果:i t c a s t去除字符串中所有空格后的结果:itcast
*/

（12）boolean startsWith(String s)

判断字符串是否以指定的字符串开始

（13）boolean endWith(String s)

判断字符串是否以指定的字符串结束

（14）boolean contains(String s)

判断字符串是否包含指定字符串s

（15）boolean isEmpty()

判断字符串是否为空

public class Example05 {public static void main(String[] args) {String s1 = "String"; String s2 = "Str";System.out.println("判断是否以字符串Str开头:" + s1.startsWith("Str"));System.out.println("判断是否以字符串ng结尾:" + s1.endsWith("ng"));System.out.println("判断是否包含字符串tri:" + s1.contains("tri"));System.out.println("判断字符串是否为空:" + s1.isEmpty());System.out.println("判断两个字符串是否相等" + s1.equals(s2));}
}/*判断是否以字符串Str开头:true判断是否以字符串ng结尾:true判断是否包含字符串tri:true判断字符串是否为空:false判断两个字符串是否相等false
*/

（16）substring()和split()

substring()方法用于截取字符串的一部分，split()方法用于将字符串按照某个字符进行分割。

public class Example06 {public static void main(String[] args) {String str = "石家庄-武汉-哈尔滨";System.out.println("从第5个字符截取到末尾的结果：" + str.substring(4));System.out.println("从第5个字符截取到第6个字符的结果：" + str.substring(4, 6));System.out.print("分割后的字符串数组中的元素依次为:");String[] strArray = str.split("-"); //将字符串转换为字符串数组for (int i = 0; i < strArray.length; i++) {if (i != strArray.length - 1) {System.out.print(strArray[i] + ",");} else {System.out.println(strArray[i]);}}}
}/*从第5个字符截取到末尾的结果：武汉-哈尔滨从第5个字符截取到第6个字符的结果：武汉分割后的字符串数组中的元素依次为:石家庄,武汉,哈尔滨
*/

3、正则表达式与元字符

（1）正则表达式

正则表达式：一个正则表达式是含有一些具有特殊意义字符的字符序列。这些特殊字符称作正则表达式中的元字符。

例如，"\\dhello"中的\\d就是具有特殊意义的元字符，代表0到9中的任何一个。因此，"9hello"、"3hello"都是和正则表达式：\\dhello匹配的字符序列之一。

（2）String对象调用

public boolean matches(String regex)方法可以判断当前String对象的字符序列是否和参数regex指定的正则表达式相匹配。（简称：String对象的字符序列和regex相匹配）

public class Test {public static void main(String[] args) {String regex = "\\dhello";String str = "8hello";System.out.println(str.matches(regex));	//true}
}

（3）元字符

方括号与元字符：在正则表达式中可以用方括号括起若干字符来表示一个元字符，该元字符代表方括号中的任何一个字符。

例如：String regex = "[159]ABC"，那么"1ABC"、"5ABC"和"9ABC"都和regex相匹配。

[abc]：代表a、b、c中的任何一个

[^abc]：代表除了a、b、c以外的任何字符

[a-zA-Z]：代表英文字母中的任何一个

[a-d]：代表a至d中的任何一个

限定符

/*X？  X出现0次或1次X*   X出现0次或多次X+   X出现1次或多次X{n} X恰好出现n次X{n,} X至少出现n次X{n,m} X出现n次至m次XY   X的后缀是YX|Y   X或Y
*/public class Test {public static void main(String[] args) {String regex = "[0-9]?hello";  //0~9中的任何一个数字出现0次或1次System.out.println("8hello".matches(regex)); //true 出现1次System.out.println("hello".matches(regex));  //true 出现0次System.out.println("123hello".matches(regex));  //flaseString regex1 = "[0-9]*hello";//0~9中的任何一个数字出现0次或多次System.out.println("hello".matches(regex1)); //trueSystem.out.println("789120hello".matches(regex1)); //true}
}

（4）常用的正则表达式

/*-?     负号出现一次或零次[1-9]  1~9之间的数字必须出现一次\\d+   任何一次数字出现一次以上
*/
String regex = "-?[1-9]\\d+"; //整数

/*-?     负号出现一次或零次[0-9]  0~9之间的数字必须出现一次[0-9]* 0~9之间的数字出现零次或多次[.]    小数点(也可以写成 \\.)[0-9]+  0~9之间的数字出现一次以上
*/
String regex = "-?[0-9][0-9]*[.][0-9]+" ;   //浮点数

/*\\w+    单词字符：[a-zA-Z_0-9]出现一次以上\\.     小数点(也可以写成[.])[a-z]+   a~z之间的任意字母出现一次以上(\\.[a-z]+)?    （小数点 a~z出现一次以上）出现一次或零次
*/
String regex = "\\w+@\\w+\\.[a-z]+(\\.[a-z]+)?";   //email

/*[1-9]            1~9间的数字出现一次[0-9]{16}        0~9之间的数字恰好出现16次a-zA-Z0-9]{1}    a~z或A~Z或0~9恰好出现一次
*/
String regex = "[1-9][0-9]{16}[a-zA-Z0-9]{1}";   //18位身份证号码

/* year     四位，第一位不能是0month   （0可以不出现，1~9出现一次）或者（1出现一次，0或1或2出现一次）day     （0可以不出现，1~9出现一次）或（1或2出现一次，0~9出现一次）或（3出现一次，0或1至少出现一次）[-./]    -或.或/      
*/
String year = "[1-9][0-9]{3}";
String month = "((0?[1-9])|(1[012]))";
String day = "((0?[1-9])|([12][0-9])|(3[01]?))";
String regex = year+"[-./]"+month+"[-./]"+day;   //日期，不考虑二月份特殊情况

4、字符序列的替换与分解

（1）String replaceAll(String regex, String replacement)

方法返回一个新的String对象，返回对象的字符序列是把当前String对象字符序列中，所有和参数regex相匹配的字符序列都替换成replacement制定的字符序列。

（2）String[] split(String regex)

String对象调用该方法时，使用参数指定的正则表达式regex做为分割标记，分解出String对象的字符序列中的单词，并将分解出的单词放到String数组中。

public class Example08{public static void main(String[] args) {String str = "A1B22DDS34DSJ9D".replaceAll("\\d+","_");System.out.println("字符替换后为："+str);boolean te = "321123as1".matches("\\d+");System.out.println("字符串是否匹配："+te);String s [] ="SDS45d4DD4dDS88D".split("\\d+");System.out.print("字符串拆分后为：");for(int i=0;i<s.length;i++){System.out.print(s[i]+"  ");}}
}/*字符替换后为：A_B_DDS_DSJ_D字符串是否匹配：false字符串拆分后为：SDS  d  DD  dDS  D  
*/

5、StringTokenizer类

java.util包中的StringTokenizer类的对象可分解字符序列。

StringTokenizer对象不使用正则表达式做分隔标记。该类有2个构造方法：

（1）StringTokenizer（String s）：构造一个StringTokeizer对象，比如fenxi。fenxi使用默认的分隔标记（空格符、换行符、回车符、Tab符、进纸符）分解出参数s的字符序列中的单词，即这些单词成为fenxi中的数据。

（2）StringTokenizer(String s, String delim)：构造一个StringTokeizer对象，比如fenxi，fenxi用参数dilim的字符序列中的字符的任意排列作为分隔标记，分解出参数s的字符序列中的单词，即这些单词成为fenxi中的数据。

注意：分隔标记的任意组合仍然是分隔标记。

StringTokenizer类常用方法

（1）String nextToken()

fenxi调用String nextToken()方法逐个获取fenxi中的单词，每当nextToken()返回一个单词（即一个String对象，该String对象的字符序列是单词），fenxi就自动删除该单词。

（2）boolean hasMoreToken()

fenxi调用boolean hasMoreToken()方法可以放回一个boolean值，只要fenxi中还有单词，就返回true，否则返回false。

（3）int countTokens()

fenxi调用countTokens()方法可以返回当前fenxi中单词的个数

public class Example11 {public static void main(String[] args) {String s = "we are stud,ents";//用空格和逗号的任意组合做为分隔标记StringTokenizer fenxi = new StringTokenizer(s," ,");int num = fenxi.countTokens();System.out.println("当前字符串中单词个数为："+num);while(fenxi.hasMoreTokens()){String str = fenxi.nextToken();System.out.println(str);System.out.println("还剩"+fenxi.countTokens()+"个单词");		}System.out.println("s共有单词："+num+"个");}
}/*当前字符串中单词个数为：4we还剩3个单词are还剩2个单词stud还剩1个单词ents还剩0个单词s共有单词：4个
*/

6、Scanner类

使用Scanner类的对象从字符序列中解析程序所需要的数据。例如，String s = "telephone cost 876 dollar.Computer cost 2398.89 dollar.";

Scanner scanner = new Scanner(s);

scanner 默认使用空格做为分隔标记来解析s的字符序列中的单词。也可以让scanner对象调用方法：scanner .useDelimiter(正则表达式)将正则表达式做为分隔标记。

特点如下：

（1）scanner对象调用next()方法依次返回s的字符序列中的单词，如果最后一个单词已经被next()返回，scanner调用hasNext()将返回flase。

（2）对于s的字符序列中的数字型单词，比如876,329.24等，scanner可以用nextInt()或nextDouble()来代替next()方法，即scanner对象可以调用nextInt()或nextDouble()方法将数字型单词转化为int或double数据返回。

（3）若单词不是数字型单词，则不能调用nextInt()或nextDouble()方法，否则会发生InputMismatchException异常。

public class Example12 {public static void main(String[] args) {String cost = "话费清单：市话费76.89元，长途话费167.38元，短信费12.68元。";Scanner scanner = new Scanner(cost);scanner.useDelimiter("[^0123456789.]+");//设置分隔标记double sum = 0;while(scanner.hasNext()){try {double price = scanner.nextDouble();sum = sum + price;System.out.println(price);}catch(InputMismatchException e) {String t = scanner.next();System.out.println(t);}}System.out.println("总费用："+sum+"元"); scanner.close();}
}/*76.89167.3812.68总费用：256.95元
*/

StringTokenizer类和Scanner类的区别

（1）StringTokenizer类把分解出的全部单词都存放到StringTokenizer对象的实体中，因此，StringTokenizer对象能较快速度地获得单词，即StringTokenizer对象的实体占用较多的内存。（多占内存空间提升速度，相当于生活中把单词记忆在大脑中）

（2）Scanner类不把单词存放到Scanner对象中，而是仅仅存放怎样获取单词的分隔标记，因此Scanner对象获得单词的速度较慢，但Scanner对象节省内存空间（减慢速度节省内存空间，相当于生活中把单词放到字典里，大脑只记忆查字典的规则）

（3）如果字符序列存放在磁盘中，并且形成的文件比较大，那么用Scanner对象分解字符序列中的单词就可以节省内存。

7、Pattern类和Matcher类（java.util.regex包）

Match类的对象直接检索出和Pattern类的对象匹配的String对象，因此，在某些应用中，Match和Pattern类更容易解决某些检索问题。

常用方法

(1)boolean find()

matcher依次调用该方法，检索input的字符序列中和regex匹配的子字符序列

(2)int start()、end()

检索匹配到的初始位置和结束位置

(3)String group()

返回String对象，其中的字符序列为input中满足regex的子字符序列、

public class Test {public static void main(String[] args) {String input = "悟空的电子邮箱是[e-mail]，八戒的email是[e-mail]";//使用正则表达式regex做参数得到一个称为模式的Pattern类的实例patternString regex = "\\w+@\\w+\\.[a-z]+(\\.[a-z]+)?";Pattern pattern = Pattern.compile(regex); //封装正则表达式//得到可用于检索input的Matcher类的实例matcher(称为匹配对象)Matcher matcher = pattern.matcher(input);while(matcher.find()) {int startN = matcher.start();int endN = matcher.end();String str = matcher.group();System.out.printf("%d,%d:%s\n",startN,endN,str);}}
}/*8,25:[e-mail]35,52:[e-mail]
*/

import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Example10 {public static void main(String[] args) {Pattern p=Pattern.compile("\\d+");Matcher m=p.matcher("22bb23");System.out.println("字符串是否匹配:"+ m.matches());  Matcher m2=p.matcher("2223");System.out.println("字符串是否匹配:"+ m2.matches());System.out.println("对前面的字符串匹配结果为"+ m.lookingAt());Matcher m3=p.matcher("aa2223");System.out.println("对前面的字符串匹配结果为:"+m3.lookingAt());m.find();//返回trueSystem.out.println("字符串任何位置是否匹配:"+ m.find());m3.find();//返回trueSystem.out.println("字符串任何位置是否匹配:"+ m3.find());Matcher m4=p.matcher("aabb");System.out.println("字符串任何位置是否匹配:"+ m4.find());Matcher m1=p.matcher("aaa2223bb");m1.find();//匹配2223System.out.println("上一个匹配的起始索引::"+  m1.start());System.out.println("最后一个字符匹配后的偏移量"+  m1.end());System.out.println("匹配到的子字符串:"+  m1.group());}
}/*字符串是否匹配:false字符串是否匹配:true对前面的字符串匹配结果为true对前面的字符串匹配结果为:false字符串任何位置是否匹配:false字符串任何位置是否匹配:false字符串任何位置是否匹配:false上一个匹配的起始索引::3最后一个字符匹配后的偏移量7匹配到的子字符串:2223
*/

8、StringBuffer类

前面学习的String类是final类，而且String类不提供修改字符序列的方法，即String对象不能修改、删除或替换字符序列中的某个字符。String对象一旦创建，那么实体不会再发生变化，称这样的对象为“不可变对象”。

StringBuffer类对象的实体内存空间可以自动的改变大小，便于存放一个可变的字符序列。

如StringBuffer buffer = new StringBuffer ("我喜欢学习");

buffer.append("数学");

StringBuffer类常用方法

（1）StringBuffer insert(int index,String str)

将参数str指定的字符序列插入到参数index指定的位置，并返回当前对象的引用

（2）StringBuffer reverse()

reverse()方法将该对象实体中的字符翻转，并返回当前对象的引用。

（3）StringBuffer delete(int startIndex,int endIndex)

删除StringBuffer对象中指定范围的字符或字符串序列

（4）StringBuffer replace(int startIndex,int endIndex,String str)

将当前StringBuffer 对象的startIndex到endIndex-1的字符序列替换成参数str指定的字符序列，并返回当前StringBuffer 对象的引用。

（5）void setCharAt(int index, char ch)

修改指定位置index处的字符序列

public class Example01 {public static void main(String[] args) {System.out.println("1、添加------------------------");add();System.out.println("2、删除------------------------");remove();System.out.println("3、修改------------------------");alter();}public static void add() {StringBuffer sb = new StringBuffer(); // 定义一个字符串缓冲区sb.append("abcdefg"); // 在末尾添加字符串System.out.println("append添加结果：" + sb);sb.insert(2, "123"); // 在指定位置插入字符串System.out.println("insert添加结果：" + sb);}public static void remove() {StringBuffer sb = new StringBuffer("abcdefg");sb.delete(1, 5); // 指定范围删除System.out.println("删除指定位置结果：" + sb);sb.deleteCharAt(2); // 指定位置删除System.out.println("删除指定位置结果：" + sb);sb.delete(0, sb.length()); // 清空缓冲区System.out.println("清空缓冲区结果：" + sb);}public static void alter() {StringBuffer sb = new StringBuffer("abcdef");sb.setCharAt(1, 'p'); // 修改指定位置字符System.out.println("修改指定位置字符结果：" + sb);sb.replace(1, 3, "qq"); // 替换指定位置字符串或字符System.out.println("替换指定位置字符（串）结果：" + sb);System.out.println("字符串翻转结果：" + sb.reverse());}
}/*1、添加------------------------append添加结果：abcdefginsert添加结果：ab123cdefg2、删除------------------------删除指定位置结果：afg删除指定位置结果：af清空缓冲区结果：3、修改------------------------修改指定位置字符结果：apcdef替换指定位置字符（串）结果：aqqdef字符串翻转结果：fedqqa
*/

9、StringBiuld类

StringBuilder类也可以对字符串进行修改，StringBuffer类和StringBuilder类的对象都可以被多次修改，并不产生新的未使用对象，StringBuilder类是JDK5中新加的类，它与StringBuffer之间最大不同在于StringBuilder的方法是线程安全的，也就是说StringBuffer不能被同步访问，而StringBuilder可以。

StringBuilder类和StringBuffer类、String类有很多相似之处，初学者在使用时很容易混淆。简单归纳一下三者的不同。

（1）String类表示的字符串是常量，一旦创建后，内容和长度都是无法改变的。而StringBuilder和StringBuffer表示字符容器，其内容和长度可以随时修改。在操作字符串时，如果该字符串仅用于表示数据类型，则使用String类即可，但是如果需要对字符串中的字符进行增删操作，则使用StringBuffer与StringBuilder类。如果有大量字符串拼接操作，不要求线程安全的情况下，采用StringBuilder更高效。相反如果需要线程安全则需要使用StringBuffer。

（2）对于euals()方法的使用我们已经有所了解，但是在StringBuffer类与StringBuilder类中并没有被Object类的equals()方法覆盖，也就是说，equals()方法对于StringBuffer类与StringBuilder类来言并不起作用。

（3）String类对象可以用操作符“+”进行连接，而StringBuffer类对象之间不能。

public class Example12_2{private static final int TIMES = 100000;public static void main(String[] args) {Example12_2.testString();Example12_2.testStringBuffer();Example12_2.testStringBuilder();}//String时间效率测试public static void testString() {long startTime = System.currentTimeMillis();String str = "";for (int i = 0; i < TIMES; i++) {str += "test";}long endTime = System.currentTimeMillis();System.out.println("String test usedtime: " + (endTime - startTime));}//StringBuffer时间效率测试（线程安全）public static void testStringBuffer() {long startTime = System.currentTimeMillis();StringBuffer str = new StringBuffer();for (int i = 0; i < TIMES; i++) {str.append("test");}long endTime = System.currentTimeMillis();System.out.println("StringBuffer test usedtime:  " + (endTime-startTime));}//StringBuffer时间效率测试（非线程安全）public static void testStringBuilder() {long startTime = System.currentTimeMillis();StringBuilder str = new StringBuilder();for (int i = 0; i < TIMES; i++) {str.append("test");}long endTime = System.currentTimeMillis();System.out.println("StringBuilder test usedtime: " + (endTime-startTime));}
}/*String test usedtime: 12726StringBuffer test usedtime:  5StringBuilder test usedtime: 2
*/

10、日期与时间

Java SE 8开始，提供java.time包，该包中有专门处理日期和时间的类，而早起的java.util包中的Data类成为过期的API。

LocalData，LocalDataTime和LocalTime类的对象封装了和日期、时间有关的数据（如年月日、时分秒、纳秒和星期等），这三个类都是final类，而且不提供修改数据的方法，即这些类的对象的实体是不可再发生变换，属于不可变对象（和String类似）

（1）LocalData类

LocalData类仅用来表示日期。通常表示的是年份和月份，该类不能代表时间线上的即时信息,只是日期的描述。在LocalData类中提供了两个获取日期对象的方法now()和of(int year, int month, int dayOfMonth)

LocalData还提供了日期格式化、增减年月日等一系列的常用方法。

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;public class Example12_3 {public static void main(String[] args) {//获取日期时分秒LocalDate now = LocalDate.now();System.out.println("LocalData的获取及格式化的相关方法--------");//getYear()获取年份字段System.out.println("从LocalData实例获取的年份为："+now.getYear());//getMonthValue()获取月份字段的值System.out.println("从LocalData实例获取的月份："+now.getMonthValue());//getDayOfMonth()获取当月第几天System.out.println("从LocalData实例获取当天在本月的第几天："+now.getDayOfMonth());//format()使用指定的格式化程序格式化此日期System.out.println("将获取到的Loacaldata实例格式化为："+now.format(DateTimeFormatter.ofPattern("yyyy年MM月dd日")));System.out.println("LocalData判断的相关方法----------------");LocalDate of = LocalDate.of(2025, 5, 2);System.out.println("判断日期of是否在now之前："+of.isBefore(now));System.out.println("判断日期of是否在now之后："+of.isAfter(now));System.out.println("判断日期of和now是否相等："+now.equals(of));System.out.println("判断日期of是否时闰年："+ of.isLeapYear());System.out.println("LocalData解析以及加减操作的相关方法---------");String dateStr="2020-02-01";System.out.println("把日期字符串解析成日期对象后为"+LocalDate.parse(dateStr));System.out.println("将LocalData实例年份加1为："+now.plusYears(1));System.out.println("将LocalData实例天数减10为："+now.minusDays(10));System.out.println("将LocalData实例指定年份为2014："+now.withYear(2014));}
}/*LocalData的获取及格式化的相关方法--------从LocalData实例获取的年份为：2025从LocalData实例获取的月份：4从LocalData实例获取当天在本月的第几天：30将获取到的Loacaldata实例格式化为：2025年04月30日LocalData判断的相关方法----------------判断日期of是否在now之前：false判断日期of是否在now之后：true判断日期of和now是否相等：false判断日期of是否时闰年：falseLocalData解析以及加减操作的相关方法---------把日期字符串解析成日期对象后为2020-02-01将LocalData实例年份加1为：2026-04-30将LocalData实例天数减10为：2025-04-20将LocalData实例指定年份为2014：2014-04-30
*/

（2）LocalTime类与LocalDataTime类

LocalTime类用来表示时间，通常表示的是小时分钟秒。与LocalData类一样，该类不能代表时间线上的即时信息，只是时间的描述。在LocalTime类中提供了获取时间对象的方法，与LocalData用法类似。 同时LocalTime类也提供了与日期类相对应的时间格式化、增减时分秒等常用方法，这些方法与日期类相对应。

public class Example12_4 {public static void main(String[] args) {LocalTime time = LocalTime.now();LocalTime of = LocalTime.of(9,23,23);System.out.println("从LocalTime获取的小时为："+time.getHour());System.out.println("将获取到的LoacalTime实例格式化为："+time.format(DateTimeFormatter.ofPattern(" HH:mm:ss")));System.out.println("判断时间of是否在now之前："+of.isBefore(time));System.out.println("将时间字符串解析为时间对象后为："+ LocalTime.parse("12:15:30"));System.out.println("从LocalTime获取当前时间，不包含毫秒数："+time.withNano(0));}
}/*从LocalTime获取的小时为：9将获取到的LoacalTime实例格式化为： 09:43:09判断时间of是否在now之前：true将时间字符串解析为时间对象后为：12:15:30从LocalTime获取当前时间，不包含毫秒数：09:43:09
*/

LocalDataTime类是LocalData类与LocalTime类的综合，它即包含日期也包含时间。LocalDataTime类中的方法包含了LocalData类与LocalTime类的方法。

LocalDateTime默认的格式是 2020-02-29T21:23:26.774，经常和DateTimeFormatter一起使用指定格式，除了LocalData与LocalTime类中的方法，额外提供了转换的方法。

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;public class Example12_5 {public static void main(String[] args) {//获取当前年月日，时分秒LocalDateTime now = LocalDateTime.now();System.out.println("获取的当前日期时间为："+now);System.out.println("将目标LocalDateTime转换为相应的LocalDate实例:"+ now.toLocalDate());System.out.println("将目标LocalDateTime转换为相应的LocalTime实例:"+ now.toLocalTime());//指定格式DateTimeFormatter ofPattern = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH时mm分ss秒");System.out.println("格式化后的日期时间为："+now.format(ofPattern));}
}/*获取的当前日期时间为：2025-04-30T09:46:34.854将目标LocalDateTime转换为相应的LocalDate实例:2025-04-30将目标LocalDateTime转换为相应的LocalTime实例:09:46:34.854格式化后的日期时间为：2025年04月30日 09时46分34秒
*/

11、Math类、Biginteger类、Random类

（1）Math类提供了很多静态方法，如计算一个数的平方根、绝对值、获取一个随机数等等。java.lang包中的Math类包含许多用来进行科学计算的类方法，这些方法可以直接通过类名调用。

（2）处理任意大的整数，java.math包中的BigInteger类提供任意精度的整数运算。

（3）Java的java.util包中有一个Random类，它可以在指定的取值范围内随机产生数字。Random类中提供了两个构造方法。

Random()：构造方法，用于创建一个伪随机数生成器。用当前计算机的时间做种子。

Random(long seed)：构造方法，使用一个long型的seed参数种子创建伪随机数生成器。

import java.util.Random;public class Example12_6 {public static void main(String[] args) {Random r = new Random();//当前计算机的时间做种子int x = r.nextInt();//返回一个整数System.out.println(x);//若想返回一个[0,m)的随机数，可调用nextInt(m)方法，参数m必须为正整数值x = r.nextInt(100);System.out.println(x);//注意：对于具有相同种子的两个Random对象，二者依次调用nextInt()方法获取的随机数序列相同}	
}/*-191817004517
*/