日期相关工具类

fixAllenSun

已于 2024-04-08 23:28:41 修改

阅读量450

点赞数 2

文章标签： java 开发语言

于 2023-10-07 14:04:38 首次发布

本文链接：https://blog.csdn.net/weixin_44823875/article/details/133637656

版权

日期相关工具类

【一】介绍
- 【1】SimpleDateFormat 为什么是线程不安全
- 【2】解决 SimpleDateFormat 线程不安全的方法
【二】LocalDate API
【三】LocalTime API
【四】LocalDateTime API
【五】转换关系
【六】LocalDateTime使用实例
【七】其他方式获取当前时间
【八】获取当前日期和前一周、前一月、前一年的日期
【九】获取当天的开始时间和结束时间
- 【1】LocalDateTime
- 【2】DateUtil获取DateTime
【十】计算日期的时间差
【十一】判断一个日期是否是月末

【一】介绍

Java 中 1.8 之前有 date 类，date 类到了 1.8 大部分的方法被弃而且 date 类如果不格式化可读性十分差，而 simpledateformat 方法中 format 和 parse 方法都是线程不安全的。

1.8 之后出现了 localdate、localdatetime、localtime 这些类，而这些类使用了 final 来修饰，使得这些类是不可变的，一旦实例化，值就固定了，有点类似于 String 类，所以这些类都是线程安全的。

localdate 年月日、localtime 时分秒、localdatetime 年月日时分秒

【1】SimpleDateFormat 为什么是线程不安全

SimpleDateFormat 类主要负责日期的转换与格式化等操作，在多线程的环境中，使用此类容易造成数据转换及处理的不正确，因为 SimpleDateFormat 类并不是线程安全的，但在单线程环境下是没有问题的。

SimpleDateFormat 在类注释中也提醒大家不适用于多线程场景：
在这里插入图片描述
说的很清楚，SimpleDateFormat 不是线程安全的，多线程下需要为每个线程创建不同的实例。不安全的原因是因为使用了 Calendar 这个全局变量

在这里插入图片描述

format 方法在执行中，会操作成员变量 calendar 来保存时间 calendar.setTime(date) 。如果 SimpleDateFormat 是一个共享变量，SimpleDateFormat 中的 calendar 也就可以被多个线程访问到，所以问题就出现了。除了 format 方法以外，SimpleDateFormat 的 parse 方法也有同样的问题。至此，我们发现了 SimpleDateFormat 的弊端，所以为了解决这个问题就是不要把 SimpleDateFormat 当做一个共享变量来使用。

【2】解决 SimpleDateFormat 线程不安全的方法

（1）每次使用就创建一个新的 SimpleDateFormat

class DateUtils {
    public static Date parse(String formatPattern, String datestring) throws ParseException {
        return new SimpleDateFormat(formatPattern).parse(datestring);
    }

    public static String format(String formatPattern, Date date) {
        return new SimpleDateFormat(formatPattern).format(date);
    }
}

（2）加锁

class DateUtils {
    private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("mm:ss");

    public static Date parse(String formatPattern, String datestring) throws ParseException {
        synchronized (simpleDateFormat) {
            return simpleDateFormat.parse(datestring);
        }

    }

    public static String format(String formatPattern, Date date) {
        synchronized (simpleDateFormat) {
            return simpleDateFormat.format(date);
        }
    }
}

（3）使用ThreadLocal

class DateUtils {
    private static ThreadLocal<DateFormat> threadLocal = new ThreadLocal<DateFormat>() {
        @Override
        protected DateFormat initialValue() {
            return new SimpleDateFormat("mm:ss");
        }
    };

    public static Date parse(String formatPattern, String datestring) throws ParseException {
        return threadLocal.get().parse(datestring);
    }

    public static String format(String formatPattern, Date date) {
        return threadLocal.get().format(date);
    }
}

（4）Java 8 引入了新的日期时间 API，并引入了线程安全的日期类
1-Instant：瞬时实例。
2-LocalDate：本地日期，不包含具体时间例如：2014-01-14 可以用来记录生日、纪念日、加盟日等。
3-LocalTime：本地时间，不包含日期。
4-LocalDateTime：组合了日期和时间，但不包含时差和时区信息。
5-ZonedDateTime：最完整的日期时间，包含时区和相对UTC或格林威治的时差。

新 API 还引入了 ZoneOffSet 和 ZoneId 类，使得解决时区问题更为简便。

【二】LocalDate API

LocalDate类的实例是一个不可变对象，它只提供了简单的日期，并不含当天的时间信息，这个类是不可变的和线程安全的。

