Java基础学习——复习第五天--异常处理、常用类、集合类

最新推荐文章于 2024-12-25 11:36:04 发布

婧中横卧听雨声

最新推荐文章于 2024-12-25 11:36:04 发布

阅读量448

点赞数

分类专栏：学习复习文章标签： java

本文链接：https://blog.youkuaiyun.com/qq_35428214/article/details/80933350

版权

学习复习专栏收录该内容

6 篇文章

订阅专栏

7.异常处理

（1）异常的概述--在程序中往往会出现错误，这些错误的产生是程序员没有料到的或者是超出了程序员可控范围的环境因素，在java中把这些可能会出现的错误统称为异常。java语言的异常处理机制优势之一就是可以将异常情况在方法调用中进行传递，通过传递可以将已成情况传递到合适的位置进行处理

（2）异常的分类--java类库中每个包都定义了异常类，这些类都是Throwable类的子类，Throwable类派生了两个子类—Error和Exception类，

2.1Error类--Error类及其子类用来描述Java运行系统分钟的内部错误以及资源耗尽的错误，一般都比较严重。程序发生Error错误时程序通常都会停止运行

2.2Exception异常主要分为运行时异常与非运行时异常，程序中应当尽可能的处理这些异常

2.2.1运行时异常--运行时异常是程序运行过程中产生的异常，它是RuntimeException类及其子类异常

常见运行时异常
异常类	说明
ClassCastException	类型转化异常
NullPointerException	空指针异常
ArrayIndexOutOfBoundsException	数组下标越界异常
ArithmeticException	算数异常
ArrayStoreException	数组中包含不兼容的值抛出的异常
NumberFormatException	字符串转化为数字抛出异常
IllegalArgumentException	非法参数异常
FileSystemNotFoundException	文件系统为找到异常
SecurityException	安全性异常
StringIndexOutOfBoundsException	字符串索引超出范围抛出异常
NegativeArraySizeException	数组长度为负异常

2.2.2非运行时异常--是RuntimeException类及其子类异常以外的异常

常见非运行异常
异常类	说明
ClassNotFoundException	未找到相应类异常
SQLException	操作数据库异常
IOException	输入输出流异常
TimeoutException	操作超时异常
FileNotFoundException	文件未找到异常

（3）捕捉处理异常

3.1try…catch代码块--主要用来对异常进行捕捉并处理

3.2finally代码块--可选代码块，主要是放置一些释放资源、关闭对象的代码

在catch代码块中使用Exception对象输出相关异常信息，常用如下

1）getMessage（）方法：获取有关异常事件的信息

2）toString（）方法：获取异常的类型与性质

3）printStackTrace（）方法：获取异常事件发生时执行堆栈的内容

代码实现

