【Java常用工具类】线程安全的日期类

其他 2021-11-19 23:43:54 阅读次数: 0

文章目录

其他工具类

【Java常用工具类】数学计算

【Java常用工具类】字符串

【Java常用工具类】easyexcel基本使用演示

【Java常用工具类】集合操作常用方法

方法解释

1、formatNowOfTimestamp，格式化当前时间为【年月日时分秒】，时间戳

20200101000000

2、formatNowOfMin，格式化当前时间为【年-月-日 小时:分钟】

2020-01-01 00:00

3、formatNowOfSec，格式化当前时间为【年-月-日 小时:分钟:秒】

2020-01-01 00:00:00

4、formatNowOfHour，格式化当前时间为【年-月-日 小时】

2020-01-01 00

5、formatNowOfDay，格式化当前时间为【年-月-日】

2020-01-01

6、dateToLocalDate，data 转 LocalDate

7、dateToLocalDateTime，data 转 LocalDateTime

8、localDateTimeToDate，localDateTime 转 Date

9、localDateToDate，localDate 转 Date

10、compare(String date1, String date2)，格式化时间YYYY_MM_DD_HH_MI_SS，然后比较两个时间

11、diffMillis(String start, String end)，计算两个时间相差的毫秒数

start ：2000-01-01 08:00:00，end ：2000-01-01 08:00:02，相差的毫秒数：2000

12、diffSec(String start, String end)，计算两个时间相差的秒数

start ：2000-01-01 08:00:00，end ：2000-01-01 08:00:02，相差的秒数：2

13、diffMin(String start, String end)，计算两个时间相差的分钟数

start ：2000-01-01 08:00:00，end ：2000-01-01 08:01:00，相差的分钟数：1

14、diffHour(String start, String end)，计算两个时间相差的小时数

start ：2000-01-01 08:00:00，end ：2000-01-01 09:00:00，相差的小时数：1

15、diffDay(String start, String end)，计算两个时间相差的天数

start ：2000-01-01 08:00:00，end ：2000-01-02 08:00:00，相差的天数：1

16、minusYears(String time, int years)，让time时间减去指定的年数

time : 2001-01-01 08:00:00，years：1，结果：2000-01-01 08:00:00

17、minusMonths(String time, int months)，让time时间减去指定的月数

time : 2000-01-01 08:00:00，months：1，结果：1999-12-01 08:00:00

18、minusDay(String time, int days)，让time时间减去指定的天数

time : 2000-01-01 08:00:00，days：1，结果：1999-12-31 08:00:00

19、minusHours(String time, int hours)，让time时间减去指定的小时数

time : 2000-01-01 08:00:00，hours：1，结果：2000-01-01 07:00:00

20、minusMin(String time, int minutes)，让time时间减去指定的分钟数

time : 2000-01-01 08:00:00，minutes：1，结果：2000-01-01 07:59:00

21、minusSeconds(String time, int seconds)，让time时间减去指定的秒数

time : 2000-01-01 08:00:00，minutes：1，结果：2000-01-01 07:59:59

22、isLastDayOfMonth，判断当前时间是否为当月的最后一天

23、isFirstDayOfMonth，判断当前时间是否为当月的第一天

24、getLastDayOfMonth，获取当月的最后一天，返回：年-月-日

25、getFirstDayOfMonth，获取当月的第一天，返回：年-月-日

26、parseStrToDate(String date, String originalFormat)，string转date

27、formatDate(Date date, String format)，date转换成字符串格式

28、formatString(String date, String originalFormat, String newFormat)，把原时间格式，转换成另一种

29、dayOfStart，获取一天中的开始时间

2020-01-01 00:00:00

30、dayOfEnd，获取一天中的结束时间

2020-01-01 23:59:59

方法代码

import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.temporal.TemporalAdjusters;
import java.util.Date;

import static java.time.format.DateTimeFormatter.ofPattern;

/**
 * 日期工具类
 */
public class LocalDateUtils {
    
    

    /**
     * yyyy-MM-dd
     */
    public static final String YYYY_MM_DD = "yyyy-MM-dd";

    /**
     * yyyy-MM-dd HH
     */
    public static final String YYYY_MM_DD_HH = "yyyy-MM-dd HH";