now 根据当前时间创建LocalDate对象
of 根据指定年月日创建LocalDate对象
getYear 获得年份
getMonthValue 获得月份
getMonth 获得月份枚举值
getDayOfMonth 获得月份天数（1-31）
getDayOfWeek 获得星期几
getDayOfYear 获得年份中的第几天（1-366）
lengthOfYear 获得当年总天数
lengthOfMonth 获得当月总天数
toEpochDay 与时间纪元（1970年1月1日）相差的天数
plusDays 加天
plusWeeks 加周
plusMonths 加月
plusYears 加年
minusDays 减年
minusWeeks 减周
minusMonths 减月
minusYears 减年
withYear 替换年份
withYear 替换年份
withDayOfMonth 替换日期
withDayOfYear 替换日期
isBefore 是否日期在之前
isAfter 是否日期在之后
isEqual 是否是当前日期
isleapYear 是否是闰年

代码示例

// A.获取
//（1）获取当前日期 2022-04-20
System.out.println(LocalDate.now());
//（2）获取指定日期 2014-03-18
System.out.println(LocalDate.of(2014, 3, 18));
//（3）获取日期的年份 2022
System.out.println(LocalDate.now().getYear());
//（4）获取日期的月份 4
System.out.println(LocalDate.now().getMonthValue());
//（5）获取日期的日子 20
System.out.println(LocalDate.now().getDayOfMonth());
//（6）获取日期的星期 WEDNESDAY
System.out.println(LocalDate.now().getDayOfWeek());
//（7）当天所在这一年的第几天 110
System.out.println(LocalDate.now().getDayOfYear());
//（8）获取当年天数 365
System.out.println(LocalDate.now().lengthOfYear());
//（9）获取当月天数 30
System.out.println(LocalDate.now().lengthOfMonth());
//（10）与时间纪元（1970年1月1日）相差的天数，负数表示在时间纪元之前多少天 19102
System.out.println(LocalDate.now().toEpochDay());

// B.运算
//（1）加一天
System.out.println("加1天：" + LocalDate.now().plusDays(1));
//（2）加一周
System.out.println("加1周：" + LocalDate.now().plusWeeks(1));
//（3）加一月
System.out.println("加1月：" + LocalDate.now().plusMonths(1));
//（4）加一年
System.out.println("加1年：" + LocalDate.now().plusYears(1));
//（5）减一天
System.out.println("减1天：" + LocalDate.now().minusDays(1));
//（6）减一周
System.out.println("减1周：" + LocalDate.now().minusWeeks(1));
//（7）减一月
System.out.println("减1月：" + LocalDate.now().minusMonths(1));
//（8）减一年
System.out.println("减1年：" + LocalDate.now().minusYears(1));

// C.替换
//（1）替换年份
System.out.println("替换年份为1：" + LocalDate.now().withYear(1));
//（2）替换月份
System.out.println("替换月份为1：" + LocalDate.now().withMonth(1));
//（3）替换日子
System.out.println("替换日期为1：" + LocalDate.now().withDayOfMonth(1));
//（4）替换天数
System.out.println("替换天数为1：" + LocalDate.now().withDayOfYear(1));
 
// D.比较
//（1）是否在当天之前
System.out.println("是否在当天之前：" + LocalDate.now().minusDays(1).isBefore(LocalDate.now()));
//（2）是否在当天之后
System.out.println("是否在当天之后：" + LocalDate.now().plusDays(1).isAfter(LocalDate.now()));
//（3）是否在当天
System.out.println("是否在当天：" + LocalDate.now().isEqual(LocalDate.now()));
//（4）是否是闰年
System.out.println("今年是否是闰年：" + LocalDate.now().isLeapYear());

【三】LocalTime API

LocalTime是一个不可变的时间对象，代表一个时间，格为时 - 分 - 秒，时间表示为纳秒精度，这个类是不可变的和线程安全的。

static LocalTime now() 获取默认时区的当前时间
static LocalTime now(ZoneId zone) 获取指定时区的当前时间
static LocalTime now(Clock clock) 从指定时钟获取当前时间
of 根据指定的时、分、秒获取LocalTime 实例
getHour 获取小时字段
getMinute 获取分钟字段
getSecond 获取秒字段
getNano 获取纳秒字段
plusHours 增加小时数
plusMinutes 增加分钟数
plusSeconds 增加秒数
plusNanos 增加纳秒数
minusHours 减少小时数
minusMinutes 减少分钟数
minusSeconds 减少秒数
minusNanos 减少纳秒数
compareTo 时间与另一个时间比较
isAfter 检查时间是否在指定时间之后
isBefore 检查时间是否在指定时间之前