public classTake {

publicstatic void main(String[] args) {

//TODO 自动生成的方法存根

try{

Stringstr="lili";

System.out.println(str+"年龄是：");

intage = Integer.parseInt("20L");

System.out.println(age);

}catch(Exceptione){

e.printStackTrace();

}finally{

System.out.println("programover");

}

结果

lili年龄是：

java.lang.NumberFormatException: For input string: "20L"

atjava.base/java.lang.NumberFormatException.forInputString(Unknown Source)

atjava.base/java.lang.Integer.parseInt(Unknown Source)

at异常处理.Take.main(Take.java:10) program over

在以下情况中，finally块不会被运行

1）在finally代码块中发生异常

2）在前面的代码块中使用了System.exit()退出程序

3）程序所在的线程死亡

（4）在方法中抛出异常

4.1使用throws关键字抛出异常--被应用在声明方法时，用来指定方法可能抛出的异常，多个异常可使用逗号分隔

语法：返回值类型方法名（参数表） throws 异常类型名{

//方法体

}

代码实现

public classShoot {

staticvoid pop()throws NegativeArraySizeException{

int[]arr=newint[-3];

}

publicstatic void main(String[]args) {

try{

pop();

}catch(NegativeArraySizeExceptione){

System.out.println("pop()方法抛出的异常");

}

结果：pop()方法抛出的异常

4.2使用throw关键字抛出异常--通常用于方法体中‘制造’出一个异常，程序执行到throw与局势会立即终止，他后面的语句都不执行。

代码实现：

public class ThrowTest {

publicstatic void main(String[] args) {

//TODO 自动生成的方法存根

intnum1=25;

intnum2=0;

intresult;

if(num2==0){

thrownew ArithmeticException("小学森都会");

}

result=num1/num2;

System.out.println("两个数的商为："+result);

}

结果：

Exception in thread "main" java.lang.ArithmeticException:小学森都会

at异常处理.ThrowTest.main(ThrowTest.java:11)

（5）自定义异常--用来处理java内置异常类无法处理的异常

自定义异常类的步骤：

1）创建自定义异常类

2）在方法中通过throw关键字抛出异常

3）如果在当前抛出异常的方法中处理异常、可以使用try…catch代码块捕获并处理，否则，在方法的声明处通过throws关键字指明要抛给方法调用者的异常，继续下一步操作

4）在出现异常方法的调用者中捕获并处理异常

代码实现

public classMyException extends Exception {

publicMyException(String ErrorMessage) {

super(ErrorMessage);

}

public classTran {

staticvoid avg(int age) throws MyException{

if(age<0){

thrownew MyException("年龄不能为负数");

}else{

System.out.println("王师傅今年"+age+"岁了！");

}

publicstatic void main(String[] args) {

//TODO 自动生成的方法存根

try{

avg(-50);

}catch(MyExceptione){

e.printStackTrace();

}

结果 :异常处理.MyException:年龄不能为负数

at异常处理.Tran.avg(Tran.java:6)

at异常处理.Tran.main(Tran.java:14)

8.Java中的常用类

（1）包装类

包装类及其对应的基本数据类型
包装类	对应数据类型	包装类	对应数据类型
Byte	byte	Short	Short
Integer	int	Long	Long
Float	Float	Double	Double
Character	char	Boolean	boolean

1.1Integer类--与Byte类、Short类和Long类用法差不多

1）构造方法

1.Integer（int number）-该方法以一个int型变量作为参数来获取Integer对象。Integer number=new Integer（7）；

2.Integer（String str）-该方法以一个String型变量作为参数来获取Integer对象。Integer number=new Integer（“45”）；

2）常用方法

Integer类常用方法
方法	返回值	功能描述
valueOf（String str）	Integer	返回保存指定的String值得Integer对象
parseInt（String str）	int	返回包含在由str指定的字符串中的数字的等价整数值
toString（）	String	返回一个表示该Integer值的String对象（可以指定进制基数）
toBinaryString（int i）	String	以二进制无符号整数型是返回一个整数参数的字符串表示形式
toHexString（int i）	String	以十六进制无符号整数型是返回一个整数参数的字符串表示形式
toOctalString（int i）	String	以八进制无符号整数型是返回一个整数参数的字符串表示形式
equals（Object IntegerObj）	boolean	比较此对象与指定对象是否相等
intValue（）	int	以int型返回Integer的值
shortValue（）	short	以short型返回Integer的值
byteValue（）	byte	以byte型返回Integer的值
compareTo（Integer anotherInteger）	int	在数字上比较两个Integer对象，如果这两个值相等，则返回0；如果调用对象的数值小于anotherInteger的数值，则返回负值；如果调用对象的数值大于anotherInteger的数值，则返回正值

代码实现

public classDemo {

publicstatic void main(String[] args) {

intnum = Integer.parseInt("456");// 将字符串转换为int类型

IntegeriNum = Integer.valueOf("456");// 通过构造函数创建一个Integer对象

System.out.println("int数据与Integer对象的比较："+ iNum.equals(num));

Stringstr2 = Integer.toBinaryString(num);// 获取数字的二进制表示

Stringstr3 = Integer.toHexString(num);// 获取数字的十六进制表示

Stringstr4 = Integer.toOctalString(num);// 获取数字的八进制表示

Stringstr5 = Integer.toString(num, 15);// 获取数字的十五进制表示

System.out.println("456的二进制表示为："+ str2);

System.out.println("456的十六进制表示为："+ str3);

System.out.println("456的八进制表示为："+ str4);

System.out.println("456的十五进制表示为："+ str5);

}

结果

int数据与Integer对象的比较：true

456的二进制表示为：111001000

456的十六进制表示为：1c8

456的八进制表示为：710

456的十五进制表示为：206

3）常量

1.MAX_VALUE:表示int类型可取的最大值，即231-1；

2.MIN_VALUE:表示int类型可取的最小值，即-231;

3.SIZE:用来以二进制补码的形式表示int值的位数；

4.TYPE:表示基本类型int的Class实例；

代码实现：

public classGetCon { // 创建类GetCon

public static void main(String args[]) { // 主方法

int maxint = Integer.MAX_VALUE; // 获取Integer类的常量值

int minint = Integer.MIN_VALUE;

int intsize = Integer.SIZE;

System.out.println("int类型可取的最大值是："+ maxint); // 将常量值输出

System.out.println("int类型可取的最小值是："+ minint);

System.out.println("int类型的二进制位数是："+ intsize);

}

结果：

int类型可取的最大值是：2147483647

int类型可取的最小值是：-2147483648

int类型的二进制位数是：32

1.2Double类--与Float类用法相似

1）构造方法

1.Double（double number）-该方法基于double参数创建Double类对象。Double number=new Double（3.14）；

2Double（String str）-该方法以一个String型变量作为参数来获取Double对象。Double number=new Double("3.14")；

2）常用方法

Double类常用方法
方法	返回值	功能描述
valueOf(String str)	Double	返回保存用参数字符串str表示的double值的Double对象
parseDouble（String s）	double	返回一个新的double值，该值被初始化为用指定String表示的值，这与Double类的valueOf方法一样
doubleValue（）	double	以double形式返回此Double对象
isNaN（）	boolean	如果此double值是非数字（NaN）值，则返回true；否则返回false。
IntValue（）	int	以int形式返回double值
byteValue（）	byte	以byte形式返回double值（通过强制转换）
longValue（）	long	以long形式返回double值（通过强制转换）·
compareTo（Double d）	int	在数字上比较两个Double对象，如果这两个值相等，则返回0；如果调用对象的数值小于d的数值，则返回负值；如果调用对象的数值大于d的数值，则返回正值
equals（Object Obj）	boolean	比较此对象与指定对象是否相等
toString（）	String	返回此Double对象的字符串表示形式
toHexString（double d）	String	返回double参数的十六进制字符串表示形式

代码实现

public classuseDouble {

publicstatic void main(String[] args) {

DoubledNum = Double.valueOf("3.14"); // 通过构造函数创建一个Integer对象

System.out.println("3.14是否为非数字值："+ Double.isNaN(dNum.doubleValue()));// 判断是否为非数字值

System.out.println("3.14转换为int值为：" + dNum.intValue());//转换为int类型

System.out.println("值为3.14的Double对象与3.14的比较结果："+ dNum.equals(3.14));// 判断大小

System.out.println("3.14的十六进制表示为："+ Double.toHexString(dNum));// 转换为十六进制

}

结果

3.14是否为非数字值：false

3.14转换为int值为：3

值为3.14的Double对象与3.14的比较结果：true

3.14的十六进制表示为：0x1.91eb851eb851fp1

3）常量

1.MAX_EXPONENT:返回int值，表示有限double变量可能具有的最大指数。

2.MIN_ EXPONENT:返回int值，表示有限double变量可能具有的最小指数。

3.NEGATIVE_INFINITY:返回double值，表示保存double类型的负无穷大值的常量。

4.POSITIVE_ INFINITY:返回double值，表示保存double类型的正无穷大值的常量。

1.3Boolean类

1）构造方法

1.Boolean（boolean value）-该方法创建一个表示value参数来获取Boolean对象。Boolean br=new Boolean（true）；

2.Boolean（String str）-该方法以String型变量作为参数创建Boolean对象。如果String参数不为null且在忽略大小写时等于true，则分配一个表示true值的Boolean对象，否则获得一个false值的Boolean对象。Boolean bool=new Boolean（“ok”）；

2）常用方法

Boolean类的常用方法
方法	返回值	功能描述
booleanValue（）	boolean	将Boolean对象的值以对应的boolean值返回
equals（Object obj）	boolean	判断调用该方法的对象与obj是否相等。当且仅当参数不是null，而且与调用该方法的对象一样都表示同一个boolean值的Boolean对象时，才返回true
parseBoolean（String s）	boolean	将字符串参数解析为boolean值
toString（）	String	返回表示该boolean值的String对象
valueOf()	boolean	返回一个用指定的字符串表示值的boolean值

代码实现：

public classGetBoolean {

publicstatic void main(String args[]) { // 主方法

Booleanb1 = new Boolean(true); // 创建Boolean对象

Booleanb2 = new Boolean("ok"); // 创建Boolean对象

System.out.println("b1：" + b1.booleanValue());

System.out.println("b2：" + b2.booleanValue());

}

结果

b1：true

b2：false

3）常量

1.TRUE:对应基值true的Boolean对象。

2.FALSE：对应基值false的Boolean对象。

3.TYPE:基本类型boolean的Class对象。

1.4Character类

1）构造方法

Character（char value）

2）常用方法

Character类常用方法
方法	返回值	功能描述
compareTo（Character anotherCharacter）	int	根据数字比较两个Character对象，若这个对象相等则返回（）
equals（Object obj）	Boolean	将调用该方法的对象与指定对象相比较
toUpperCase（char ch）	char	将字符参数转化为大写
toLowerCase（char ch）	char	将字符参数转化为小写
toString（）	String	返回一个表示指定char值的String对象
charValue（）	char	返回此Character对象的值
isUpperCase（char ch）	Boolean	判定指定字符是否是大写字符
isLowerCase（char ch）	Boolean	判定指定字符是否是小写字符
isLetter（char ch）	Boolean	判定指定字符是否是为字母
isDigit（char ch）	Boolean	判定指定字符是否是否为数字

代码实现：

public classUpperOrLower {

publicstatic void main(String args[]) { // 主方法

Charactermychar1 = new Character('A'); // 声明Character对象

Charactermychar2 = new Character('a'); // 声明Character对象

if(Character.isUpperCase(mychar1)) {// 判断是否为大写字母

System.out.println(mychar1+ "是大写字母 ");

System.out.println("转换为小写字母的结果：" + Character.toLowerCase(mychar1));// 转换为小写

}

if(Character.isLowerCase(mychar2)) {// 判断是否为小写字母

System.out.println(mychar2+ "是小写字母");

System.out.println("转换为大写字母的结果：" + Character.toUpperCase(mychar2));// 转换为大写

}

结果：

A是大写字母

转换为小写字母的结果： a

a是小写字母

转换为大写字母的结果： A

3）常量

1.CONNECTOR_PUNCT:返回byte型值，表示Unicode规范中的常规类别“Pc”

2.UNASSIGNED:返回byte值，表示Unicode规范中的常规类别“Cn”

3.TITLECASE_LETTER:返回byte值，表示Unicode规范中的常规类别“Lt”

1.5Number类--所有数值型包装类的父类

数值型包装类的共有方法
方法	返回值	功能描述
byteValue（）	byte	以byte形式返回值指定的数值
intValue（）	int	以int形式返回值指定的数值
floatValue（）	float	以float形式返回值指定的数值
shortValue（）	short	以short形式返回值指定的数值
longValue（）	long	以long形式返回值指定的数值
doubleValue（）	double	以double形式返回值指定的数值

（2）Math类

2.1Math类概述

Math类表示数学类，提供了众多的数学函数方法，另还提供一些数学常量。

2.2常用数字运算方法

1）三角函数方法

Math类中的三角函数方法
方法	返回值	功能描述
sin（double a）	double	返回角的三角正弦
cos（double a）	double	返回角的三角余弦
tan（double a）	double	返回角的三角正切
asin（double a）	double	返回一个值的反正弦
acos（double a）	double	返回一个值的反余弦
atan（double a）	double	返回一个值的反正切
toRadians（double angdeg）	double	将角度转化为弧度
toDegrees（double angdeg）	double	将弧度转化为角度

代码实现

public classTrigonometricFunction {

publicstatic void main(String[] args) {

//取90度的正弦

System.out.println("90度的正弦值："+ Math.sin(Math.PI / 2));

System.out.println("0度的余弦值："+ Math.cos(0)); // 取0度的余弦

//取60度的正切

System.out.println("60度的正切值："+ Math.tan(Math.PI / 3));

//取2的平方根与2商的反正弦

System.out.println("2的平方根与2商的反弦值："

+Math.asin(Math.sqrt(2) / 2));

//取2的平方根与2商的反余弦

System.out.println("2的平方根与2商的反余弦值："

+Math.acos(Math.sqrt(2) / 2));

System.out.println("1的反正切值："+ Math.atan(1)); // 取1的反正切

//取120度的弧度值

System.out.println("120度的弧度值："+ Math.toRadians(120.0));

//取π/2的角度

System.out.println("π/2的角度值：" +Math.toDegrees(Math.PI / 2));

}

结果：

90度的正弦值：1.0

0度的余弦值：1.0

60度的正切值：1.7320508075688767

2的平方根与2商的反弦值：0.7853981633974484

2的平方根与2商的反余弦值：0.7853981633974483

1的反正切值：0.7853981633974483

120度的弧度值：2.0943951023931953

π/2的角度值：90.0

2）指数函数方法

Math类中的与指数函数相关的方法
方法	返回值	功能描述
exp（double a）	double	用于获取e的a次方，即取e^a
double log（double a）	double	用于去自然对数，即取lna的值
double log10（double a）	double	用于取底数为10的对数
sqrt（double a）	double	用于取a的平方根，其中a的值不能为负值
cbrt（double a）	double	用于取a的立方根
pow（double a，double b）	double	用于取a的b次方

代码实现：

public classExponentFunction {

publicstatic void main(String[] args) {

System.out.println("e的平方值：" +Math.exp(2)); // 取e的2次方

//取以e为底2的对数

System.out.println("以e为底2的对数值：" +Math.log(2));

//取以10为底2的对数

System.out.println("以10为底2的对数值：" +Math.log10(2));

System.out.println("4的平方根值："+ Math.sqrt(4)); // 取4的平方根

System.out.println("8的立方根值："+ Math.cbrt(8)); // 取8的立方根

System.out.println("2的2次方值：" +Math.pow(2, 2)); // 取2的2次方

}

结果

e的平方值：7.38905609893065

以e为底2的对数值：0.6931471805599453

以10为底2的对数值：0.3010299956639812

4的平方根值：2.0

8的立方根值：2.0

2的2次方值：4.0

3)取整函数方法

使用ceil()方法取整：6.0
使用floor()方法取整：2.0
使用rint()方法取整：3.0
使用rint()方法取整：2.0
使用round()方法取整：3
使用round()方法取整：3

4）取最大值、最小值、绝对值函数方法

Math其他的常用数据操作方法
方法	返回值	功能描述
max（double a，double b）	double	取a与b之间的最大值
min（int a，int b）	int	取a与b之间的最小值，参数为整型
min（long a，long b）	long	取a与b之间的最小值，参数为长整型
min（float a，float b）	float	取a与b之间的最小值，参数为浮点型
min（double a，double b）	double	取a与b之间的最小值，参数为双精度型
abs（int a）	int	返回整数参数的绝对值
abs（long a）	long	返回长整数参数的绝对值
abs（float a）	float	返回浮点型参数的绝对值
abs（double a）	double	返回双精度型参数的绝对值

代码实现：

public classAnyFunction {

publicstatic void main(String[] args) {

System.out.println("4和8较大者:" +Math.max(4, 8));

// 取两个参数的最小值

System.out.println("4.4和4较小者：" +Math.min(4.4, 4));

System.out.println("-7的绝对值：" +Math.abs(-7)); // 取参数的绝对值

}

结果：

4和8较大者:8

4.4和4较小者：4.0

-7的绝对值：7

（3）随机数

3.1Math.random（）方法--Math.random（）方法只能生成大于等于0.0小于1.0的double型随机数。但对于Math.random（）语句稍加处理，就可以生成任意范围的随机数：m+（int）（Math.random（）*n）；用于生成返回大于等于m小于吗m+n（不包括）的随机数

代码实现

importjava.util.Scanner;

public classNumGame {

publicstatic void main(String[] args) {

System.out.println("——————猜数字游戏——————\n");

intiNum;

intiGuess;

Scannerin = new Scanner(System.in);// 创建扫描器对象，用于输入

iNum= (int) (Math.random() * 100);// 生成1到100之间的随机数

System.out.print("请输入你猜的数字：");

iGuess= in.nextInt(); // 输入首次猜测的数字

while((iGuess != -1) && (iGuess != iNum))// 判断输入的数字不是-1或者基准数

{

if(iGuess < iNum)// 若猜测的数字小于基准数，则提示用户输入的数太小，并让用户重新输入

{

System.out.print("太小，请重新输入：");

iGuess= in.nextInt();

}else// 若猜测的数字大于基准数，则提示用户输入的数太大，并让用户重新输入

{

System.out.print("太大，请重新输入：");

iGuess= in.nextInt();

}

if(iGuess == -1)// 若最后一次输入的数字是-1，循环结束的原因是用户选择退出游戏

{

System.out.println("退出游戏！");

}else// 若最后一次输入的数字不是-1，用户猜对数字，获得成功，游戏结束

{

System.out.println("恭喜你，你赢了，猜中的数字是：" + iNum);

}

System.out.println("\n———————游戏结束———————");

}

结果：

——————猜数字游戏——————

请输入你猜的数字：50

太小，请重新输入：80

太小，请重新输入：90

太小，请重新输入：95

太大，请重新输入：93

太小，请重新输入：94

恭喜你，你赢了，猜中的数字是：94

———————游戏结束———————

Math.random（）方法还可以生成字符随机数：

代码实现

public classMathRandomChar {

//定义获取任意字符之间的随机字符

publicstatic char GetRandomChar(char cha1, char cha2) {

return(char) (cha1 + Math.random() * (cha2 - cha1 + 1));

}

publicstatic void main(String[] args) {

//获取a~z之间的随机字符

System.out.println("任意小写字符"+ GetRandomChar('a', 'z'));

//获取A~Z之间的随机字符

System.out.println("任意大写字符"+ GetRandomChar('A', 'Z'));

//获取0~9之间的随机字符

System.out.println("0到9任意数字字符"+ GetRandomChar('0', '9'));

}

结果

任意小写字符a

任意大写字符M

0到9任意数字字符4

3.2Random类

Random类常用的获取随机数方法
方法	返回值	功能描述
nextInt（）	int	返回一个随机整数
nextInt（int n）	int	返回大于等于0
nextLong（）	long	返回一个随机长整型值
nextBoolean（）	Boolean	返回一个随机布尔型值
nextFloat()	float	返回一个随机浮点型值
nextDouble（）	Double	返回一个随机双精度型值
nextGaussian	Double	返回一个概率密度为高斯分布的双精度值

代码实现import java.text.DecimalFormat;

importjava.util.Random;

importjava.util.Scanner;

public classRedBags { //创建一个RedBags类

publicstatic void main(String[] args) {

System.out.println("—————————模拟微信抢红包—————————\n");

Scannersc = new Scanner(System.in); //控制台输入

System.out.print("请输入要装入红包的总金额（元）：");

doubletotal = sc.nextDouble(); //输入“红包的总金额”

System.out.print("请输入红包的个数（个）：");

intbagsnum = sc.nextInt(); //输入“红包的个数”

doublemin = 0.01; //初始化“红包的最小金额”

Randomrandom = new Random(); //创建随机数对象random

DecimalFormatdf = new DecimalFormat("###,###,###.##"); //创建DecimalFormat类的对象df，并设置格式

for(int i = 1; i < bagsnum; i++) { //设置“循环”

doublesafe = (total - (bagsnum - i) * min) / (bagsnum - i); //通过公式模拟数学中的离散模型

doublemoney = (double) random.nextInt((int) ((safe - min) * 100)) / 100+ min; //根据离散模型得到每个红包的金额

total= total - money; //替换total的值

Stringtemp = df.format(money); //调用format()方法，对数字money格式化

System.out.println("第" + i +"个红包：" + temp + "元"); //输出结果

}

Stringleft = df.format(total); //调用format()方法，对数字total格式化

System.out.println("第" + bagsnum+ "个红包：" + left + "元"); //输出结果

sc.close();//关闭控制台输入

}

结果：

—————————模拟微信抢红包—————————

请输入要装入红包的总金额（元）：100

请输入红包的个数（个）：5

第1个红包：23.55元

第2个红包：4.17元

第3个红包：31.81元

第4个红包：17.61元

第5个红包：22.86元

（4）日期时间类

4.1Date类

Date类的构造方法及说明
构造方法	功能描述
Date（）	分配Date对象并初始化此对象，以表示分配它的时间（精准到毫秒）
Date（long date）	分配Date对象并初始化此对象，以表示自标准基准时间（即1970年1月1日00:00:00GMT）以来的指定毫秒数

Date类的常用方法及说明
方法	返回值	功能描述
after（Date when）	Boolean	测试当前日期是否在指定日期之后
before（Date when）	Boolean	测试当前日期是否在指定日期之前
getTime（）	long	获得字1970年1月1日00:00:00GMT开始到现在所表示的毫秒数
setTime（long time）	void	设置当前Date对象所表示的日期时间值，该值用以表示1970年1月1日00:00:00GMT以后time的毫秒的时间点

代码实现：

importjava.util.Date;

public classDateTest {

publicstatic void main(String[] args) {

Datedate = new Date(); //创建现在的日期

longvalue = date.getTime(); //获得毫秒数

System.out.println("日期：" + date);

System.out.println("到现在所经历的毫秒数为：" + value);

}

结果：日期：Fri Jul 06 17:02:05 CST 2018

到现在所经历的毫秒数为： 1530867725893

DateFormat类—是日期/时间格式化子类的抽象类。格式化语言风格：

1）SHORT:完全为数字，如12.13.52或3：30pm

2）MEDIUM:较长，如Jan 12，1952

3）LONG:更长，如January12,1952.

4）FULL：完全指定，如Tuesday、April12、1952AD。

DateFormat类常用方法及说明
方法	返回值	功能描述
format（Date date）	String	将一个Date格式化为日期/时间字符串
getCalendar（）	Calendar	获取与此日期/时间格式器关联日历
getDateInstance（）	static DateFormat	获取日期格式器，该格式器具有默认语言环境的默认格式化风格
getDateTimeInstance（）	static DateFormat	获取日期/时间格式器，该格式器具有默认语言环境的默认格式化风格
getInstance（）	static DateFormat	获取为日期和时间使用SHORT风格的默认日期/时间格式器
getTimeInstance（）	static DateFormat	获取时间格式器，该格式器具有默认语言环境的默认风格
parse（String source）	Date	将字符串解析成一个日期，并返回这个日期的Date对象

代码实现

importjava.text.DateFormat;

importjava.text.SimpleDateFormat;

importjava.util.Date;

importjava.util.Locale;

public classDateFormatTest {

publicstatic void main(String[] args) {

//创建日期

Datedate = new Date();

//创建不同的日期格式

DateFormatdf1 = DateFormat.getInstance();

DateFormatdf2 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss EE");

DateFormatdf3 = new SimpleDateFormat("yyyy年MM月dd日 hh时mm分ss秒 EE",Locale.CHINA);

DateFormatdf4 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss EE", Locale.US);

DateFormatdf5 = new SimpleDateFormat("yyyy-MM-dd");

DateFormatdf6 = new SimpleDateFormat("yyyy年MM月dd日");

//将日期按照不同格式进行输出

System.out.println("-------将日期时间按照不同格式进行输出------");

System.out.println("按照Java默认的日期格式:" + df1.format(date));

System.out.println("按照指定格式yyyy-MM-dd hh:mm:ss，系统默认区域:" + df2.format(date));

System.out.println("按照指定格式 yyyy年MM月dd日 hh时mm分ss秒，区域为中文 :" + df3.format(date));

System.out.println("按照指定格式yyyy-MM-dd hh:mm:ss，区域为美国: " + df4.format(date));

System.out.println("按照指定格式yyyy-MM-dd: " + df5.format(date));

System.out.println("按照指定格式 yyyy年MM月dd日: " + df6.format(date));

}

结果

-------将日期时间按照不同格式进行输出------

按照Java默认的日期格式: 2018/7/6 下午5:40

按照指定格式 yyyy-MM-dd hh:mm:ss，系统默认区域:2018-07-06 05:40:35 周五

按照指定格式 yyyy年MM月dd日 hh时mm分ss秒，区域为中文 : 2018年07月06日 05时40分35秒周五

按照指定格式 yyyy-MM-dd hh:mm:ss，区域为美国: 2018-07-06 05:40:35 Fri

按照指定格式 yyyy-MM-dd: 2018-07-06

按照指定格式 yyyy年MM月dd日: 2018年07月06日

4.2Calendar类

Calendar类提供的常用字段及说明
字段名	说明
DATE	get和set的字段数字，指示一天中的某天
DAY_OF_MONTH	get和set的字段数字，指示一月中的某天
DAY_OF_WEEK	get和set的字段数字，指示一星期中的某天
DAY_OF_IN_MONTH	get和set的字段数字，指示当前月中的第几个星期
DAY_OF_YEAR	get和set的字段数字，指示当前年中的天数
HOUR	get和set的字段数字，指示上午或下午的小时
HOUR_OF_DAY	get和set的字段数字，指示一天中的小时
MILLISECOND	get和set的字段数字，指示一秒中的毫秒
MINUTE	get和set的字段数字，指示一小时中的分秒
MONTH	指示月份的get和set的字段数字
SECOND	et和set的字段数字，指示一分钟中的秒
time	日历的当前设置时间，以毫秒为单位，表示自格林威治标准时间1970年1月1日0:00:00后经过的时间
WEEK_OF_MONTH	get和set的字段数字，指示当前月中的星期数
WEEK_OF_YEAR	get和set的字段数字，指示当前年中的星期数
YEAR	指示年的get和set的字段数字

Calendar类提供的常用方法及说明
方法	返回值	功能描述
add（int field，int amount）	void	根据日历的规则，为给定的日历字段添加或减去指定的时间量
after（Object when）	Boolean	判断此Calendar表示的时间是否在指定Object表示的时间之后，返回判断结果
before（Object when）	Boolean	判断此Calendar表示的时间是否在指定的Object表示的时间之前，返回判断结果
get（int field）	int	返回给定日历字段的值
getInstance（）	static Calendar	使用默认时区和语言环境获得一个日历
getTime（）	Date	返回一个表示此Calendar时间值（从历元至现在的毫秒偏移量）的Date对象
getTimeInMillis()	long	返回此Calendar的时间值，以毫秒为单位
roll（int field，boolean up）	abstract void	在给定的时间字段上添加或减去（上/下）单个时间单元，不更改更大的字段
set（int field，int value）	void	将给定的日历字段设置为给定值
set（int year，int month，intdate）	void	设置日历字段YEAR、MONTH和DAY_OF_MONTH的值
set（int year，int month，intdate，int hourOfDay，intminute）	void	设置日历字段YEAR、MONTH、DAY_OF_MONTH、HOUR_OF_DAY和MINUTE的值
set（int year，int month，intdate，int hourOfDay，intminute，int second）	void	设置日历字段YEAR、MONTH、DAY_OF_MONTH、HOUR_OF_DAY、MINUTE和SECOND的值
setTime（Date date）	void	使用给定的Date设置此Calendar的时间
setTimeInMillis（long millis）	void	用给定的long值设置此Calendar的当前时间值

代码实现：

importjava.text.SimpleDateFormat;

importjava.util.Calendar;

importjava.util.Date;

/**

* 输出2022年冬奥会倒计时（暂定冬奥会举办时间为2022年2月2日）

public classOlympicWinterGames { //创建OlympicWinterGames类

publicstatic void main(String[] args) {

System.out.println("——————————冬奥会倒计时——————————\n");

Datedate = new Date(); //实例化Date

SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");//创建SimpleDateFormat对象，制定目标格式

String today = simpleDateFormat.format(date);// 调用format方法，格式化时间，转换为指定方法

System.out.println("今天是" + today); //输出当前日期

long time1 = date.getTime(); //计算“自 1970 年 1 月 1 日 00:00:00 至当前时间所经过的毫秒数

Calendar calendar = Calendar.getInstance(); //使用默认时区和语言环境获得一个日历calendar

calendar.set(2022, 2-1, 4); //设置日历calendar中的 YEAR、MONTH 和DAY_OF_MONTH 的值

long time2 = calendar.getTimeInMillis(); //计算“自 1970 年 1 月 1 日 00:00:00 至 2022 年 2 月 2 日所经过的毫秒数

long day = (time2 - time1)/(24 * 60 * 60 * 1000); //计算2022 年 2 月 2 日距离当前时间的天数

System.out.println("距离2022年“北京-张家口”冬奥会还有 "+ day + " 天！");

}

结果:

——————————冬奥会倒计时——————————

今天是2018-07-06

距离2022年“北京-张家口”冬奥会还有 1309 天！

9.集合类

（1）集合类概述--Java中提供了集合类，而他们又被称为容器，集合的长度是可变的。

（2）Collection接口--是层次结构中的根接口。由于list集合、set集合都继承了Collection接口，所以Collection的所有方法它们都是可以直接使用的。

Collection接口的常用方法
方法	功能描述
add（Object e）	将指定对象添加到该集合中
remove（Object o）	将指定对象从该集合中移除
isEmpty（）	返回boolean值，用于判断当前集合是否为空
iterator（）	返回在此Collection的元素上进行迭代的迭代器。用于遍历集合中的对象
size（）	返回int型值，获取该集合中元素的个数

（3）List集合

3.1List接口--继承Collection接口，因此包含了Collection中所有的方法，此外List接口还定义了以下方法：

List接口的常用方法
方法	功能描述
get（int index）	获得指定索引位置的元素
set（int index，Object obj）	将集合中指定索引位置的对象修改为指定的对象

3.2List接口的实现类

1.ArrayList类--ArrayList类的优点是实现了可变的数组，允许保存所有的元素，包括null，并可以根据索引位置对集合进行快速的随机访问；缺点就是指向的索引位置插入和删除对象的速度较慢，因为ArrayList实质上是使用数组来保存集合中的元素的，在增加和删除指定位置的元素时、虚拟机会创建新的数组，效率低，所以在对元素做大量的增删操作时不适合使用ArrayList集合。

2.LinkedList类--LinkedList类采用了链表结构保存对象，这种结构的优点是便于向集合中插入和删除对象，需要向集合中插入、删除对象时，使用LinkedList类实现List集合的效率较高；但对于随机访问集合中的对象，使用LinkedList类实现List集合的效率较低

代码实现

importjava.util.*;

public classUseList { // 创建类useList

publicstatic void main(String[] args) { // 主方法

List<String>list = new ArrayList<>(); // 创建集合对象

list.add("a");// 向集合添加元素

list.add("b");

list.add("c");

inti = (int) (Math.random() * list.size()); // 获得0~2之间的随机数

System.out.println("随机获取数组中的元素："+ list.get(i));

list.remove(2);// 将指定索引位置的元素从集合中移除

System.out.println("将索引是'2'的元素从数组移除后，数组中的元素是：");

for(int j = 0; j < list.size(); j++) { // 循环遍历集合

System.out.println(list.get(j));// 获取指定索引处的值

}

结果：

随机获取数组中的元素：b

将索引是'2'的元素从数组移除后，数组中的元素是：

3.3Iterator迭代器--是专门对Collection进行迭代的迭代器

Iterator迭代器
方法	功能描述
hasNext（）	如果仍有元素可以迭代，则返回true
next（）	返回迭代的下一个元素
remove（）	从迭代器指向的Collection中移除迭代器返回的最后一个参数（可选操作）

代码实现

importjava.util.*; //导入java.util包，其他实例都要添加该语句

public classUseIterator { // 创建类useIterator

publicstatic void main(String args[]) {

Collection<String>list = new ArrayList<>(); // 实例化集合类对象

list.add("a");// 向集合添加数据

list.add("b");

list.add("c");

Iterator<String>it = list.iterator(); // 创建迭代器

while(it.hasNext()) { // 判断是否有下一个元素

Stringstr = (String) it.next(); // 获取集合中元素

System.out.println(str);

}

结果

（4）Set集合--集合中的对象不安特定的方式排列，只是简单的把对象加入到集合中，但Set集合中不能包含重复对象

4.1Set接口--是一个不包含重复元素的集合，其继承Collection接口，所以拥有Collection所有的方法

4.2Set接口的实现类

1.HashSet类--是Set接口的一个实现类，他不允许有重复元素。HashSet主要依据哈希算法直接将元素指定到一个地址上，当向HashSet集合中添加一个元素时，会调用equals方法来判断该位置是否有重复元素。判断是通过比较它们的HashCode来进行比较的。HashSet集合的常用方法都是重写了Set接口中的方法。此集合允许保存null。

2.TreeSet类--不仅实现了Set接口，还实现了java.util.SortedSet接口，因此TreeSet类实现的Set集合在遍历时按照自然顺序递增排序，也可以制定排序规则，让集合按照我们想要的方式排列。TreeSet新增方法如下表所示，该集合不能保存null

TreeSet类增加的方法
方法	功能描述
first（）	返回此Set中当前第一个（最低）元素
last（）	返回此Set中当前最后一个（最高）元素
comparator()	返回对此Set中的元素进行排序的比较器。如果此Set是自然排序则返回null
headset（E toElement）	返回一个新的Set集合，新集合是toElement(不包含)之前的所有对象
sunset（E fromElement，E toElement）	返回一个新的Set集合，新集合是fromElement (包含)对象与toElement(不包含)对象之间的所有对象
tailSet(E fromElement)	返回一个新的Set集合，新集合包含对象fromElement (包含)之后的所有对象

代码实现

importjava.util.*;

public classUseHashSet {

publicstatic void main(String[] args) {

Setset = new HashSet();// 创建Set集合

set.add("c");//向集合中添加数据

set.add("c");

set.add("a");

set.add("b");

Iterator<String>it = set.iterator();// 创建迭代器

while(it.hasNext()) {// 遍历HashSet集合

Stringstr = (String) it.next();// 获取集合中的元素

System.out.println(str);

}

结果：

（5）Map集合

5.1Map接口--提供了将key映射到值的对象。一个映射不能包含重复的key，每个key最多只能映射一个值。

Map接口中常用的方法
方法	功能描述
put(Object key, Object value)	向集合中添加指定的key与value的映射关系
contaimsKey(Object key)	如果此映射包含指定key的映射关系，则返回true
containsValue(Object value)	如果此映射将一个或多个key映射到指定值，，则返回true
get(Object key)	如果存在指定的key对象，则返回该对象对应的值，否则返回null
keyset（）	返回该集合中的所有key对象形成的Set集合
values（）	返回该集合中所有值对象形成的Collection集合

5.2Map接口的实现类

1)HashMap类是基于哈希表的Map接口的实现，此实现提供所有可选的映射操作，并允许使用null值和null键，但必须保证键的唯一性。HashMap通过哈希表对其内部的映射关系进行快速查找。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。

2)TreeMap类不仅实现了Map接口，还实现了java.util.SortedMap接口，因此，集合中映射关系具有一定的顺序。但在添加、删除和定位映射关系时，TreeMap类比HashMap类性能稍差，由于TreeMap类实现的Map集合中的映射关系是根据键对象按照一定的顺序排列的，因此不允许键对象是null.

代码实现

importjava.util.*;

public classUseHashMap {

publicstatic void main(String[] args) {

Map<String,String> map = new HashMap<>(); // 创建Map实例

map.put("ISBN-978654","Java从入门到精通"); // 向集合中添加对象

map.put("ISBN-978361","Android从入门到精通");

map.put("ISBN-978893","21天学Android");

map.put("ISBN-978756","21天学Java");

Set<String>set = map.keySet(); // 构建Map集合中所有key对象的集合

Iterator<String>it = set.iterator(); // 创建集合迭代器

System.out.println("key值：");