    /**
     * yyyy-MM-dd HH:mm
     */
    public static final String YYYY_MM_DD_HH_MI = "yyyy-MM-dd HH:mm";
    /**
     * yyyy-MM-dd HH:mm:ss
     */
    public static final String YYYY_MM_DD_HH_MI_SS = "yyyy-MM-dd HH:mm:ss";
    /**
     * yyyyMMddHHmmss
     */
    public static final String YYYYMMDDHHMISS = "yyyyMMddHHmmss";
    public static final String YYYYMMDDHHMISSMS = "yyyyMMddHHmmssSSS";


    private static final DateTimeFormatter DATE_TIME_FORMATTER_DAY = ofPattern(YYYY_MM_DD);
    private static final DateTimeFormatter DATE_TIME_FORMATTER_HOUR = ofPattern(YYYY_MM_DD_HH);
    private static final DateTimeFormatter DATE_TIME_FORMATTER_MIN = ofPattern(YYYY_MM_DD_HH_MI);
    private static final DateTimeFormatter DATE_TIME_FORMATTER_SEC = ofPattern(YYYY_MM_DD_HH_MI_SS);
    private static final DateTimeFormatter DATE_TIME_FORMATTER_TIMESTAMP_SEC = ofPattern(YYYYMMDDHHMISS);
    private static final DateTimeFormatter DATE_TIME_FORMATTER_TIMESTAMP_MS = ofPattern(YYYYMMDDHHMISSMS);

    /**
     * data 转 LocalDate
     *
     * @param date date
     * @return LocalDate
     */
    public static LocalDate dateToLocalDate(Date date) {
    
    
        return date.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
    }

    /**
     * data 转 LocalDateTime
     *
     * @param date date
     * @return LocalDateTime
     */
    public static LocalDateTime dateToLocalDateTime(Date date) {
    
    
        return date.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime();
    }

    /**
     * localDateTime 转 Date
     *
     * @param localDateTime localDateTime
     * @return Date
     */
    public static Date localDateTimeToDate(LocalDateTime localDateTime) {
    
    
        return Date.from(localDateTime.atZone(ZoneId.systemDefault()).toInstant());
    }

    /**
     * localDate 转 Date
     *
     * @param localDate localDate
     * @return Date
     */
    public static Date localDateToDate(LocalDate localDate) {
    
    
        return Date.from(localDate.atStartOfDay(ZoneId.systemDefault()).toInstant());
    }

    /**
     * 按照指定的format格式化，LocalDateUtils本身已经定义了一些常用格式，可直接使用，也可自定义
     *
     * @param format 时间格式
     * @return
     */
    public static String formatNow(String format) {
    
    
        return LocalDateTime.now().format(ofPattern(format));
    }

    /**
     * 格式化当前时间【年月日时分秒】
     *
     * @return 20000101000000000
     */
    public static String formatNowOfTimestampMS() {
    
    
        return LocalDateTime.now().format(DATE_TIME_FORMATTER_TIMESTAMP_MS);
    }

    /**
     * 格式化当前时间【年月日时分秒】
     *
     * @return 20000101000000
     */
    public static String formatNowOfTimestampSec() {
    
    
        return LocalDateTime.now().format(DATE_TIME_FORMATTER_TIMESTAMP_SEC);
    }

    /**
     * 格式化当前时间【年-月-日】
     *
     * @return 2000-01-01
     */
    public static String formatNowOfDay() {
    
    
        return LocalDateTime.now().format(DATE_TIME_FORMATTER_DAY);
    }

    /**
     * 格式化当前时间【年-月-日 小时】
     *
     * @return 2000-01-01 08
     */
    public static String formatNowOfHour() {
    
    
        return LocalDateTime.now().format(DATE_TIME_FORMATTER_HOUR);
    }

    /**
     * 格式化当前时间【年-月-日 小时:分钟】
     *
     * @return 2000-01-01 08:00
     */
    public static String formatNowOfMin() {
    
    
        return LocalDateTime.now().format(DATE_TIME_FORMATTER_MIN);
    }

