时间日期API(Date,SimpleDateFormat,Calendar)+java8新增日期API (LocalTime,LocalDate,LocalDateTime)

时间日期API+java8新增日期API (LocalTime,LocalDate,LocalDateTime)

① Date

java.util 包提供了 Date 类来封装当前的日期和时间。

Date date = new Date();
// 1.toString输出时间 按照一定格式
System.out.println(date); // Mon Jan 29 15:41:38 CST 2024
// 2.获取自1970.1.1起到现在的时间毫秒数
System.out.println(date.getTime()); // date.getTime()获取自1970xxx起的微秒数
// 3.设置时间  参数为自1970.1.1起的毫秒数
date.setTime(514074250); // 将毫秒数加到1970.1.1，然后设置为时间
System.out.println(date); // Wed Jan 07 06:47:54 CST 1970
// 4. 比较日期是否在参数日期之前
System.out.println(date.before(new Date(510000000))); //false
System.out.println(date.before(new Date(530000000))); //true
// 5. 比较日期是否在参数日期之后
System.out.println(date.after(new Date(510000000))); // true
System.out.println(date.after(new Date(530000000))); // false
// 6.比较两个时间  -1 表示在参数时间之前 ；0 表示 两个时间相等 ；1 表示在参数时间之后
System.out.println(date.compareTo(new Date(530000000))); // -1

1. 创建Date对象，有多个构造器，包括无参数的 new Date(),有参数的 new Date(long Date) 以指定的毫秒数去设置时间，还有一个 new Date(int year, int month, int date) 已经弃用了。
2. toString（)方法格式化时间毫秒数
3. getTime() 获取自1970.1.1起的毫秒数
4. setTime() 设置时间，参数为自1970.1.1起的毫秒数
5. before() 比较日期是否在某个日期之前
6. after() 比较日期是否在某个日期之后
7. compareTo() 比较两个时间的大小，然后参数返回是 -1 ，0， 1 就是 Comparable接口那个比较器。
8. … hashCode()、toInstant()、clone()返回当前对象的副本。

② SimpleDateFormat

SimpleDateFormat格式化分析日期的类

Date date = new Date();
// 格式化日期
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
System.out.println(sdf.format(date)); // 2024-01-29 02:16:37

③ Calendar

Calender类，对于设置获取日期数据的特定部分，更为简便（例如：获取，小时，分钟，秒，日月），并且可以对日期上进行增加和减去一些时间。

// 1.获取Calendar对象 ,使用getInstance()
Calendar calendar = Calendar.getInstance();
// 2.设置指定的时间
calendar.set(Calendar.YEAR,2027);
calendar.set(Calendar.MONDAY,11);
calendar.set(Calendar.DATE,18);
// calendar.set(2027,11,18);  上面三段代码可以合成一句
// 3.获取时间部分值 ---- 例如：获取年
System.out.println(calendar.get(Calendar.YEAR));
System.out.println(calendar.get(Calendar.MONTH));
System.out.println(calendar.get(Calendar.DATE));
// 4.在现有时间上，增加时间-----例如年份
calendar.add(Calendar.YEAR,3); // 年份加3年 2027 + 3 => 2030
System.out.println(calendar.get(Calendar.YEAR)); // 2030
// 5.在现有时间上，减去时间-----例如月份
calendar.add(Calendar.MONTH,-2); // 月份减2月 11-2 => 09
System.out.println(calendar.get(Calendar.MONTH)); // 9

首先，通过Calendar.getInstance()来获取一个Calendar对象
其中，Calendar.set()有多个重载，可以根据不同需求去指定。

接着，可以通过Calendar.get(field) 来获取指定的时间部分的值
通过 Calendar.add(field,amount) 来增加时间或者减去时间

Calendar类中的常量：

常量	描述
Calendar.YEAR	年份
Calendar.MONTH	月份
Calendar.DATE	日期
Calendar.DAY_OF_MONTH	日期，和上面的字段意义完全相同
Calendar.HOUR	12小时制的小时
Calendar.HOUR_OF_DAY	24小时制的小时
Calendar.MINUTE	分钟
Calendar.SECOND	秒
Calendar.DAY_OF_WEEK	星期几

④ GregorianCalendar

GregorianCalendar类是Calendar类的子类，实现了公历日期。

//---------------------------------------- GregorianCalendar
GregorianCalendar gregorianCalendar = new GregorianCalendar();
System.out.println(gregorianCalendar.get(Calendar.YEAR));
//  判断是否是闰年  其余方法基本和 Calendar ，需要的话看下api文档就行
System.out.println(gregorianCalendar.isLeapYear(2024));
System.out.println(gregorianCalendar.isLeapYear(2025));

值得注意的方法 gregorianCalendar.isLeapYear（year）,判断是否为闰年

⑤ 新的日期API （LocalTime,LocalDate,LocalDateTime）

经过上面旧的日期API使用，很容易感觉到旧的日期API用起来非常麻烦（一大堆毫秒数，时间戳），并且也不是线程安全的，存在一些潜在的并发问题。

Java8 提出了新的日期API,在java.time下。

1. LocalTime 不可变时间对象

LocalTime是Java8中用于才处理时间的不可变类，它只包含时分秒以及纳秒，没有日期部分。它没有时区信息，所以它代表的是一天中的某个时间

以下是LocalTime常用的一些操作及方法。

1. 创建LocalTime实例

创建 LocalTime 实例的最直接方式是使用它的静态工厂方法，LocalTime.now()