// A.获取
//（1）获取默认时区的当前时间 14:11:31.294
System.out.println(LocalTime.now());
//（2）获取指定时区的当前时间 14:11:31.392
System.out.println(LocalTime.now(ZoneId.of("Asia/Shanghai")));
//（3）从指定时钟获取当前时间 14:11:31.392
System.out.println(LocalTime.now(Clock.systemDefaultZone()));
//（4）指定获取时分秒
System.out.println(LocalTime.of(12, 30, 30));
//（5）指定获取时分
System.out.println(LocalTime.of(12, 30));
//（6）指定获取时分秒纳秒
System.out.println(LocalTime.of(12, 30, 30, 123));
//（7）获取小时字段
System.out.println("时: " + LocalTime.now().getHour());
//（8）获取分钟字段
System.out.println("时: " + LocalTime.now().getMinute());
//（9）获取秒字段
System.out.println("时: " + LocalTime.now().getSecond());
//（10）获取纳秒字段
System.out.println("时: " + LocalTime.now().getNano());

// B.计算
//（1）增加一小时
System.out.println("增加1小时: " + LocalTime.now().plusHours(1));
//（2）增加三十分钟
System.out.println("增加30分钟: " + LocalTime.now().plusMinutes(30));
//（3）增加三十秒
System.out.println("增加30秒: " + LocalTime.now().plusSeconds(30));
//（4）增加一万纳秒
System.out.println("增加10000纳秒:" + LocalTime.now().plusNanos(10000));
//（5）减少一小时
System.out.println("减少1小时: " + LocalTime.now().minusHours(1));
//（6）减少三十分钟
System.out.println("减少30分钟: " + LocalTime.now().minusMinutes(30));
//（7）减少三十秒
System.out.println("减少30秒: " + LocalTime.now().minusSeconds(30));
//（8）减少一万纳秒
System.out.println("减少10000纳秒:" + LocalTime.now().minusNanos(10000));

// C.比较
//（1）时间与另一个时间比较 0（相等）正数（大）负数（小）
System.out.println(LocalTime.now().compareTo(LocalTime.now()));
//（2）检查时间是否在指定时间之后
System.out.println(LocalTime.now().isAfter(LocalTime.now()));
//（3）检查时间是否在指定时间之前
System.out.println(LocalTime.now().isBefore(LocalTime.now()));

【四】LocalDateTime API

LocalDateTime是一个不可变的日期时间对象，代表日期时间，格式为年 - 月 - 日 - 时 - 分 - 秒，这个类是不可变的和线程安全的。

static LocalDateTime now() 获取默认时区的当前日期时间
static LocalDateTime now(Clock clock) 从指定时钟获取当前日期时间
static LocalDateTime now(ZoneId zone) 获取指定时区的当前日期时间
static LocalDateTime of(LocalDate date, LocalTime time) 根据日期和时间对象获取LocalDateTime 实例
static LocalDateTime of(int year, Month month, int dayOfMonth, int hour, int minute, int second) second) 根据指定的年、月、日、时、分、秒获取LocalDateTime 实例
getYear 获取年份
getMonth 使用月份枚举类获取月份
getDayOfMonth 获取日期在该月是第几天
getDayOfWeek 获取日期是星期几
getDayOfYear 获取日期在该年是第几天
getHour 获取小时
getMinute 获取分钟
getSecond 获取秒
getNano 获取纳秒
plusYears 增加年
plusMonths 增加月
plusWeeks 增加周
plusDays 增加天
plusHours 增加小时
plusMinutes 增加分
plusSeconds 增加秒
plusNanos 增加纳秒
minusYears 减少年
minusMonths 减少月
meminusWeeks 减少周
minusDays 减少天
minusHours 减少小时
minusMinutes 减少分
minusSeconds 减少秒
minusNanos 减少纳秒
isEqual 判断日期时间是否相等
isBefore 检查是否在指定日期时间之前
isAfter 检查是否在指定日期时间之后
toLocalDate 获取日期部分
toLocalTime 获取时间部分

代码示例

// A.获取
//（1）获取默认时区的当前日期时间
System.out.println(LocalDateTime.now());
//（2）获取指定时区的当前日期时间
System.out.println(LocalDateTime.now(ZoneId.of("Asia/Shanghai")));
//（3）从指定时钟获取当前日期时间
System.out.println(LocalDateTime.now(Clock.systemDefaultZone()));
//（4）根据日期和时间对象获取LocalDateTime实例
System.out.println(LocalDateTime.of(LocalDate.now(), LocalTime.now()));
//（5）根据指定的年、月、日、时、分、秒获取LocalDateTime实例
System.out.println(LocalDateTime.of(2019, 12, 7, 21, 48, 50));
//（6）获取年份
System.out.println("年 : " + LocalDateTime.now().getYear());
//（7）使用月份枚举类获取月份
System.out.println("月（英文） : " + LocalDateTime.now().getMonth());
//（8) 使用月份数字类获取月份
System.out.println(" 月（数字英文）: " + LocalDateTime.now().getMonth().getValue());
//（9）获取日期在该月是第几天
System.out.println("天 : " + LocalDateTime.now().getDayOfMonth());
//（10）获取日期是星期几（英文）
System.out.println("星期几（英文） : " + LocalDateTime.now().getDayOfWeek());
//（11）获取日期是星期几（数字英文）
System.out.println("星期几（数字英文） : " + LocalDateTime.now().getDayOfWeek().getValue());
//（12）获取日期在该年是第几天
System.out.println("本年的第几天 : " + LocalDateTime.now().getDayOfYear());
//（13）获取小时
System.out.println("时: " + LocalDateTime.now().getHour());
//（14）获取分钟
System.out.println("分: " + LocalDateTime.now().getMinute());
//（15）获取秒
System.out.println("秒: " + LocalDateTime.now().getSecond());
//（16）获取纳秒
System.out.println("纳秒: " + LocalDateTime.now().getNano());
//（17）获取日期部分
System.out.println(LocalDateTime.now().toLocalDate());
//（18）获取时间部分
System.out.println(LocalDateTime.now().toLocalTime());