    /**
     * 格式化当前时间【年-月-日 小时:分钟:秒】
     *
     * @return 2000-01-01 08:00:00
     */
    public static String formatNowOfSec() {
    
    
        return LocalDateTime.now().format(DATE_TIME_FORMATTER_SEC);
    }

    /**
     * 格式化时间为yyyy-MM-dd HH:mm:ss，然后进行比较
     *
     * @param date1 比较时间1
     * @param date2 比较时间2
     * @return -1、0、1
     */
    public static int compare(String date1, String date2) {
    
    
        LocalDateTime d1 = LocalDateTime.parse(date1, DATE_TIME_FORMATTER_SEC);
        LocalDateTime d2 = LocalDateTime.parse(date2, DATE_TIME_FORMATTER_SEC);
        return d1.compareTo(d2);
    }

    /**
     * 计算两个时间相差的毫秒数
     *
     * @param start 【年-月-日 小时:分钟:秒】2000-01-01 08:00:00
     * @param end   【年-月-日 小时:分钟:秒】2000-01-01 08:00:02
     * @return 相差的毫秒数：2000
     */
    public static long diffMillis(String start, String end) {
    
    
        LocalDateTime startTime = LocalDateTime.parse(start, DATE_TIME_FORMATTER_SEC);
        LocalDateTime endTime = LocalDateTime.parse(end, DATE_TIME_FORMATTER_SEC);
        return Duration.between(startTime, endTime).toMillis();
    }

    /**
     * 计算两个时间相差的秒数
     *
     * @param start 【年-月-日 小时:分钟:秒】2000-01-01 08:00:00
     * @param end   【年-月-日 小时:分钟:秒】2000-01-01 08:00:02
     * @return 相差的秒数：2
     */
    public static long diffSec(String start, String end) {
    
    
        LocalDateTime startTime = LocalDateTime.parse(start, DATE_TIME_FORMATTER_SEC);
        LocalDateTime endTime = LocalDateTime.parse(end, DATE_TIME_FORMATTER_SEC);
        return Duration.between(startTime, endTime).toMillis() / 1000;
    }

    /**
     * 计算两个时间相差的分钟数
     *
     * @param start 【年-月-日 小时:分钟:秒】2000-01-01 08:00:00
     * @param end   【年-月-日 小时:分钟:秒】2000-01-01 08:01:00
     * @return 相差的分钟数：1
     */
    public static long diffMin(String start, String end) {
    
    
        LocalDateTime startTime = LocalDateTime.parse(start, DATE_TIME_FORMATTER_SEC);
        LocalDateTime endTime = LocalDateTime.parse(end, DATE_TIME_FORMATTER_SEC);
        return Duration.between(startTime, endTime).toMinutes();
    }

    /**
     * 计算两个时间相差的小时数
     *
     * @param start 【年-月-日 小时:分钟:秒】2000-01-01 08:00:00
     * @param end   【年-月-日 小时:分钟:秒】2000-01-01 09:00:00
     * @return 相差的小时数：1
     */
    public static long diffHour(String start, String end) {
    
    
        LocalDateTime startTime = LocalDateTime.parse(start, DATE_TIME_FORMATTER_SEC);
        LocalDateTime endTime = LocalDateTime.parse(end, DATE_TIME_FORMATTER_SEC);
        return Duration.between(startTime, endTime).toHours();
    }

    /**
     * 计算两个时间相差的天数
     *
     * @param start 【年-月-日 小时:分钟:秒】2000-01-01 08:00:00
     * @param end   【年-月-日 小时:分钟:秒】2000-01-03 08:00:00
     * @return 相差的天数：2
     */
    public static long diffDay(String start, String end) {
    
    
        LocalDateTime startTime = LocalDateTime.parse(start, DATE_TIME_FORMATTER_SEC);
        LocalDateTime endTime = LocalDateTime.parse(end, DATE_TIME_FORMATTER_SEC);
        return Duration.between(startTime, endTime).toDays();
    }

    /**
     * 让time时间减去指定的年数
     *
     * @param time  【年-月-日 小时:分钟:秒】2000-01-01 08:00:00
     * @param years 减去指定的年数
     * @return 减去后的时间
     */
    public static String minusYears(String time, int years) {
    
    
        return LocalDateTime.parse(time, DATE_TIME_FORMATTER_SEC).minusYears(years).format(DATE_TIME_FORMATTER_SEC);
    }

