Data

Date 类的对象在 Java 中代表的是当前所在系统的此刻日期时间。
Date 的常用方法：public long getTime()：获取时间对象的毫秒值

  1. // 1、创建一个 Date 类的对象：代表系统此刻日期时间对象
  2. Date d = new Date();
  3. System.out.println(d);
  5. // 2、获取时间毫秒值
  6. long time = d.getTime();
  7. System.out.println(time);
  9. long time1 = System.currentTimeMillis();
  10. System.out.println(time1);
  12. System.out.println("----------------------------");
  14. // 1、得到当前时间
  15. Date d1 = new Date();
  16. System.out.println(d1);
  18. // 2、当前时间往后走 1 小时
  19. long time2 = System.currentTimeMillis();
  20. time2 += (60 * 60) * 1000;
  22. // 3、把时间毫秒值转换成对应的日期对象。
  23. Date d2 = new Date(time2);
  24. System.out.println(d2);

SimpleDateFormat

可以对 Date 对象或时间毫秒值格式化成我们喜欢的时间形式，也可以把字符串的时间形式解析成日期对象。
SimpleDateFormat 的构造器

  • public SimpleDateFormat()：构造一个SimpleDateFormat，使用默认格式
  • public SimpleDateFormat(String pattern)：构造一个SimpleDateFormat，使用指定的格式

SimpleDateFormat 的格式化方法

  • public final String format(Date date)：将日期格式化成日期/时间字符串
  • public final String format(Object time)：将时间毫秒值式化成日期/时间字符串

SimpleDateFormat 解析字符串时间成为日期对象

  • public Date parse(String source)：从给定字符串的开始解析文本以生成日期

格式化的时间形式的常用的模式对应关系如下：y 年、M 月、d 日、H 时、m 分、s 秒、E 星期、a 上下午

  1. // 1、日期对象
  2. Date d = new Date();
  3. System.out.println(d);
  5. // 2、格式化这个日期对象 (指定最终格式化的形式)
  6. SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss EEE a");
  7. // 3、开始格式化日期对象成为喜欢的字符串形式
  8. String rs = sdf.format(d);
  9. System.out.println(rs);
  11. System.out.println("----------------------------");
  13. // 4、格式化时间毫秒值
  14. // 需求：请问121秒后的时间是多少
  15. long time1 = System.currentTimeMillis() + 121 * 1000;
  16. String rs2 = sdf.format(time1);
  17. System.out.println(rs2);

使用 SimpleDateFormat 解析字符串时间成为日期对象

  1. // 有一个时间 2021年08月06日 11:11:11 往后 2 天 14 小时 49 分 06 秒后的时间是多少。
  2. // 1、把字符串时间拿到程序中来
  3. String dateStr = "2021年08月06日 11:11:11";
  5. // 2、把字符串时间解析成日期对象: 形式必须与被解析时间的形式完全一样，否则运行时解析报错！
  6. SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
  7. Date d = sdf.parse(dateStr);
  9. // 3、往后走 2 天 14 小时 49 分 06 秒
  10. long time = d.getTime() + (2L * 24 * 60 * 60 + 14 * 60 * 60 + 49 * 60 + 6) * 1000;
  12. // 4、格式化这个时间毫秒值就是结果
  13. System.out.println(sdf.format(time));

Calendar

Calendar 代表了系统此刻日期对应的日历对象。
Calendar 是一个抽象类，不能直接创建对象。
Calendar 日历类创建日历对象的方法：

  • public static Calendar getInstance()：获取当前日历对象

Calendar 常用方法：

  • public int get(int field)：取日期中的某个字段信息。
  • public void set(int field,int value)：修改日历的某个字段信息。
  • public void add(int field,int amount)：为某个字段增加/减少指定的值
  • public final Date getTime()：拿到此刻日期对象。
  • public long getTimeInMillis()：拿到此刻时间毫秒值

注意：Calendar 是可变日期对象，一旦修改后其对象本身表示的时间将产生变化。

// 1、拿到系统此刻日历对象
Calendar cal = Calendar.getInstance();
System.out.println(cal);

// 2、获取日历的信息:public int get(int field)：取日期中的某个字段信息。
int year = cal.get(Calendar.YEAR);
System.out.println(year);