// B.计算
//（1）增加天数
System.out.println("增加天数 : " + LocalDateTime.now().plusDays(1));
//（2）增加周数
System.out.println("增加周数 : " + LocalDateTime.now().plusWeeks(1));
//（3）增加月数
System.out.println("增加月数 : " + LocalDateTime.now().plusMonths(1));
//（4）增加年数
System.out.println("增加年数 : " + LocalDateTime.now().plusYears(1));
//（5）减少天数
System.out.println("减少天数 : " + LocalDateTime.now().minusDays(1));
//（6）减少月数
System.out.println("减少月数 : " + LocalDateTime.now().minusMonths(1));
//（7）减少周数
System.out.println("减少周数 : " + LocalDateTime.now().minusWeeks(1));
//（8）减少年数
System.out.println("减少年数 : " + LocalDateTime.now().minusYears(1));
//（9）增加小时
System.out.println("增加1小时: " + LocalDateTime.now().plusHours(1));
//（10）增加分钟
System.out.println("增加30分钟: " + LocalDateTime.now().plusMinutes(30));
//（11）增加秒数
System.out.println("增加30秒: " + LocalDateTime.now().plusSeconds(30));
//（12）增加纳秒
System.out.println("增加10000纳秒:" + LocalDateTime.now().plusNanos(10000));
//（13）减少小时
System.out.println("减少1小时:" + LocalDateTime.now().minusHours(1));
//（14）减少分钟
System.out.println("减少30分钟:" + LocalDateTime.now().minusMinutes(30));
//（15）减少秒数
System.out.println("减少30秒: " + LocalDateTime.now().minusSeconds(30));
//（16）减少纳秒
System.out.println("减少10000纳秒:" + LocalDateTime.now().minusNanos(10000));

// C.比较
//（1）判断日期时间是否相等
System.out.println(LocalDateTime.now().isEqual(LocalDateTime.now()));
//（2）检查是否在指定日期时间之前
System.out.println(LocalDateTime.now().isBefore(LocalDateTime.now()));
//（3）检查是否在指定日期时间之后
System.out.println(LocalDateTime.now().isAfter(LocalDateTime.now()));

【五】转换关系

【1】LocalDateTime 与 LocalDate 之间的转换

//（1）LocalDateTime转化为LocalDate
LocalDateTime localDateTime = LocalDateTime.now();
LocalDate localDate = localDateTime.toLocalDate();
System.out.println(localDate);

//（2）LocalDate转化为LocalDateTime
LocalDate localDate = LocalDate.now();
LocalDateTime localDateTime1 = localDate.atStartOfDay();
LocalDateTime localDateTime2 = localDate.atTime(8,20,33);
LocalDateTime localDateTime3 = localDate.atTime(LocalTime.now());

System.out.println(localDateTime1);
System.out.println(localDateTime2);
System.out.println(localDateTime3);

【2】LocalDateTime 与 Date 之间的转换

//（1）LocalDateTime转化为Date
LocalDateTime localDateTime = LocalDateTime.now();
Date date = Date.from(localDateTime.atZone(ZoneId.systemDefault()).toInstant());
System.out.println(date);

//（2）Date转化为LocalDateTime
Date todayDate = new Date();
LocalDateTime ldt = todayDate.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime();
System.out.println(ldt);

【3】LocalDate 与 Date 之间的转换

//（1）localDate转化为Date
LocalDate localDate = LocalDate.now();
ZoneId zoneId = ZoneId.systemDefault();
Date date = Date.from(localDate.atStartOfDay().atZone(zoneId).toInstant());
System.out.println(date);

//（2）Date转化为localDate
Date date1 = new Date();
ZoneId zoneId1 = ZoneId.systemDefault();
LocalDate localDate1 = date1.toInstant().atZone(zoneId1).toLocalDate();
System.out.println(localDate1);