    /**
     * 让time时间减去指定的月数
     *
     * @param time   【年-月-日 小时:分钟:秒】2000-01-01 08:00:00
     * @param months 减去指定的月数
     * @return 减去后的时间
     */
    public static String minusMonths(String time, int months) {
    
    
        return LocalDateTime.parse(time, DATE_TIME_FORMATTER_SEC).minusMonths(months).format(DATE_TIME_FORMATTER_SEC);
    }

    /**
     * 让time时间减去指定的天数
     *
     * @param time 【年-月-日 小时:分钟:秒】2000-01-01 08:00:00
     * @param days 要减去的天数，当传入负数时，等于加上指定的天数
     * @return 减去后的时间
     */
    public static String minusDay(String time, int days) {
    
    
        return LocalDateTime.parse(time, DATE_TIME_FORMATTER_SEC).minusDays(days).format(DATE_TIME_FORMATTER_SEC);
    }

    /**
     * 让time时间减去指定的小时数
     *
     * @param time  【年-月-日 小时:分钟:秒】2000-01-01 08:00:00
     * @param hours 要减去的小时数
     * @return 减去后的时间
     */
    public static String minusHours(String time, int hours) {
    
    
        return LocalDateTime.parse(time, DATE_TIME_FORMATTER_SEC).minusHours(hours).format(DATE_TIME_FORMATTER_SEC);
    }

    /**
     * 让time时间减去指定的分钟数
     *
     * @param time    【年-月-日 小时:分钟:秒】2000-01-01 08:00:00
     * @param minutes 要减去的分钟数
     * @return 减去后的时间
     */
    public static String minusMin(String time, int minutes) {
    
    
        return LocalDateTime.parse(time, DATE_TIME_FORMATTER_SEC).minusMinutes(minutes).format(DATE_TIME_FORMATTER_SEC);
    }

    /**
     * 让time时间减去指定的秒数
     *
     * @param time    【年-月-日 小时:分钟:秒】2000-01-01 08:00:00
     * @param seconds 要减去的秒数
     * @return 减去后的时间
     */
    public static String minusSeconds(String time, int seconds) {
    
    
        return LocalDateTime.parse(time, DATE_TIME_FORMATTER_SEC).minusSeconds(seconds).format(DATE_TIME_FORMATTER_SEC);
    }

    /**
     * 判断当前时间是否为当月的最后一天
     *
     * @return true/false
     */
    public static boolean isLastDayOfMonth() {
    
    
        LocalDate today = LocalDate.now();
        LocalDate lastDayOfMonth = today.with(TemporalAdjusters.lastDayOfMonth());
        return Period.between(today, lastDayOfMonth).getDays() == 0;
    }

    /**
     * 判断当前时间是否为当月的第一天
     *
     * @return true/false
     */
    public static boolean isFirstDayOfMonth() {
    
    
        LocalDate today = LocalDate.now();
        LocalDate firstDayOfMonth = today.with(TemporalAdjusters.firstDayOfMonth());
        return Period.between(today, firstDayOfMonth).getDays() == 0;
    }

    /**
     * 获取当月的最后一天
     *
     * @return yyyy-MM-dd 字符串
     */
    public static String getLastDayOfMonth() {
    
    
        LocalDate today = LocalDate.now();
        LocalDate lastDayOfMonth = today.with(TemporalAdjusters.lastDayOfMonth());
        return lastDayOfMonth.format(DATE_TIME_FORMATTER_DAY);
    }

    /**
     * 获取当月的第一天
     *
     * @return yyyy-MM-dd 字符串
     */
    public static String getFirstDayOfMonth() {
    
    
        LocalDate today = LocalDate.now();
        LocalDate firstDayOfMonth = today.with(TemporalAdjusters.firstDayOfMonth());
        return firstDayOfMonth.format(DATE_TIME_FORMATTER_DAY);
    }