int mm = cal.get(Calendar.MONTH) + 1;
System.out.println(mm);

int days = cal.get(Calendar.DAY_OF_YEAR);
System.out.println(days);

// 3、public void set(int field,int value)：修改日历的某个字段信息。
// cal.set(Calendar.HOUR , 12);
// System.out.println(cal);

// 4.public void add(int field,int amount)：为某个字段增加/减少指定的值
// 请问64天后是什么时间
cal.add(Calendar.DAY_OF_YEAR, 64);
cal.add(Calendar.MINUTE, 59);

//  5.public final Date getTime(): 拿到此刻日期对象。
Date d = cal.getTime();
System.out.println(d);

//  6.public long getTimeInMillis(): 拿到此刻时间毫秒值
long time = cal.getTimeInMillis();
System.out.println(time);

Java 8 新增日期类

从 Java 8开始，java.time 包提供了新的日期和时间 API，主要涉及的类型有：
日期与时间类 - 图1
新增的 API 严格区分了时刻、本地日期、本地时间，并且，对日期和时间进行运算更加方便。其次，新 API 的类型几乎全部是不变类型（和 String 的使用类似），可以放心使用不必担心被修改。

LocalDate、LocalTime、LocalDateTime

他们分别表示日期，时间，日期时间对象，他们的类的实例是不可变的对象。他们三者构建对象和 API 都是通用的：

  • now()：静态方法，根据当前时间创建对象
  • of()：静态方法，指定日期/时间创建对象 ```java

// 1、获取本地日期对象。 LocalDate nowDate = LocalDate.now(); // 今天的日期 System.out.println(“今天的日期：” + nowDate);

int year = nowDate.getYear(); System.out.println(“year：” + year);

int month = nowDate.getMonthValue(); System.out.println(“month：” + month);

int day = nowDate.getDayOfMonth(); System.out.println(“day：” + day);

// 当年的第几天 int dayOfYear = nowDate.getDayOfYear(); System.out.println(“dayOfYear：” + dayOfYear);

// 星期 System.out.println(nowDate.getDayOfWeek()); System.out.println(nowDate.getDayOfWeek().getValue());

// 月份 System.out.println(nowDate.getMonth()); System.out.println(nowDate.getMonth().getValue());

System.out.println(“————————————“); LocalDate bt = LocalDate.of(1991, 11, 11); System.out.println(bt); // 直接传入对应的年月日 System.out.println(LocalDate.of(1991, Month.NOVEMBER, 11)); // 相对上面只是把月换成了枚举

```java
// 获取本地时间对象。
LocalTime nowTime = LocalTime.now();
System.out.println("今天的时间：" + nowTime); // 今天的时间：

int hour = nowTime.getHour(); // 时
System.out.println("hour：" + hour); // hour：

int minute = nowTime.getMinute(); // 分
System.out.println("minute：" + minute); // minute：

int second = nowTime.getSecond(); // 秒
System.out.println("second：" + second); // second：

int nano = nowTime.getNano(); // 纳秒
System.out.println("nano：" + nano); // nano：

System.out.println("-----");
System.out.println(LocalTime.of(8, 20)); // 时分
System.out.println(LocalTime.of(8, 20, 30)); // 时分秒
System.out.println(LocalTime.of(8, 20, 30, 150)); // 时分秒纳秒
LocalTime mTime = LocalTime.of(8, 20, 30, 150);

System.out.println("---------------");
System.out.println(LocalDateTime.of(1991, 11, 11, 8, 20));
System.out.println(LocalDateTime.of(1991, Month.NOVEMBER, 11, 8, 20));
System.out.println(LocalDateTime.of(1991, 11, 11, 8, 20, 30));
System.out.println(LocalDateTime.of(1991, Month.NOVEMBER, 11, 8, 20, 30));
System.out.println(LocalDateTime.of(1991, 11, 11, 8, 20, 30, 150));
System.out.println(LocalDateTime.of(1991, Month.NOVEMBER, 11, 8, 20, 30, 150));