【4】LocalDate 与 String 之间的转换

//（1）从文本字符串获取LocalDate实例
LocalDate localdate = LocalDate.parse("2022-04-21");
System.out.println(localdate);

//（2）使用特定格式化形式从文本字符串获取LocalDate实例
String str = "2019-03-03";
DateTimeFormatter fmt1 = DateTimeFormatter.ofPattern("yyyy-MM-dd");
LocalDate date = LocalDate.parse(str, fmt1);
System.out.println(date);

//（3）使用特定格式化形式将LocalDate转为字符串
LocalDate today = LocalDate.now();
DateTimeFormatter fmt = DateTimeFormatter.ofPattern("yyyy/MM/dd");
String dateStr = today.format(fmt);
System.out.println(dateStr);

【5】LocalTime 与 String 之间的转换

// （1）字符串转为LocalTime
LocalTime localdate = LocalTime.parse("12:01:02");
System.out.println(localdate);

// （2）使用特定格式化将字符串转为LocalTime
DateTimeFormatter fmt1 = DateTimeFormatter.ofPattern("HH:mm:ss");
LocalTime date = LocalTime.parse("12:01:02", fmt1);
System.out.println(date);

// （3）LocalTime转为字符串
LocalTime toTime = LocalTime.now();
DateTimeFormatter fmt = DateTimeFormatter.ofPattern("HH:mm:ss");
String dateStr = toTime.format(fmt);
System.out.println(dateStr);

【6】LocalDateTime 与 String 之间的转换

//（1）字符串转为LocalDateTime
LocalDateTime ldt2 = LocalDateTime.parse("2019-12-07T21:20:06.303995200");
System.out.println(ldt2);

//（2）使用特定格式化将字符串转为LocalDateTime
DateTimeFormatter df1 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
LocalDateTime ldt3 = LocalDateTime.parse("2019-12-07 21:20:06", df1);
System.out.println(ldt3);

//（3）LocalDateTime转为字符串
LocalDateTime today = LocalDateTime.now();
DateTimeFormatter fmt = DateTimeFormatter.ofPattern("yyyy/MM/dd");
String dateStr = today.format(fmt);
System.out.println(dateStr);

【7】使用DateUtil

String dateStr = "2017-03-01";
Date date = DateUtil.parse(dateStr);

String dateStr = "2017-03-01";
Date date = DateUtil.parse(dateStr);

//结果 2017/03/01
String format = DateUtil.format(date, "yyyy/MM/dd");

//常用格式的格式化，结果：2017-03-01
String formatDate = DateUtil.formatDate(date);

//结果：2017-03-01 00:00:00
String formatDateTime = DateUtil.formatDateTime(date);

//结果：00:00:00
String formatTime = DateUtil.formatTime(date);

【六】LocalDateTime使用实例

【1】获取当前时间

@Test
public void now(){
    LocalDateTime now = LocalDateTime.now(); // 获取当前时间
    LocalDate now1 = LocalDate.now(); // 获取当前年月日（当前日期）
    LocalTime now2 = LocalTime.now();// 获取当前时分秒（具体时间）
    System.out.println(now);
    System.out.println(now1);
    System.out.println(now2);
}

【2】获取当前时间的年月日时分秒

@Test
public void now1(){
    LocalDateTime now = LocalDateTime.now(); // 获取当前时间
    int year = now.getYear(); // 获取年份
    int month = now.getMonthValue(); // 获取月份
    int day = now.getDayOfMonth(); // 获取月中的天数
    int hour = now.getHour(); // 获取当前的小时
    int minute = now.getMinute(); // 获取当前分钟
    int second = now.getSecond(); // 获取当前秒数
    System.out.println(year);
    System.out.println(month);
    System.out.println(day);
    System.out.println(hour);
    System.out.println(minute);
    System.out.println(second);
}

【3】在当前时间基础上加上对应的时间

@Test
public void now2(){
    LocalDateTime now = LocalDateTime.now(); // 当前时间
    LocalDateTime now1 = now.plusYears(5); // 在当前时间加上5年
    LocalDateTime now2 = now.plusMonths(5);// 在当前时间商加上5月
    LocalDateTime now3 = now.plusDays(7); // 在当前时间加上7天
    LocalDateTime now4 = now.plusHours(2); // 在当前时间加上2个小时
    LocalDateTime now5 = now.plusMinutes(30); // 在当前时间加上30分钟
    LocalDateTime now6 = now.plusSeconds(30); // 在当前时间加上30秒
    System.out.println(now);
    System.out.println(now1);
    System.out.println(now2);
    System.out.println(now3);
    System.out.println(now4);
    System.out.println(now5);
    System.out.println(now6);
}

【4】在当前时间基础上减去对应的时间