    /**
     * string转date
     *
     * @param date           字符串
     * @param originalFormat 当前字符串的日期格式
     * @return
     */
    public static Date parseStrToDate(String date, String originalFormat) {
    
    
        final DateTimeFormatter formatter = DateTimeFormatter.ofPattern(originalFormat);
        LocalDateTime time = LocalDateTime.from(LocalDate.parse(date, formatter).atStartOfDay());
        return LocalDateUtils.localDateTimeToDate(time);
    }

    /**
     * 把date按照指定格式转成字符串
     *
     * @param date   date
     * @param format 格式
     * @return
     */
    public static String formatDate(Date date, String format) {
    
    
        LocalDateTime localDateTime = dateToLocalDateTime(date);
        return localDateTime.format(ofPattern(format));
    }

    /**
     * 把原时间格式，转换成另一种时间格式
     *
     * @param date           string 时间
     * @param originalFormat 原格式
     * @param newFormat      转换后的格式
     * @return
     */
    public static String formatString(String date, String originalFormat, String newFormat) {
    
    
        return LocalDateUtils.formatDate(parseStrToDate(date, originalFormat), newFormat);
    }

    /**
     * 获取一天中的开始时间
     *
     * @return 2020-01-01 00:00:00
     */
    public static String dayOfStart() {
    
    
        LocalDateTime localDateTime = LocalDateTime.of(LocalDate.now(), LocalTime.MIN);
        return localDateTime.format(DATE_TIME_FORMATTER_SEC);
    }

    /**
     * 获取一天中的结束时间
     *
     * @return 2020-01-01 23:59:59
     */
    public static String dayOfEnd() {
    
    
        LocalDateTime localDateTime = LocalDateTime.of(LocalDate.now(), LocalTime.MAX);
        return localDateTime.format(DATE_TIME_FORMATTER_SEC);
    }

}

使用测试

import org.junit.Test;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.Date;

public class LocalDateUtilsTest {
    
    

    @Test
    public void dateToLocalDate() {
    
    
        Date date = new Date();
        LocalDate localDate = LocalDateUtils.dateToLocalDate(date);
        System.out.println(localDate.toString());
    }

    @Test
    public void dateToLocalDateTime() {
    
    
        Date date = new Date();
        LocalDateTime localDateTime = LocalDateUtils.dateToLocalDateTime(date);
        System.out.println(localDateTime.toString());
    }

    @Test
    public void localDateTimeToDate() {
    
    
        LocalDateTime localDateTime = LocalDateUtils.dateToLocalDateTime(new Date());
        Date date = LocalDateUtils.localDateTimeToDate(localDateTime);
        System.out.println(date);

    }

    @Test
    public void localDateToDate() {
    
    
        Date date = LocalDateUtils.localDateToDate(LocalDateUtils.dateToLocalDate(new Date()));
        System.out.println(date);
    }

    @Test
    public void formatNow() {
    
    
        System.out.println(LocalDateUtils.formatNow(LocalDateUtils.YYYY_MM_DD_HH_MI_SS));
    }

    @Test
    public void formatNowOfTimestampMS() {
    
    
        System.out.println(LocalDateUtils.formatNowOfTimestampMS());
    }

    @Test
    public void formatNowOfTimestampSec() {
    
    
        System.out.println(LocalDateUtils.formatNowOfTimestampSec());
    }

    @Test
    public void formatNowOfDay() {
    
    
        System.out.println(LocalDateUtils.formatNowOfDay());
    }

    @Test
    public void formatNowOfHour() {
    
    
        System.out.println(LocalDateUtils.formatNowOfHour());
    }

    @Test
    public void formatNowOfMin() {
    
    
        System.out.println(LocalDateUtils.formatNowOfMin());
    }

    @Test
    public void formatNowOfSec() {
    
    
        System.out.println(LocalDateUtils.formatNowOfSec());
    }

    @Test
    public void formatDate() {
    
    
        System.out.println(LocalDateUtils.formatDate(new Date(), LocalDateUtils.YYYY_MM_DD_HH));
    }

    @Test
    public void formatString() {
    
    
        System.out.println(LocalDateUtils.formatString("2020-01-01", LocalDateUtils.YYYY_MM_DD, LocalDateUtils.YYYY_MM_DD_HH_MI_SS));
    }

