日期时间类——Java常用类

Posted 2021-11-04 qq308015824

时间戳(timestamp)：距离特定时间的间隔.

计算机中的时间戳是指距离历元（1970-01-01 00：00：00：000）的时间间隔（ms）.

格林尼治时间(GMT)：是一个标准时间，用于全球时间的标准化，也称世界协调时(UT)。各个国家通过时区偏移来定义各国的标准时间。

计算机中时间2019-04-29 20:14:00 是该时间距离历元经过的毫秒数，用long类型存储。

计算机中的时间表示为，当前时间距离历元经过的毫秒数，即时间戳。在计算机中，知道时间戳，就知道时间。

时间本质上是一个整型。

 

中国位于东八区

 

中国的标准时china standard time = UTC + 08:00

 

日本的标准时 = UTC + 09:00

1 Date

类Date，常见用法：

1 创建当前时间

2 获取当前时间的时间戳

3 通过时间戳创建Data对象

 1 public class Test01 {
 2 
 3     public static void main(String[] args) {
 4         //获取当前时间
 5         Date date= new Date();
 6         System.out.println(date);
 7         
 8         //获取date的时间戳
 9         long time1 = date.getTime();
10         System.out.println(time1);
11         
12         //通过时间戳创建Date对象
13         long time2 = 0;
14         Date date2 = new Date(time1);
15         System.out.println(date2);
16         
17         // 需求:请构建一个时间，表示未来一天的当前时间。
18         /*
19          * 计算机中的时间表示为，当前时间距离历元经过的毫秒数，即时间戳。在计算机中，知道时间戳，就知道时间。
20         未来一天的当前时间距历元的毫秒数（时间戳）为，当前时间戳+一天的毫秒数*/
21         
22         long dayTime = 24*3600*1000;
23         long futureTime = dayTime + date.getTime();
24         Date date3 = new Date(futureTime);
25         System.out.println(date3);
26         
27         
28     }
29 }

2.1 时间比较

1 date1.compareTo(date2)

2 date1.equals(date2)

改变时间戳：setTime() 如：

 date1.setTime(date1.getTime()+24*3600*1000);

 1 public static void main(String[] args) {
 2         
 3         // 比较两个时间
 4         Date d1 = new Date();
 5         Date d2 = new Date(d1.getTime()+1000);
 6         
 7         System.out.println(d1.before(d2));
 8         System.out.println(d1.after(d2));
 9         
10         System.out.println(d1.compareTo(d2));
11         
12         System.out.println(d1.equals(d2));
13         
14         
15         // d1.getTime() - d2.getTime()
16         // setTime:改变Date对象的时间戳
17         d1.setTime(d1.getTime()+24*3600*1000);
18         System.out.println(d1);
19     }

2.2日期时间的格式化

【1】把Date对象格式化成特定的字符串 SimpleDateFormat  df = new SimpleDateFormat();

（1）日期格式化->字符串

（2）使用默认的模式和语言环境

（3）使用指定的模式格式化

（4）修改模式

 1 public class Test02 {
 2 
 3     public static void main(String[] args) {
 4         Date date = new Date();
 5         System.out.println(date);
 6         
 7         //将日期格式化成字符串
 8         SimpleDateFormat dF = new SimpleDateFormat();
 9         //使用默认的模式和语言环境
10         //19-4-29 下午9:01
11         String dateStr = dF.format(date);
12         System.out.println(dateStr);
13         
14         //[2]使用指定的模式格式化
15         SimpleDateFormat df2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
16         String dateStr2 = df2.format(date);
17         System.out.println(dateStr2);
18         
19         //修改时间格式
20         df2.applyPattern("yyyy-MM-dd");
21         String dateStr3 = df2.format(date);
22         System.out.println(dateStr3);
23     }
24 }

【2】把特定的时间格式的字符串解析成Date对象