@Test
public void now3(){
    LocalDateTime now = LocalDateTime.now(); // 当前时间
    LocalDateTime now1 = now.minusYears(5); // 在当前时间减上5年
    LocalDateTime now2 = now.minusMonths(5);// 在当前时间商减上5月
    LocalDateTime now3 = now.minusDays(7); // 在当前时间减上7天
    LocalDateTime now4 = now.minusHours(2); // 在当前时间减上2个小时
    LocalDateTime now5 = now.minusMinutes(30); // 在当前时间减上30分钟
    LocalDateTime now6 = now.minusSeconds(30); // 在当前时间减上30秒
    System.out.println(now);
    System.out.println(now1);
    System.out.println(now2);
    System.out.println(now3);
    System.out.println(now4);
    System.out.println(now5);
    System.out.println(now6);
}

【5】改变当前时间（年月日时分秒）

@Test
public void now4(){
    LocalDateTime now = LocalDateTime.now(); // 当前时间
    LocalDateTime now1 = now.withYear(2060); // 改变当前年份（变成2060年）
    LocalDateTime now2 = now.withMonth(12); // 改变当前月份（变成12月份）
    LocalDateTime now3 = now.withDayOfMonth(29); //改变当前天数（变成29日）
    LocalDateTime now4 = now.withHour(23); // 改变当前小时数（变成23时）
    LocalDateTime now5 = now.withMinute(30); // 改变当前分钟（变成30分钟）
    LocalDateTime now6 = now.withSecond(23); // 改变当前小时数（变成23时）
    LocalDateTime now7 = now.withDayOfYear(60); // 从一月一号开始加上60天
    System.out.println(now);
    System.out.println(now1);
    System.out.println(now2);
    System.out.println(now3);
    System.out.println(now4);
    System.out.println(now5);
    System.out.println(now6);
    System.out.println(now7);
}

【6】两个时间作比较

（1）LocalDateTime的compareTo

@Test
public void compareTo(){
    LocalDateTime now = LocalDateTime.now(); // 当前时间
    LocalDateTime now1 = now.plusYears(5); // 在当前时间加上5年
    //  给LocalDateTime 赋值
    LocalDateTime of = LocalDateTime.of(2022,2,5,1,1,1);
    LocalDateTime of1 = LocalDateTime.of(2022,8,5,1,1,1);
    //两个时间作比较，第一个时间减去第二个时间(如果年份相同，比较月份，月份相同比较天数，以此类推)
    int compareTo = now1.compareTo(now);
    int compareTo1 = now.compareTo(now1);
    int compareTo2 = now.compareTo(of);
    int compareTo3 = now.compareTo(of1);
    System.out.println(now);   // 输出 2022-08-13 14:35:52
    System.out.println(now1); // 输出 2027-08-13 14:35:52
    System.out.println(of); // 输出 2022-02-05T01:01:01
    System.out.println(of1); // 输出 2022-08-05T01:01:01
    System.out.println(compareTo); // 输出 5年
    System.out.println(compareTo1); // 输出 -5年
    System.out.println(compareTo2); // 输出 6月
    System.out.println(compareTo3); // 输出 8天
}

（2）isAfter和isBefore

    System.out.println("nowLocalDateTime = " + nowLocalDateTime);
    System.out.println("oldLocalDateTime = " + oldLocalDateTime);
    // 判断调用者是否在传入参数(时间)之后
    boolean after = nowLocalDateTime.isAfter(oldLocalDateTime);
    System.out.println(after);

【7】给LocalDateTime 赋值

@Test
public void ofParse(){
    //  给LocalDateTime 赋值
    LocalDateTime of = LocalDateTime.of(2022,2,5,1,1,1);
    System.out.println(of); // 输出 2022-02-05 01:01:01
    //  给LocalDateTime 赋值 注意（text文本格式要于yyyy-MM-dd HH:mm:ss一致，不然会报错）
    LocalDateTime parse = LocalDateTime.parse("2022-02-05 01:01:01", DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
    System.out.println(parse); // 输出 2022-02-05 1:1:1
}

【8】时间转换

@Test
public void ofPattern() {
    // 字符串转时间
    String dateTime = "2021-01-05 12:00:00";
    DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    LocalDateTime ldt = LocalDateTime.parse(dateTime, df);
    // 时间转字符串
    LocalDateTime now = LocalDateTime.now();
    DateTimeFormatter of = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    String dateTime1 = now.format(of);
    System.out.println(ldt); // 输出 2021-01-05T12:00
    System.out.println(dateTime1); // 输出 2022-08-13 10:15:03
}

【9】计算时间差

@Test
public void duration(){
    LocalDateTime now = LocalDateTime.now(); // 当前时间
    //  给LocalDateTime 赋值
    LocalDateTime of = LocalDateTime.of(2022,7,13,1,1,1);
    Duration duration = Duration.between(of,now); // 后面减去前面
    long days = duration.toDays(); //相差的天数
    long hours = duration.toHours();//相差的小时数
    long minutes = duration.toMinutes();//相差的分钟数
    long millis = duration.toMillis();//相差毫秒数
    long nanos = duration.toNanos();//相差的纳秒数
    System.out.println(days); // 输出 31
    System.out.println(hours); // 输出 752
    System.out.println(minutes); // 输出 45179
    System.out.println(millis); // 输出 2710769393
    System.out.println(nanos); // 输出 2710863444800000
}

【10】获取指定格式的时间

（1）方式一

public void formatDateTime() {
    //格式化格式
    String format = "YYYY-MM-dd hh:mm:ss";
    // DateTimeFormatter.ofPattern方法根据指定的格式输出时间
    String formatDateTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern(format));

    System.out.println(formatDateTime);
}