// 日期 时间
LocalDateTime nowDateTime = LocalDateTime.now();
System.out.println("今天是：" + nowDateTime); // 今天是：
System.out.println(nowDateTime.getYear()); // 年
System.out.println(nowDateTime.getMonthValue()); // 月
System.out.println(nowDateTime.getDayOfMonth()); // 日
System.out.println(nowDateTime.getHour()); // 时
System.out.println(nowDateTime.getMinute()); // 分
System.out.println(nowDateTime.getSecond()); // 秒
System.out.println(nowDateTime.getNano()); // 纳秒
// 日：当年的第几天
System.out.println("dayOfYear：" + nowDateTime.getDayOfYear()); // dayOfYear：249
// 星期
System.out.println(nowDateTime.getDayOfWeek());
System.out.println(nowDateTime.getDayOfWeek().getValue());
// 月份
System.out.println(nowDateTime.getMonth());
System.out.println(nowDateTime.getMonth().getValue());

// 转成 LocalDate 对象
LocalDate ld = nowDateTime.toLocalDate();
System.out.println(ld);
// 转成 LocalTime 对象
LocalTime lt = nowDateTime.toLocalTime();
System.out.println(lt.getHour());
System.out.println(lt.getMinute());
System.out.println(lt.getSecond());

修改相关的 API：

  • plusDays, plusWeeks, plusMonths, plusYears：向当前 LocalDate 对象添加几天、 几周、几个月、几年
  • minusDays, minusWeeks, minusMonths, minusYears：从当前 LocalDate 对象减去几天、 几周、几个月、几年
  • withDayOfMonth, withDayOfYear, withMonth, withYear：将月份天数、年份天数、月份、年份修改为指定的值并返回新的 LocalDate 对象
  • isBefore，isAfter：比较两个 LocalDate ```java LocalTime nowTime = LocalTime.now(); System.out.println(nowTime); // 当前时间 System.out.println(nowTime.minusHours(1)); // 一小时前 System.out.println(nowTime.minusMinutes(1)); // 一分钟前 System.out.println(nowTime.minusSeconds(1)); // 一秒前 System.out.println(nowTime.minusNanos(1)); // 一纳秒前

System.out.println(“————————“);

System.out.println(nowTime.plusHours(1)); // 一小时后 System.out.println(nowTime.plusMinutes(1)); // 一分钟后 System.out.println(nowTime.plusSeconds(1)); // 一秒后 System.out.println(nowTime.plusNanos(1)); // 一纳秒后

System.out.println(“—————————“);

// 不可变对象，每次修改产生新对象！ System.out.println(nowTime);

System.out.println(“———————-“); LocalDate myDate = LocalDate.of(2018, 9, 5); LocalDate nowDate = LocalDate.now();

System.out.println(“今天是 2018-09-06 吗？ “ + nowDate.equals(myDate)); // 今天是 2018-09-06 吗？ false System.out.println(myDate + “是否在” + nowDate + “之前？ “ + myDate.isBefore(nowDate));// 2018-09-05 是否在 2018-09-06 之前？ true System.out.println(myDate + “是否在” + nowDate + “之后？ “ + myDate.isAfter(nowDate));//2018-09-05 是否在 2018-09-06 之后？ false

System.out.println(“—————————————-“);

// 判断今天是否是你的生日 LocalDate birDate = LocalDate.of(1996, 8, 5); LocalDate nowDate1 = LocalDate.now();

MonthDay birMd = MonthDay.of(birDate.getMonthValue(), birDate.getDayOfMonth()); MonthDay nowMd = MonthDay.from(nowDate1);

System.out.println(“今天是你的生日吗？ “ + birMd.equals(nowMd)); // 今天是你的生日吗？ false

<a name="E0Yvy"></a>
### Instant 时间戳
Java 8 获取时间戳特别简单，且功能更丰富。Instant 类由一个静态的工厂方法 `now()` 可以返回当前时间戳。
```java
// 1、得到一个Instant时间戳对象
Instant instant = Instant.now();
System.out.println(instant);

// 2、系统此刻的时间戳怎么办？
Instant instant1 = Instant.now();
System.out.println(instant1.atZone(ZoneId.systemDefault()));

// 3、如何去返回Date对象
Date date = Date.from(instant);
System.out.println(date);