（1）"2019-04-29 15:48:00" ->Date

 1 public class Test03 {
 2 
 3     public static void main(String[] args) {
 4         //把特定的格式的字符串解析成Date对象
 5         String str = "2019-04-29 15:21:25";
 6         SimpleDateFormat dF = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
 7         
 8         try {
 9             Date date = dF.parse(str);
10             System.out.println(date);
11         } catch (ParseException e) {
12             e.printStackTrace();
13         }
14     }
15 }

2.3Calender

Calendar是日历类，本质上内部拥有一个属性 long time。 表示该日历所具体的时间戳。

同时Calendar内部通过对time的运算计算出很多日历字段，把这些日历字段存在一个容器中，并提供set/get方法用于设置或者访问这些字段。

Calender是抽象类，没有构造方法但Calender有特殊的创建对象的方法

Calender cal = Calender.getInstance();

Calender获取年，月，日，时，分，秒，星期，本月的第一天和最后一天

 1 public class Test04 {
 2 
 3     public static void main(String[] args) {
 4         //通过工厂设计模式构建一个对象
 5         Calendar cal = Calendar.getInstance();
 6         System.out.println(cal);
 7         
 8         //获取年
 9         System.out.println(cal.get(cal.YEAR));
10         
11         //获取月，索引从0开始，0-表示1月
12         System.out.println(cal.get(cal.MONTH));
13         
14         //获取日
15         System.out.println(cal.get(cal.DAY_OF_MONTH));
16         
17         //时
18         System.out.println(cal.get(cal.HOUR_OF_DAY));
19         
20         //分
21         System.out.println(cal.get(cal.MINUTE));
22         
23         //秒
24         System.out.println(cal.get(cal.SECOND));
25         
26         //毫秒
27         System.out.println(cal.get(cal.MILLISECOND));
28         
29         //获取星期几    一周的第一天是从周日开始的
30         System.out.println(cal.get(cal.DAY_OF_WEEK));
31         
32         //本月的第一天和本月的最后一天
33         System.out.println(cal.getActualMinimum(cal.DAY_OF_MONTH));
34         System.out.println(cal.getActualMaximum(cal.DAY_OF_MONTH));
35     }
36 }

2.4 Math

Math 类包含用于执行基本数学运算的方法。例如，随机数、平方、立方。

Math类获取Pi(3.14159265358..),绝对值，ceil(向上取整)，floor(向下取整)，两个数中的max/min， pow(x,y)x的y次方，Math.random 随机数，四舍五入，

把弧度转角度，把角度转弧度， sin(a),cos(a)/tan(a)

 1 public static void main(String[] args) {
 2         //常用属性 PI(3.14159265358..)
 3         System.out.println(Math.PI);
 4         
 5         
 6         //常用方法
 7         //绝对值
 8         System.out.println(Math.abs(-10));
 9         System.out.println(Math.abs(10));
10         
11         //ceil(向上取整)  floor向下取整
12         //返回比10.1大的最小整数 => 向上取整
13         System.out.println(Math.ceil(10.1));
14         //返回比10.1小的最大整数 => 向下取整
15         System.out.println(Math.floor(10.1));
16         
17         //max/min
18         System.out.println(Math.max(10, 20));
19         System.out.println(Math.min(10, 20));
20         
21         //pow(x,y)x的y次方
22         System.out.println(Math.pow(2, 3));
23         
24         //Math.randow 随机数
25         //产生[m,n]随机整数 <=> (int)(Math.random()*(n-m+1)+m)
26         
27         //四舍五入
28         System.out.println(Math.round(4.5));
29         
30         
31         //把弧度转角度
32         System.out.println(Math.toDegrees(Math.PI/2));
33         //角度转弧度
34         System.out.println(Math.toRadians(180));
35         
36         //sin(a)/cos(a)/tan(a)
37         System.out.println(Math.sin(Math.PI/6));
38         
39         //需求：求两点之间的距离（x1,y1）- (x2,y2)的距离。
40         //Math.sqrt(Math.pow((x1-x2), 2)+Math.pow((y1-y2), 2));
41     }

2.5 枚举

2.5.1 枚举简介

枚举是由一组固定的常量组成的类型，自定义数据类型。语法:

1 [修饰符] enum enumName{
2   常量值1,
3   常量值2,
4   常量值3…
5   
6   常量值n[;]
7 }

枚举的常量值一定是可列举的有限值。常量值的类型都是public static final

案例:定义一个性别的枚举类型

 

1 public enum Gender {
2     男,
3     女,
4     保密;
5 }

 

Gender 是一种自定义的数据类型，可以用于声明变量，且变量的取值必须是枚举值的其中一个。gender的值必须是男或者女或者保密。

 

1 public class Test06 {
2 
3     public static void main(String[] args) {
4         //声明一个Gender枚举类型的变量gender,并取值为男
5         Gender gender = Gender.男;
6     }
7 }

java中所有的枚举类型都继承于Enum类。可以把枚举类型看出一个类。

 

 1 public class Student {
 2 
 3     private String name;
 4     private int age;
 5     private Gender gender;
 6     public String getName() {
 7         return name;
 8     }
 9     public void setName(String name) {
10         this.name = name;
11     }
12     public int getAge() {
13         return age;
14     }
15     public void setAge(int age) {
16         this.age = age;
17     }
18     public Gender getGender() {
19         return gender;
20     }
21     public void setGender(Gender gender) {
22         this.gender = gender;
23     }
24     public Student() {
25         super();
26     }
27     public Student(String name, int age, Gender gender) {
28         super();
29         this.name = name;
30         this.age = age;
31         this.gender = gender;
32     }
33     @Override
34     public String toString() {
35         return "Student [name=" + name + ", age=" + age + ", gender=" + gender
36                 + "]";
37     }
38     
39     //class Gender extends Enum{}   看成一个类
40     enum Gender {
41         男,女,保密;
42     }

 

2.5.2 枚举和字符串转化

【1】枚举值->字符串

【2】字符串->枚举值

 

 1 public static void main(String[] args) {
 2         //声明一个Gender枚举类型 的变量gender,并取值为男
 3         Gender gender = Gender.男;
 4         
 5         //枚举值->字符串
 6         System.out.println(gender.toString());
 7         
 8         //字符串-> 枚举值
 9         String string = "保密";
10         
11         //可能产生IllegalArgumentException 非法参数异常
12         Gender gender2 = Enum.valueOf(Gender.class, string);
13         System.out.println(gender2);
14     }

 

2.5.3

枚举和switch

1 public enum Week {
2     Monday,
3     TUESDAY,
4     WEDNESDAY,
5     THURSDAY,
6     FRIDAY,
7     SATURDAY,
8     SUNDAY;
9 }

 1 public class Test08 {
 2 
 3     public static void main(String[] args) {
 4         // 需求:有一个变量表示星期几，输出对于的教学安排
 5         Week week = Week.SUNDAY;
 6         switch (week) {
 7             case Monday:
 8             case TUESDAY:
 9             case THURSDAY:
10             case FRIDAY:
11             case SATURDAY:{
12                 System.out.println("上课");
13                 break;
14             }
15             case WEDNESDAY:
16             case SUNDAY:{
17                 System.out.println("练习");
18                 break;
19             }
20 
21         }
22     }

枚举的其他方法

【1】返回此枚举常量的名称

【2】返回枚举常量的序数（它在枚举声明中的位置，其中初始常量序数为零）。

 

1 public static void main(String[] args) {
2         Week week = Week.SUNDAY;
3         
4         //返回枚举常量的名称
5         System.out.println(week.name());
6         
7         //返回枚举常量的序数（它在枚举声明中的位置，其中初始常量序数为零）。
8         System.out.println(week.ordinal());
9     }

 

输出结果为：

SUNDAY
6

 

 

 

总结：

　　1.只能够取特定值中的一个

　　2.使用enum关键字

　　3.所有的枚举类型隐性地继承自 java.lang.Enum。（枚举实质上还是类！而每个被枚举的成员实质就是一个枚举类型的实例，他们　　默认都是public static final的。可以直接通过枚举类型名直接使用它们。）

　　4.强烈建议当你需要定义一组常量时，使用枚举类型