Java中时间类型得整理
java的是时间类型我分为了 基础类跟新增类，基础类就是比较老的类库，但是java在1.8之后又新增了一些时间类型。
基础类：
这个部分整理一下，我们常用的时间类：
| 类 | 简述 |
|---|---|
| java.util.Date(父类) | 最基本的时间类 |
| java.sql.Date | 格式年月日，没有无参构造 |
| java.sql.time | 时分秒 |
| java.sql.Timestamp | 年月日时分秒毫秒 |
| java.util.Calendar(日历) | 可以表示年月日时分秒毫秒 |
| java.text.DateFormat | 时间可以格式化 |
1） java.util.Date的用法实例：
//基础构造器
//获取当前时间
Date date = new Date();
//传入一个偏移量，计算出距离1970年1月1日的00:00:00+偏移量个秒值的时间
Date date1 = new Date(1);
//传入一个年月日时分秒的偏移量，计算出距离1970年1月1日的00:00:00+偏移量中的年月日时分秒的时间
Date date2 = new Date(10, 10, 10, 10, 10, 10);
//常用方法
System.out.println("默认输出格式："+date1);
System.out.println("时间戳，距离1970年1月1日的00:00:00的毫秒数："+date1.getTime());
System.out.println("转化成Instance格式："+date1.toInstant());
System.out.println("判断是否在当前时间之后，结果"+date1.after(new Date()));
System.out.println("复制一个完全一样的date对象"+date1.clone());
2）java.sql.Time、java.sql.Time的用法实例
java.sql.Time、java.sql.Time就相当于java.util.Date的年月日和时分秒部分。
//没有无参构造器，需要传入一个偏移量，得到是距离1970年1月1日的00:00:00+偏移量个毫秒值的时间
//但是得到的时间 只有年月日 没有时分秒
java.sql.Date date = new java.sql.Date(100);
System.out.println("java.sql.Date 默认输出格式:"+date);
System.out.println("java.sql.Date转换为LocalDate:"+date.toLocalDate());
//也没有无参构造器，需要传入一个偏移量，得到是距离1970年1月1日的00:00:00+偏移量个毫秒值的时间
//但是得到的时间 只有时分秒 没有年月日
Time time = new Time(1000);
System.out.println("java.sql.Time 默认输出格式:"+time);
System.out.println("java.sql.Time 转换为LocalTime:"+time.toLocalTime());
3）java.sql.Timestamp 用法实例
//没有无参构造器,传入偏移量，计算出1970年1月1日的08:00:00+偏移量个毫秒值的时间
//并没有取当前时间，而是取的时间轴上1970年1月1日的00:00:00的某个时区的时间
Timestamp timestamp = new Timestamp(1);
System.out.println("timestamp"+timestamp);
System.out.println("纳秒值为："+timestamp.getNanos());
//设置纳秒值，注意不会在原来的时间上增加，会修改秒后面的纳秒值
timestamp.setNanos(1);
System.out.println("设置纳秒为1之后："+timestamp);
4)java.util.Calendar 用法实例
//实例化Calendar对象
Calendar calendar = Calendar.getInstance();;
System.out.println("默认输出格式："+calendar.getTime());
System.out.println("当前年份："+calendar.getWeekYear());
System.out.println("一年中第一周所需的最少天数:"+calendar.getMinimalDaysInFirstWeek());//我也不太懂这个到底是什么意思
System.out.println("一周的第一天:"+calendar.getFirstDayOfWeek());
System.out.println("时间戳:"+calendar.getTimeInMillis());
System.out.println("一年中有多少周："+calendar.getWeeksInWeekYear());
System.out.println("第一周所需的最少天数:"+calendar.getMinimalDaysInFirstWeek());
System.out.println("本月的最大天数："+calendar.getActualMaximum(Calendar.DATE));
System.out.println("当前年份："+calendar.get(Calendar.YEAR));
System.out.println("当前月份："+calendar.get(Calendar.MONTH));//实际月份要加1
System.out.println("当前日期："+calendar.get(Calendar.DATE));
System.out.println("本周的第几天："+calendar.get(Calendar.DAY_OF_WEEK));//第一天是周日
System.out.println("本月最大日期"+calendar.getMaximum(Calendar.DATE));
我感觉使用 Calendar的最大好处就是能将年月日时分秒都拆分开，单独使用，而且也便于分开计算各个数值，还有其他用法可自行查阅。
Calendar常用的方法的返回结果 获取指定时间点_calendar.get(calendar.year)-CSDN博客
java getActualMaximum()方法-CSDN博客
5）java.text.SimpleDateFormat用法实例
Date dNow = new Date( );
SimpleDateFormat ft = new SimpleDateFormat ("yyyy-MM-dd hh:mm:ss");
System.out.println("当前时间为: " + ft.format(dNow));
这一行代码确立了转换的格式，其中 yyyy 是完整的公元年，MM 是月份，dd 是日期，HH:mm:ss 是时、分、秒。
注意:有的格式大写，有的格式小写，例如 MM 是月份，mm 是分；HH 是 24 小时制，而 hh 是 12 小时制。
以上实例编译运行结果如下:
日期和时间的格式化编码
时间模式字符串用来指定时间格式。在此模式中，所有的 ASCII 字母被保留为模式字母，定义如下：
其中的类型为：
- Text: 对于格式化，如果模式字母的数量是4以上，则使用完整的形式; 否则，如果有的话，使用简短或缩写形式。 对于解析，两种形式都是接受的，与模式字母的数量无关。
| 1 2 3 4 5 6 7 8 9 |
|
- Number: 对于格式化，模式字母的数量是最小位数，而较短的数字将零填充到此数量。 对于解析，模式字母的数量将被忽略，除非需要分隔两个相邻的字段。
| 1 2 3 4 5 6 7 8 9 |
|
- Year:对于格式化，如果模式字母数为2，那么年份将被截断为2位数; 否则被解释为Number(不足补0)
| 1 2 3 4 5 6 7 8 9 10 11 |
|
- Month: 如果模式字母数为3以上，则该月份被解释为text; 否则，它被解释为number
| 1 2 3 4 5 6 7 8 9 10 11 |
|
其他的类型和时区有关，暂时不去做描述先知道上面的常见的几个
举个常见的例子：
| 1 2 |
|
常用方法 parse,format
| 1 2 3 4 5 6 7 |
|
新日期格式：
相对来说,底下的时间是没有偏移量的比如1就代表周一，然后还是线程安全的
LocalDate,LocalTime,LocalDateTime用法实例：
LocalDate date = LocalDate.now();
LocalTime time = LocalTime.now();
LocalDateTime dateTime = LocalDateTime.now();
System.out.println("当前日期："+ date);
System.out.println("当前时间："+ time);
System.out.println("当前时间+日期："+ dateTime);
LocalDate date1 = LocalDate.of(2022, 12, 12);
LocalTime time1 = LocalTime.of(12, 12, 12);
LocalDateTime dateTime1 = LocalDateTime.of(2022, 12, 12, 12, 12, 12);
System.out.println("指定时间："+date1);
System.out.println("指定日期："+time1);
System.out.println("指定日期+时间："+dateTime1);
System.out.println("当前年份："+date.getYear());
System.out.println("当前月份(英文)："+date.getMonth());
System.out.println("当前月份(数字)："+date.getMonthValue());
System.out.println("使用中的日历系统的此日期的时间顺序："+date.getChronology());//不太懂什么用法
System.out.println("当前是本月的哪一天："+date.getDayOfMonth());
System.out.println("当前周几（英文）："+date.getDayOfWeek());
System.out.println("当前是本周的第几天："+date.getDayOfWeek().getValue());
System.out.println("当前是本年中的第几天："+date.getDayOfYear());
System.out.println("纪元常数："+date.getEra());//也不太清楚什么用法
System.out.println("当前月份有多少天："+date.lengthOfMonth());
System.out.println("当前年份有多少天："+date.lengthOfYear());
System.out.println("当前年份是否是闰年："+date.isLeapYear());
//with重新赋值，原值不变
LocalDate date2 = date.withYear(2022);
System.out.println("重新赋值后："+date2);
System.out.println("本月第一天："+date.with(TemporalAdjusters.firstDayOfMonth()));
System.out.println("本月最后一天："+date.with(TemporalAdjusters.lastDayOfMonth()));
//加减操作
System.out.println("增加一个月份之后："+date.plusMonths(1));
System.out.println("减少两个月份之后："+date.minusMonths(2));
System.out.println("增加一年二个月："+date.plus(Period.of(1, 2, 0)));
关于TemporalAdjusters的一些简介：
TemporalAdjusters 是 Java 8 中的一个实用工具类，它提供了一些内置的、用于日期时间调整的工具方法。这些方法允许你进行复杂的日期时间调整操作，如获取某月的第一天、获取下一个星期一、获取年底最后一天等。TemporalAdjusters 中的方法返回 TemporalAdjuster 对象，这是一个函数式接口，用于在 java.time 框架中进行日期时间的调整。以下是一些常见的 TemporalAdjusters 方法及其功能：
firstDayOfMonth()：返回指定日期所在月份的第一天。
lastDayOfMonth()：返回指定日期所在月份的最后一天。
firstDayOfNextMonth()：返回指定日期下个月的第一天。
firstDayOfNextYear()：返回指定日期下一年的第一天。
next(DayOfWeek dayOfWeek)：返回指定日期之后的下一个星期几。例如，next(DayOfWeek.MONDAY) 返回下一个星期一。
previous(DayOfWeek dayOfWeek)：返回指定日期之前的上一个星期几。
nextOrSame(DayOfWeek dayOfWeek)：返回指定日期，如果它是指定星期几，则返回它本身，否则返回下一个指定星期几。
previousOrSame(DayOfWeek dayOfWeek)：返回指定日期，如果它是指定星期几，则返回它本身，否则返回上一个指定星期几。
firstInMonth(DayOfWeek dayOfWeek)：返回指定日期所在月份的第一个指定星期几。
lastInMonth(DayOfWeek dayOfWeek)：返回指定日期所在月份的最后一个指定星期几。
dayOfWeekInMonth(int ordinal, DayOfWeek dayOfWeek)：返回指定日期所在月份的第 ordinal 个指定星期几。例如，dayOfWeekInMonth(2, DayOfWeek.WEDNESDAY) 返回指定日期所在月份的第二个星期三。
firstDayOfYear()：返回指定日期所在年份的第一天。
lastDayOfYear()：返回指定日期所在年份的最后一天。
时间间隔的计算：
//Duration:用于计算两个“时间”间隔，是总共的相差多少时间
//Duration.between方法必须支持秒数，如果没有的话将会报错。
//日期大的放后面
LocalDateTime dateTime = LocalDateTime.now();
LocalDateTime of = LocalDateTime.of(2022, 12, 12, 12, 12,12,12);
Duration between = Duration.between(of, dateTime);
System.out.println(dateTime + " 与 " + of + " 间隔 " + "\n"
+ " 天 :" + between.toDays() + "\n"
+ " 时 :" + between.toHours() + "\n"
+ " 分 :" + between.toMinutes() + "\n"
+ " 毫秒 :" + between.toMillis() + "\n"
+ " 纳秒 :" + between.toNanos() + "\n"
);
//Period:用于计算两个“日期”间隔,注意只是每个年月日上每个单位上的相加减，并不是总天数
LocalDate nowDate = LocalDate.now();
System.out.println("period当前时间：" + nowDate);
LocalDate OfDate = LocalDate.of(2020, 10, 15);
System.out.println("period自定义时间：" + OfDate);
//Period:用于计算两个“日期”间隔
//日期大的放后面
Period period = Period.between(OfDate, nowDate);
System.out.println("Period相差年数 ： " + period.getYears());
System.out.println("Period相差月数 ： " + period.getMonths());
System.out.println("Period相差日数 ： " + period.getDays());
//还可以这样获取相差的年月日
System.out.println("-------------------------------");
long years = period.get(ChronoUnit.YEARS);
long months = period.get(ChronoUnit.MONTHS);
long days = period.get(ChronoUnit.DAYS);
System.out.println("Period相差的年月日分别为 ： " + years + "," + months + "," + days);
//注意，Period不太好用，返回并不是总的相差多少，而只是单纯的用年月日的参数相减而已ChronoUnit：
这个是个枚举类型，实现功能类型Period和Duration，但如果我们看它的底层实现，就可以看到它基本是基于Duration来实现的。这个枚举很简单，我们直接看一些例子就可以了：
LocalDateTime oldDate = LocalDateTime.of(2017, Month.AUGUST, 31, 10, 20, 55);
LocalDateTime newDate = LocalDateTime.of(2018, Month.NOVEMBER, 9, 10, 21, 56);
System.out.println(oldDate);
System.out.println(newDate);
// count between dates
long years = ChronoUnit.YEARS.between(oldDate, newDate);
long months = ChronoUnit.MONTHS.between(oldDate, newDate);
long weeks = ChronoUnit.WEEKS.between(oldDate, newDate);
long days = ChronoUnit.DAYS.between(oldDate, newDate);
long hours = ChronoUnit.HOURS.between(oldDate, newDate);
long minutes = ChronoUnit.MINUTES.between(oldDate, newDate);
long seconds = ChronoUnit.SECONDS.between(oldDate, newDate);
long milis = ChronoUnit.MILLIS.between(oldDate, newDate);
long nano = ChronoUnit.NANOS.between(oldDate, newDate);
System.out.println("\n--- Total --- ");
System.out.println(years + " years");
System.out.println(months + " months");
System.out.println(weeks + " weeks");
System.out.println(days + " days");
System.out.println(hours + " hours");
System.out.println(minutes + " minutes");
System.out.println(seconds + " seconds");
System.out.println(milis + " milis");
System.out.println(nano + " nano");
日期格式化:
DateTimeFormatter:
这个主要可以用来进行String 和 LocalXXX之间的转化，案例:
//将日期转换为字符串
LocalDateTime now = LocalDateTime.now();
DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss:SSS");
String format = dtf.format(now);
System.out.println("日期转换为字符串："+format);
//将时间日期对象转为格式化后的时间日期对象
//新的格式化API中，格式化后的结果都默认是String，有时我们也需要返回经过格式化的同类型对象
LocalDateTime ldt1 = LocalDateTime.now();
DateTimeFormatter dtf1 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String temp = dtf1.format(ldt1);
LocalDateTime formatedDateTime = LocalDateTime.parse(temp, dtf1);
System.out.println("字符串转换为日期："+formatedDateTime);日期转换：
java.util.Date与LocalDate，LocalTime，LocalDateTime替换：
将Date转换为LocalDate，LocalTime，LocalDateTime可以借助于ZonedDateTime和Instant，实现如下：
//date转localXXX
Date date = new Date();
System.out.println("current date: " + date);
// Date -> LocalDateTime
LocalDateTime localDateTime = date.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime();
System.out.println("localDateTime by Instant: " + localDateTime);
// Date -> LocalDate
LocalDate localDate = date.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
System.out.println("localDate by Instant: " + localDate);
// Date -> LocalTime
LocalTime localTime = date.toInstant().atZone(ZoneId.systemDefault()).toLocalTime();
System.out.println("localTime by Instant: " + localTime);
//2. Date -> LocalDateTime
localDateTime = LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault());
System.out.println("localDateTime by ofInstant: " + localDateTime);
//LcoalXXX转Date
Date date1 = new Date();
LocalDate localDate1 = date1.toInstant().atZone(ZoneOffset.systemDefault()).toLocalDate();
System.out.println(localDate1);
LocalDateTime localDateTime1 = date1.toInstant().atZone(ZoneOffset.systemDefault()).toLocalDateTime();
System.out.println(localDateTime1);
由于JDK8实现了向下兼容，所以Date里在JDK8版本引入了2个方法，from 和
toInstant，所以我们可以借助这两个方法来实现LocalDateTime到Date的转换。将LocalDateTime转为Date如下：
LocalDateTime localDateTime = LocalDateTime.now();
System.out.println("localDateTime: " + localDateTime);
// LocalDateTime -> Date
Date date = Date.from(localDateTime.atZone(ZoneId.systemDefault()).toInstant());
System.out.println("LocalDateTime -> current date: " + date);
// LocalDate -> Date，时间默认都是00
LocalDate localDate = LocalDate.now();
date = Date.from(localDate.atStartOfDay(ZoneId.systemDefault()).toInstant());
System.out.println("LocalDate -> current date: " + date);
而单独的LocalTime转为Date没什么意义，所以如果LocalTime要转为Date，一般借助于LocalDate和LocalDateTime来实现就可以了。
localDate 转 时间戳:
//lcoalDate转时间戳
LocalDate localDate = LocalDate.now();
long instant = localDate.atStartOfDay(ZoneOffset.systemDefault()).toInstant().toEpochMilli();
System.out.println("localDate转成时间戳为："+instant);
LocalDateTime now = LocalDateTime.now();
long instant1 = now.toInstant(ZoneOffset.ofHours(8)).toEpochMilli();
System.out.println("LocalDateTime转成时间戳为："+instant1);
//时间戳转lcoaldate
long time = System.currentTimeMillis();
LocalDateTime localDateTime = Instant.ofEpochMilli(time).atZone(ZoneOffset.systemDefault()).toLocalDateTime();
System.out.println("当前时间戳转为localDateTime："+localDateTime);
LocalDate localDate1 = Instant.ofEpochMilli(time).atZone(ZoneOffset.systemDefault()).toLocalDate();
System.out.println("当前时间戳转为localDate:"+localDate1);
LocalDate类：JAVA中的日期详解_localdate 年月-CSDN博客
LocalDate详解-CSDN博客
java中日期的换算处理_51CTO博客_java日期转换
Java——日期时间（SimpleDateFormat）-CSDN博客
java的时间类汇总(齐全)_java_脚本之家
日期比较：
Java使用以下三种方法来比较两个日期：
1、使用 getTime() 方法获取两个日期（自1970年1月1日经历的毫秒数值），然后比较这两个值。
2、使用方法 before()，after() 和 equals()。例如，一个月的12号比18号早，则 new Date(99, 2, 12).before(new Date (99, 2, 18)) 返回true。
3、使用 compareTo() 方法，它是由 Comparable 接口定义的，Date 类实现了这个接口。
时间戳：
时间戳（timestamp）是指某个时间点相对于一个固定的起始点（通常是格林威治时间1970年1月1日00:00:00）所经过的秒数或毫秒数。在Java中，时间戳常用来表示和处理时间相关的数据。
时间戳的三种获取方式：
System.out.println(System.currentTimeMillis()); // 推荐使用
System.out.println(new Date().getTime());
System.out.println(Calendar.getInstance().getTimeInMillis());根据时间戳计算相隔多少分钟：
(end.getTime() - start.getTime())/(1000*60);Java8 中的 LocalDateTime 默认格式化字符串中为什么会有个T？
嗯，先看看LocalDateTime#toString()方法的实现吧：
/**
* Outputs this date-time as a {@code String}, such as {@code 2007-12-03T10:15:30}.
*
* The output will be one of the following ISO-8601 formats:
*
* - {@code uuuu-MM-dd'T'HH:mm}
* - {@code uuuu-MM-dd'T'HH:mm:ss}
* - {@code uuuu-MM-dd'T'HH:mm:ss.SSS}
* - {@code uuuu-MM-dd'T'HH:mm:ss.SSSSSS}
* - {@code uuuu-MM-dd'T'HH:mm:ss.SSSSSSSSS}
*
* The format used will be the shortest that outputs the full value of
* the time where the omitted parts are implied to be zero.
*
* @return a string representation of this date-time, not null
*/
@Override
public String toString() {
return date.toString() + 'T' + time.toString();
}可以看到这个字符'T'是故意加进去的，目的是为了遵循ISO-8601日期时间格式标准；关于ISO-8601格式标准，
其中对于‘T’的描述：
Outputs this date-time as a String, such as 2007-12-03T10:15:30.
The output will be one of the following ISO-8601 formats:
uuuu-MM-dd'T'HH:mm
uuuu-MM-dd'T'HH:mm:ss
uuuu-MM-dd'T'HH:mm:ss.SSS
uuuu-MM-dd'T'HH:mm:ss.SSSSSS
uuuu-MM-dd'T'HH:mm:ss.SSSSSSSSS
The format used will be the shortest that outputs the full value of the time where the omitted parts are implied to be zero.
返回值:
a string representation of this date-time, not null
'T'用于标示时间的开始。所以遇到问题，研读代码再通过注释深入挖掘就能找到问题的答案。