上面是12小时制的，如果是想要24小时制的

public void formatDateTime() {
    //格式化格式
    String format = "YYYY-MM-dd HH:mm:ss";
    // DateTimeFormatter.ofPattern方法根据指定的格式输出时间
    String formatDateTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern(format));

    System.out.println(formatDateTime);
}

（2）方式二

public void setBirthday(Date birthday) {
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    String format = sdf.format(birthday);
    this.birthday =format;
}

（3）方式三

在Spring框架，如果你需要将一个日期格式从后端传递给前端，你可以通过注解@JsonFormat(pattern=“yyyy-MM-dd HH:mm:ss”,timezone=“GMT+8”)进行返回。

public class student {
    private String name;
    private Integer age;
    @JsonFormat(pattern="yyyy-MM-dd HH:mm:ss",timezone="GMT+8")
    private Date  birthday;
}

【七】其他方式获取当前时间

【1】通过Util包中的Date获取当前时间

Date date = new Date(); // 返回当前时间戳格式
SimpleDateFormat dateFormat= new SimpleDateFormat("yyyy-MM-dd :hh:mm:ss"); // 改变格式
System.out.println(dateFormat.format(date)); // 获取当前时间

【2】通过Util包的Calendar 获取当前时间

Calendar cal= Calendar.getInstance(); // 返回当前时间戳格式
SimpleDateFormat dateFormat= new SimpleDateFormat("yyyy-MM-dd :hh:mm:ss"); // 改变格式
System.out.println(dateFormat.format(cal.getTime())); // 获取当前时间
int y=cal.get(Calendar.YEAR); // 获取当前年份
int m=cal.get(Calendar.MONTH); // 获取当前月份
int d=cal.get(Calendar.DATE); // 获取当前日期
int h=cal.get(Calendar.HOUR_OF_DAY); // 获取当前小时
int mi=cal.get(Calendar.MINUTE); // 获取当前分钟
int s=cal.get(Calendar.SECOND); // 获取当前秒数
System.out.println("现在时刻是"+y+"年"+m+"月"+d+"日"+h+"时"+mi+"分"+s+"秒");

【3】使用System.currentTimeMillis()获取当前时间

SimpleDateFormat formatter= new SimpleDateFormat("yyyy-MM-dd 'at' HH:mm:ss z"); // 改变格式
Date date = new Date(System.currentTimeMillis()); // 返回当前时间戳格式
System.out.println(formatter.format(date)); // 获取当前时间

【八】获取当前日期和前一周、前一月、前一年的日期

public static void main(String[] args) {
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Calendar calendar = Calendar.getInstance();

        //现在日期
        String now = format.format(new Date());
        System.out.println("现在日期  ："+now);

        //过去七天
        calendar.setTime(new Date());
        calendar.add(Calendar.DATE, - 7);
        Date d = calendar.getTime();
        String day = format.format(d);
        System.out.println("过去七天  ："+day);

        //过去一月
        calendar.setTime(new Date());
        calendar.add(Calendar.MONTH, -1);
        Date m = calendar.getTime();
        String mon = format.format(m);
        System.out.println("过去一个月："+mon);

        //过去三个月
        calendar.setTime(new Date());
        calendar.add(Calendar.MONTH, -3);
        Date m3 = calendar.getTime();
        String mon3 = format.format(m3);
        System.out.println("过去三个月："+mon3);

        //过去一年
        calendar.setTime(new Date());
        calendar.add(Calendar.YEAR, -1);
        Date y = calendar.getTime();
        String year = format.format(y);
        System.out.println("过去一年  ："+year);
    }

【九】获取当天的开始时间和结束时间

【1】LocalDateTime

// 当前开始时间
LocalDateTime today_start = LocalDateTime.of(LocalDate.now(), LocalTime.MIN);
String td_st_str = today_start.format(DateTimeFormatter.ofPattern("yyyyMMddHHmmss"));
//当天结束时间
LocalDateTime today_end = LocalDateTime.of(LocalDate.now(), LocalTime.MAX);

