DateUtil工具类

90 阅读 0 评论 60 点赞

我是靠谱客的博主勤劳仙人掌，最近开发中收集的这篇文章主要介绍DateUtil工具类，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

基于java8日期函数的DateUtil工具类：

import java.text.SimpleDateFormat;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @description:
 * @author: zhangcb
 * @create: 2019-12-20 10:11
 **/
public class DateUtil {


    /**
     * 求两个日期时间差
     * @param startTime 开始时间
     * @param endTime 结束时间
     * @return 相隔秒
     */
    public static long between(Date startTime, Date endTime){
        return Duration.between(startTime.toInstant(), endTime.toInstant()).getSeconds();
    }

    /**
     * 求两个日期时间差
     * @param startTime 开始时间
     * @param endTime 结束时间
     * @return 相隔秒
     */
    public static long between(LocalDateTime startTime, LocalDateTime endTime){
        return Duration.between(startTime, endTime).getSeconds();
    }

    /**
     * 格式化日期
     * @param date 待格式化的日期
     * @param pattern 格式化正则
     * @return 格式化结果串
     */
    public static String format(Date date, String pattern){
        return new SimpleDateFormat(pattern).format(date);
    }

    /**
     * 格式化日期
     * @param localDateTime 待格式化的日期
     * @param pattern 格式化正式
     * @return 格式化结果串
     */
    public static String format(LocalDateTime localDateTime, String pattern){
        return localDateTime.format(DateTimeFormatter.ofPattern(pattern));
    }

    /**
     * 格式化日期
     * @param localDate 待格式化的日期
     * @param pattern 格式化正则, 这里使用的类型 {@link LocalDate}, 所以正则只能设定到天
     * @return 格式化结果串
     */
    public static String format(LocalDate localDate, String pattern){
        return localDate.format(DateTimeFormatter.ofPattern(pattern));
    }


    /**
     * 将 {@link LocalDateTime} 转换成 {@link Date}
     * @param localDateTime {@link LocalDateTime} 待转换的日期
     * @return 转换成Date结果
     */
    public static Date from(LocalDateTime localDateTime){
        Instant instant = localDateTime.atZone(ZoneId.systemDefault()).toInstant();
        return Date.from(instant);
    }

    /**
     * 将 {@link Date} 转换成 {@link LocalDateTime}
     * @param date {@link Date} 待转换的日期
     * @return 转换成 {@link LocalDateTime} 结果
     */
    public static LocalDateTime from(Date date){
        return LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault());
    }


    /**
     * 获取{@link Date}在开始时间和结束时间内的日期时间段{@link Date}集合
     * @param start 开始时间
     * @param end 结束时间
     * @return 时间天数集合
     */
    public static List<Date> dateZones(Date start, Date end){
        return dateZones(from(start), from(end));
    }


    /**
     * 获取 {@link LocalDate} 在开始时间和结束时间内的日期时间段 {@link LocalDate} 集合
     * @param start 开始时间
     * @param end 结束时间
     * @return 时间集合
     */
    public static List<Date> dateZones(LocalDate start, LocalDate end){
        return Stream.iterate(start, x -> x.plusDays(1))
                .limit(ChronoUnit.DAYS.between(start, end) + 1)
                .map(e -> Date.from(e.atStartOfDay().atZone(ZoneId.systemDefault()).toInstant()))
                .collect(Collectors.toList());
    }


    /**
     * 获取{@link LocalDateTime} 在开始时间和结束时间内的日期时间段{@link Date}集合
     * @param start 开始时间
     * @param end 结束时间
     * @return 时间天数集合
     */
    public static List<Date> dateZones(LocalDateTime start, LocalDateTime end){
        // 用起始时间作为流的源头，按照每次加一天的方式创建一个无限流
        return Stream.iterate(start.toLocalDate(), x -> x.plusDays(1))
                // 截断无限流，长度为起始时间和结束时间的差+1个
                .limit(ChronoUnit.DAYS.between(start, end) + 1)
                // 由于最后要的是字符串，所以map转换一下
                .map(e -> Date.from(e.atStartOfDay().atZone(ZoneId.systemDefault()).toInstant()))
                // 把流收集为List
                .collect(Collectors.toList());
    }


    /**
     * 获取{@link Date}在开始时间和结束时间内的日期时间段{@link LocalDate}集合
     * @param start 开始时间
     * @param end 结束时间
     * @return 时间集合
     */
    public static List<LocalDate> localDateZones(Date start, Date end){
        return localDateZones(from(start), from(end));
    }


    /**
     * 获取 {@link LocalDate} 在开始时间和结束时间内的日期时间段 {@link LocalDate} 集合
     * @param start 开始时间
     * @param end 结束时间
     * @return 时间集合
     */
    public static List<LocalDate> localDateZones(LocalDate start, LocalDate end){
        return Stream.iterate(start, x -> x.plusDays(1))
                .limit(ChronoUnit.DAYS.between(start, end) + 1)
                .collect(Collectors.toList());
    }

    /**
     * 获取 {@link LocalDateTime} 在开始时间和结束时间内的日期时间段 {@link LocalDate} 集合
     * @param start 开始时间
     * @param end 结束时间
     * @return 时间集合
     */
    public static List<LocalDate> localDateZones(LocalDateTime start, LocalDateTime end){
        // 用起始时间作为流的源头，按照每次加一天的方式创建一个无限流
        return Stream.iterate(start.toLocalDate(), x -> x.plusDays(1))
                // 截断无限流，长度为起始时间和结束时间的差+1个
                .limit(ChronoUnit.DAYS.between(start, end) + 1)
                .map(e -> e.atStartOfDay().toLocalDate())
                // 把流收集为List
                .collect(Collectors.toList());
    }


}