LocalTime now = LocalTime.now();
System.out.println(now); // 16:38:59.015059500

2. 使用of() 创建一个具体的时间

LocalTime time = LocalTime.of(22, 33, 44, 55);// 创建 22:33:44.55的时间
System.out.println(time);

3. 获取时间信息

获取时间信息的方法，见名知意，非常简单。

LocalTime now = LocalTime.now();
// 获取时分秒及纳秒
int hour = now.getHour();
int minute = now.getMinute();
int second = now.getSecond();
int nano = now.getNano();
System.out.println(hour);
System.out.println(minute);
System.out.println(second);
System.out.println(nano);

4. 修改时间 plus minus

LocalTime是不可变的，所以每个修改时间的操作返回的都是一个新的LocalTime对象，修改时间的方法允许进行链式编程操作。

LocalTime now = LocalTime.now();
// 增加三个小时，4分钟，5秒，10纳秒
LocalTime later = now.plusHours(3).plusMinutes(4).plusSeconds(5).plusNanos(10);
System.out.println(later); //20:25:55.672090010

// 减少1个小时，2分钟，3秒
LocalTime oldTime = now.minusHours(1).minusMinutes(2).minusSeconds(3);
System.out.println(oldTime); //16:19:47.672090

5. 比较时间 使用 isBefore() isAfter() 或者 compareTo() 【返回值为整型】

LocalTime time1 = LocalTime.of(9,30);
LocalTime time2 = LocalTime.of(10,15);
System.out.println(time1.isBefore(time2)); // true
System.out.println(time1.isAfter(time2)); // false
System.out.println(time1.compareTo(time2)); // -1

2. LocalDate 不可变日期对象

LocalDate 是 Java 8 中用于处理日期的不可变类，它只包含日期部分（年、月、日），没有时间和时区。

1. 创建LocalDate对象

LocalDate today = LocalDate.now();
System.out.println(today); // 2024-01-29

2. 创建指定日期的LocalDate对象

LocalDate date = LocalDate.of(2027,8,21);
System.out.println(date); // 2027-08-21

3. 获取日期信息

LocalDate now = LocalDate.now();
int year = now.getYear();
Month month = now.getMonth();
int dayOfMonth = now.getDayOfMonth();

System.out.println(year); // 2024
System.out.println(month); // JANUARY
System.out.println(dayOfMonth); // 29

4. 修改日期 plus minus

同样LocalDate也是不可变的，每次修改日期操作都会返回一个新的LocalDate对象,也一样支持日期修改的链式操作。

LocalDate today = LocalDate.now();
System.out.println(today); // 2024-01-29

// 1.增加日期
LocalDate futureDay = today.plusYears(1).plusMonths(2).plusDays(3);
System.out.println(futureDay);// 2025-04-01

// 2.减少日期
LocalDate oldDay = today.minusDays(1).minusMonths(2).minusYears(3);
System.out.println(oldDay); //2020-11-28

5. 比较日期 isBefore(),isAfter(),compareTo()

LocalDate d1 = LocalDate.of(2028, 1, 29);
LocalDate d2 = LocalDate.of(2028, 2, 1);
System.out.println(d1.isBefore(d2)); // true
System.out.println(d1.isAfter(d2)); // false
System.out.println(d1.compareTo(d2)); // -1

3. LocalDateTime 不可变日期时间对象

LocalDateTime 是 Java 8 中一个不可变的日期-时间对象，它表示了日期（年、月、日）和时间（小时、分钟、秒），但不包含时区

1. 获取当前的日期和时间

LocalDateTime now = LocalDateTime.now();
System.out.println(now); // 2024-01-29T17:08:53.401518100

2. 创建指定日期时间的LocalDateTime对象

LocalDateTime dateTime = LocalDateTime.of(2024, 12, 9, 18, 22);
System.out.println(dateTime); // 2024-12-09T18:22

3. 获取日期和时间的信息

System.out.println(now.getYear());
System.out.println(now.getMonth());
System.out.println(now.getDayOfMonth());
System.out.println(now.getHour());
System.out.println(now.getMinute());
System.out.println(now.getSecond());
System.out.println(now.getNano());
// ... 就不一一列举了

4. 修改日期和时间 plus minus

同样的LocalDateTime对象也是不可变对象，当修改日期时间时，会创建新的LocalDateTime对象。并且同样，修改时间操作支持链式编程**。plus增加时间，minus减少时间。**

LocalDateTime changeDateTime = now.plusDays(1).minusHours(2).plusHours(1);
System.out.println(changeDateTime);

5. 比较日期时间 isBefore、isAfter、compareTo

LocalDateTime dateTime1 = LocalDateTime.of(2028, 11, 24, 12, 30);
LocalDateTime dateTime2 = LocalDateTime.of(2028, 1, 26, 12, 30);

// 检查 dateTime1 是否在 dateTime2 之前
boolean isBefore = dateTime1.isBefore(dateTime2);
System.out.println(isBefore);  // 输出：false

// 检查 dateTime1 是否在 dateTime2 之后
boolean isAfter = dateTime1.isAfter(dateTime2);
System.out.println(isAfter);  // 输出：true

小结：
新的日期时间API，LocalTime,LocalDate,LocalDateTime都是不可变对象，每次操作修改值都会创建一个新的对象。
如果只是涉及时间，则使用LocalTime只涉及日期，使用LocalDate,日期时间都涉及，则使用LocalDateTime.
LocalTime,LocalDate,LocalDateTime三个类的操作基本一致，相对于Date更为灵活，简洁。