【2】DateUtil获取DateTime

DateUtil方法：beginOfDay为获取当前最早时间，endOfDay为获取当前最晚时间

DateTime beginDate = DateUtil.beginOfDay(date);
DateTime endDate = DateUtil.endOfDay(date);

【十】计算日期的时间差

String dateStr1 = "2017-03-01 22:33:23";
Date date1 = DateUtil.parse(dateStr1);

String dateStr2 = "2017-04-01 23:33:23";
Date date2 = DateUtil.parse(dateStr2);

//相差一个月，31天
long betweenDay = DateUtil.between(date1, date2, DateUnit.DAY);

【十一】判断一个日期是否是月末

（1）月末+1=月初

Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
calendar.set(Calendar.DATE, (calendar.get(Calendar.DATE) + 1));
if (calendar.get(Calendar.DAY_OF_MONTH) == 1) {
    return true;
}else{
    return false;
}

（2）用getActualMaximum方法获取一个月的最大天数

Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
int getDay = calendar.get(Calendar.DAY_OF_MONTH);
if(getDay == calendar.getActualMaximum(Calendar.DAY_OF_MONTH)){
    return true;
}else{
    return false;
}

（3）使用LocalDate方法获取上个月的第一天以及最后一天

LocalDate now = LocalDate.now();
now = now.minusMonths(1);//月份-1
// 获取当前月的第一天
LocalDate firstDay = now.with(TemporalAdjusters.firstDayOfMonth()); 
// 获取当前月的最后一天
LocalDate lastDay = now.with(TemporalAdjusters.lastDayOfMonth()); 
//上个月第一天
Date startTime = Date.from(firstDay.atStartOfDay(ZoneId.systemDefault()).toInstant());
//上个月最后一天
Date endTime = Date.from(lastDay.atStartOfDay(ZoneId.systemDefault()).toInstant());
int year = now.getYear();
int month = now.getMonthValue();

（4）使用Date方法获取上个月的第一天以及最后一天

Calendar cal=Calendar.getInstance();
cal.add(Calendar.MONTH, -1);
cal.set(Calendar.DAY_OF_MONTH, 1);
Date startTime = cal.getTime();//上个月第一天

Calendar calendar=Calendar.getInstance();
int month=calendar.get(Calendar.MONTH);
calendar.set(Calendar.MONTH, month-1);
calendar.set(Calendar.DAY_OF_MONTH, calendar.getActualMaximum(Calendar.DAY_OF_MONTH));
Date endTime = calendar.getTime();//上个月最后一天

（5）获取当月第一天，最后一天，下个月第一天，上个月最后一天

@Test
public void lastDayOfMonth(){
    //LocalDate localDate = LocalDate.now();
    LocalDate localDate =LocalDate.of(2020, 2, 20);
    System.out.println("当前时间: " + localDate);
    //当月最后一天
    LocalDate lastDay = localDate.with(TemporalAdjusters.lastDayOfMonth());
    System.out.println("当月最后一天: " + lastDay);
    //当月第一天
    LocalDate firstDay = localDate.with(TemporalAdjusters.firstDayOfMonth());
    System.out.println("当月第一天: " + firstDay);

    //=================================================
    
    //下个月第一天
    SimpleDateFormat dft = new SimpleDateFormat("yyyy-MM-dd");
    Calendar calendar = Calendar.getInstance();
    calendar.add(Calendar.MONTH, 1);
    calendar.set(Calendar.DAY_OF_MONTH, calendar.getActualMinimum(Calendar.DAY_OF_MONTH));
    System.out.println("下个月第一天: " + dft.format(calendar.getTime()));
    //上个月最后一天
    Calendar calendar1 = Calendar.getInstance();
    calendar1.setTime(new Date());
    calendar1.add(Calendar.MONTH, -1);
    calendar1.set(Calendar.DAY_OF_MONTH, calendar.getActualMaximum(Calendar.DAY_OF_MONTH));
    System.out.println("上个月最后一天: " + dft.format(calendar1.getTime()));
}

fixAllenSun

关注

2
点赞
踩
2

收藏

觉得还不错? 一键收藏
1
评论
日期相关工具类

Java 中 1.8 之前有 date 类，date 类到了 1.8 大部分的方法被弃而且 date 类如果不格式化可读性十分差，而 simpledateformat 方法中 format 和 parse 方法都是线程不安全的。1.8 之后出现了 localdate、localdatetime、localtime 这些类，而这些类使用了 final 来修饰，使得这些类是不可变的，一旦实例化，值就固定了，有点类似于 String 类，所以这些类都是线程安全的。
复制链接

扫一扫