Instant i2 = date.toInstant();
System.out.println(i2);

DateTimeFormatter

在 Java 8中，引入了一个全新的日期与时间格式器 DateTimeFormatter。正反都能调用 format 方法

// 本地此刻  日期时间 对象
LocalDateTime ldt = LocalDateTime.now();
System.out.println(ldt);

// 解析/格式化器
DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss EEE a");
// 正向格式化
System.out.println(dtf.format(ldt));
// 逆向格式化
System.out.println(ldt.format(dtf));

// 解析字符串时间
DateTimeFormatter dtf1 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
// 解析当前字符串时间成为本地日期时间对象
LocalDateTime ldt1 = LocalDateTime.parse("2019-11-11 11:11:11", dtf1);
System.out.println(ldt1);
System.out.println(ldt1.getDayOfYear());

Duration、Period

  • 日期间隔差异：java.time.Period
  • 时间间隔差异：java.time.Duration

Period 类方法 getYears()，getMonths() 和 getDays() 来计算,只能精确到年月日。用于 LocalDate 之间的比较。

// 当前本地 年月日
LocalDate today = LocalDate.now();
System.out.println(today);//

// 生日的 年月日
LocalDate birthDate = LocalDate.of(1988, 1, 7);
System.out.println(birthDate);

Period period = Period.between(birthDate, today); // 第二个参数减第一个参数

System.out.println(period.getYears());
System.out.println(period.getMonths());
System.out.println(period.getDays());

Duration 提供了使用基于时间的值测量时间量的方法。用于 LocalDateTime 之间的比较。也可用于 Instant 之间的比较。

// 本地日期时间对象。
LocalDateTime today = LocalDateTime.now();
System.out.println(today);

// 出生的日期时间对象
LocalDateTime birthDate = LocalDateTime.of(2021, 8, 6, 1, 0, 0);

System.out.println(birthDate);

Duration duration = Duration.between(birthDate, today); // 第二个参数减第一个参数

System.out.println(duration.toDays()); // 两个时间差的天数
System.out.println(duration.toHours()); // 两个时间差的小时数
System.out.println(duration.toMinutes()); // 两个时间差的分钟数
System.out.println(duration.toMillis()); // 两个时间差的毫秒数
System.out.println(duration.toNanos()); // 两个时间差的纳秒数

ChronoUnit

ChronoUnit 类可用于在单个时间单位内测量一段时间，这个工具类是最全的了，可以用于比较所有的时间单位

// 本地日期时间对象：此刻的
LocalDateTime today = LocalDateTime.now();
System.out.println(today);

// 生日时间
LocalDateTime birthDate = LocalDateTime.of(1990, 10, 1, 10, 50, 59);
System.out.println(birthDate);

System.out.println("相差的年数：" + ChronoUnit.YEARS.between(birthDate, today));
System.out.println("相差的月数：" + ChronoUnit.MONTHS.between(birthDate, today));
System.out.println("相差的周数：" + ChronoUnit.WEEKS.between(birthDate, today));
System.out.println("相差的天数：" + ChronoUnit.DAYS.between(birthDate, today));
System.out.println("相差的时数：" + ChronoUnit.HOURS.between(birthDate, today));
System.out.println("相差的分数：" + ChronoUnit.MINUTES.between(birthDate, today));
System.out.println("相差的秒数：" + ChronoUnit.SECONDS.between(birthDate, today));
System.out.println("相差的毫秒数：" + ChronoUnit.MILLIS.between(birthDate, today));
System.out.println("相差的微秒数：" + ChronoUnit.MICROS.between(birthDate, today));
System.out.println("相差的纳秒数：" + ChronoUnit.NANOS.between(birthDate, today));
System.out.println("相差的半天数：" + ChronoUnit.HALF_DAYS.between(birthDate, today));
System.out.println("相差的十年数：" + ChronoUnit.DECADES.between(birthDate, today));
System.out.println("相差的世纪（百年）数：" + ChronoUnit.CENTURIES.between(birthDate, today));
System.out.println("相差的千年数：" + ChronoUnit.MILLENNIA.between(birthDate, today));
System.out.println("相差的纪元数：" + ChronoUnit.ERAS.between(birthDate, today));