    @Test
    public void compare() {
    
    
        System.out.println(LocalDateUtils.compare("2020-01-01 00:00:00", "2020-01-02 00:00:00"));
    }

    @Test
    public void diffMillis() {
    
    
        System.out.println(LocalDateUtils.diffMillis("2020-01-01 00:00:00", "2020-01-02 00:00:00"));
    }

    @Test
    public void diffSec() {
    
    
        System.out.println(LocalDateUtils.diffSec("2020-01-01 00:00:00", "2020-01-02 00:00:00"));
    }

    @Test
    public void diffMin() {
    
    
        System.out.println(LocalDateUtils.diffMin("2020-01-01 00:00:00", "2020-01-02 00:00:00"));
    }

    @Test
    public void diffHour() {
    
    
        System.out.println(LocalDateUtils.diffHour("2020-01-01 00:00:00", "2020-01-02 00:00:00"));
    }

    @Test
    public void diffDay() {
    
    
        System.out.println(LocalDateUtils.diffDay("2020-01-01 00:00:00", "2020-01-02 00:00:00"));
    }

    @Test
    public void minusYears() {
    
    
        System.out.println(LocalDateUtils.minusYears("2020-01-01 10:10:10", 1));
    }

    @Test
    public void minusMonths() {
    
    
        System.out.println(LocalDateUtils.minusMonths("2020-01-01 10:10:10", 1));
    }

    @Test
    public void minusDay() {
    
    
        System.out.println(LocalDateUtils.minusDay("2020-01-01 10:10:10", 1));
    }

    @Test
    public void minusHours() {
    
    
        System.out.println(LocalDateUtils.minusHours("2020-01-01 10:10:10", 1));
    }

    @Test
    public void minusMin() {
    
    
        System.out.println(LocalDateUtils.minusMin("2020-01-01 10:10:10", 1));
    }

    @Test
    public void minusSeconds() {
    
    
        System.out.println(LocalDateUtils.minusSeconds("2020-01-01 10:10:10", 1));
    }

    @Test
    public void isLastDayOfMonth() {
    
    
        System.out.println(LocalDateUtils.isLastDayOfMonth());
    }

    @Test
    public void isFirstDayOfMonth() {
    
    
        System.out.println(LocalDateUtils.isFirstDayOfMonth());
    }

    @Test
    public void getLastDayOfMonth() {
    
    
        System.out.println(LocalDateUtils.getLastDayOfMonth());
    }

    @Test
    public void getFirstDayOfMonth() {
    
    
        System.out.println(LocalDateUtils.getFirstDayOfMonth());
    }

    @Test
    public void parseStrToDate() {
    
    
        System.out.println(LocalDateUtils.parseStrToDate("2020-01-01", LocalDateUtils.YYYY_MM_DD));
    }

    @Test
    public void dayOfStart() {
    
    
        System.out.println(LocalDateUtils.dayOfStart());
    }

    @Test
    public void dayOfEnd() {
    
    
        System.out.println(LocalDateUtils.dayOfEnd());
    }
}

猜你喜欢

转载自blog.csdn.net/CSDN_WYL2016/article/details/121006449
今日推荐
Apache Doris 2.0.10 版本正式发布！
开源日报 | 大模型开战；大模型独角兽被曝卖身；周鸿祎建议谷歌开源所有产品；最大开源AI社区提供1000万美元共享GPU
开源日报 | Chrome内置Gemini的意义不在于Gemini；中国AI追随之路的五大误区；ECharts创始人“下海”养鱼；谷歌I/O开发者大会什么都有，只是没有惊喜
微软回应中国区AI团队“打包赴美”传闻
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
周排行
阿里云短信服务平台注册
Windows下的字符串处理(1)
sqoop: mysql导入数据到hdfs, hive, hbase
commons.lang中常用的工具类
离线安装PostgreSQL11.6
使用PyTorch简单实现卷积神经网络模型
一文彻底搞定谱聚类
一道面试题引发的血案
One Chat for Mac(聊天工具)
TCP/IP的底层队列是如何实现的？
每日归档
更多
2024-05-17(34)
2024-05-16(6)
2024-05-15(24)
2024-05-14(0)
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022