通过时间格式生成唯一编码以及日期常用方法

写项目的时候，很费劲写了一大堆，最后大哥优化，直接调用工具类，觉得是一个很不错的东西，留存一下，方便之后使用查找。

日期常用方法

package org.autumn.code;

import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.time.temporal.TemporalAdjusters;
import java.time.temporal.TemporalField;
import java.time.temporal.WeekFields;
import java.util.Date;
import java.util.HashMap;
import java.util.Locale;
import java.util.Map;

/**
 * @Description: 日期常用方法
 * @Author: Zhangyuhan
 * @Date: 2022/4/19
 */
public class DateUtil {

    /**
     * 设置时区
     */
    public static final ZoneId ZONEID = ZoneId.systemDefault();

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

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

    /**
     * yyyyMM
     */
    public static final String YYYYMM = "yyyyMM";
    /**
     * yyyy-MM-dd HH:mm:ss
     */
    public static final String YYYY_MM_DD_HH_MM_SS = "yyyy-MM-dd HH:mm:ss";
    /**
     * yyyyMMddHHmmss
     */
    public static final String YYYYMMDDHHMMSS = "yyyyMMddHHmmss";

    public enum DateUtilEnum{
        /**
         * 	年
         */
        YEAR,
        /**
         * 	月
         */
        MONTH,
        /**
         *	 日
         */
        DAY,
        /**
         * 	周
         */
        WEEK,
        /**
         * 	小时
         */
        HOUR,
        /**
         * 	分钟
         */
        MINUTE,
        /**
         * 	秒
         */
        SECOND,
        /**
         * 	毫秒
         */
        MILLI,
        /**
         * 	微秒
         */
        MICRO,
        /**
         * 	纳秒
         */
        NANO
    }

    /**
     * timestamp to LocalDateTime
     * @param timestamp
     * @return
     */
    public static LocalDateTime timestampToDatetime(long timestamp){
        Instant instant = Instant.ofEpochMilli(timestamp);
        return LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
    }


    /**
     * Description: 获取当前年月 yyyyMM
     *
     * @return
     */
    public static String getYearAndMonth() {
        return DateTimeFormatter.ofPattern(YYYYMM).format(LocalDate.now());
    }

    /**
     * Description: yyyyMM
     *
     * @param timeStamp 时间戳
     * @return
     */
    public static String getYearAndMonth(long timeStamp) {
        return DateTimeFormatter.ofPattern(YYYYMM)
                .format(Instant.ofEpochMilli(timeStamp).atZone(ZONEID));
    }
    /**
     * 时间戳转字符串时间格式 yyyy-MM-dd HH:mm:ss
     * @param timeStamp
     * @return
     */
    public static String getDateTime(long timeStamp) {
        return DateTimeFormatter.ofPattern(YYYY_MM_DD_HH_MM_SS)
                .format(Instant.ofEpochMilli(timeStamp).atZone(ZONEID));
    }

    /**
     * 时间戳转LocalDateTime
     * @param timeStamp
     * @return
     */
    public static LocalDateTime toLocalDateTime(long timeStamp) {
        return Instant.ofEpochMilli(timeStamp).atZone(ZONEID).toLocalDateTime();
    }

    /**
     * LocalDateTime转时间戳
     * @param
     * @return
     */
    public static long toTimeStamp(LocalDateTime dateTime) {
        return dateTime.toInstant(ZoneOffset.of("+8")).toEpochMilli();
    }

    /**
     * 时间戳转LocalDate
     * @param timeStamp
     * @return
     */
    public static LocalDate toLocalDate(long timeStamp) {
        return Instant.ofEpochMilli(timeStamp).atZone(ZONEID).toLocalDate();
    }

    /**
     *
     * Description: 获取当前是几几年 是哪个月  是一个月中的第几天
     *
     * @param node
     * @return
     */
    public static int peridCount(String node) {
        LocalDateTime ldt = LocalDateTime.now();
        if ("day".equals(node)) {
            return ldt.getDayOfMonth();
        } else if ("month".equals(node)) {
            return ldt.getMonthValue();
        } else if ("year".equals(node)) {
            return ldt.getYear();
        } else {
            return 0;
        }
    }

    /**
     * -获取当前日期
     *
     * @return yyyy-MM-dd
     */
    public static String getNowDate() {
        return String.valueOf(LocalDate.now());
    }

    /**
     * -获取当前时间
     *
     * @return yyyyMMddHHmmss
     */
    public static String getNowDateTime() {
        return LocalDateTime.now().format(DateTimeFormatter.ofPattern(YYYYMMDDHHMMSS));
    }

    /**
     * -获取当前日期
     *
     * @return yyyyMMdd
     */
    public static String getNowDates() {
        return LocalDate.now().format(DateTimeFormatter.ofPattern(YYYYMMDD));
    }

    /**
     * -获取当前日期
     *
     * @return yyyy-MM-dd HH:mm:ss
     */
    public static String getNowDateTimes() {
        return LocalDateTime.now().format(DateTimeFormatter.ofPattern(YYYY_MM_DD_HH_MM_SS));
    }

    /**
     * -获取当前日期 Description: getNowDateTime
     *
     * @param format 日期格式 yyyyMMddHHmmss yyyy-MM-dd ...
     * @return
     */
    public static String getNowDateTime(String format) {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(format);
        return LocalDateTime.now().format(formatter);
    }

    /**
     *
     * Description: 指定日期格式化
     *
     * @param date
     * @param formatter
     * @return
     */
    public static String getLocalDateStr(Date date, String formatter) {
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(formatter);
        Instant instant = date.toInstant();
        LocalDateTime localDateTime = LocalDateTime.ofInstant(instant, ZONEID);
        return dateTimeFormatter.format(localDateTime);
    }

    /**
     *
     * Description: dateToLocalDate
     * @param date
     * @return
     */
    public static LocalDate dateToLocalDate(Date date) {
        Instant instant = date.toInstant();
        return LocalDateTime.ofInstant(instant, ZONEID).toLocalDate();
    }

    /**
     *
     * Description: dateA = dateB
     * @param dateA 2021-10-16
     * @param dateB 2021-10-16
     */
    public static boolean beEqualTo(LocalDate dateA,LocalDate dateB) {
        return dateA.isEqual(dateB);
    }

    /**
     *
     * Description: dateA < dateB
     * @param dateA 2021-10-15
     * @param dateB 2021-10-16
     */
    public static boolean lessThan(LocalDate dateA,LocalDate dateB) {
        return dateA.isBefore(dateB);
    }

    /**
     *
     * Description: dateA <= dateB
     * @param dateA 2021-10-15
     * @param dateB 2021-10-16
     * @return
     */
    public static boolean lessThanOrEqual(LocalDate dateA,LocalDate dateB) {
        return dateA.isBefore(dateB) || dateA.isEqual(dateB);
    }

    /**
     *
     * Description: dateA > dateB
     * @param dateA 2021-10-16
     * @param dateB 2021-10-15
     */
    public static boolean greaterThan(LocalDate dateA,LocalDate dateB) {
        return dateA.isAfter(dateB);
    }

    /**
     *
     * Description: dateA >= dateB
     * @param dateA 2021-10-16
     * @param dateB 2021-10-15
     * @return
     */
    public static boolean greaterThanOrEqual(LocalDate dateA,LocalDate dateB) {
        return dateA.isAfter(dateB) || dateA.isEqual(dateB);
    }

    /**
     *
     * Description: 指定日期格式化
     *
     * @param date
     * @param formatter
     * @return
     */
    public static String getLocalDateStr(String date, String formatter) {
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(formatter);
        LocalDateTime localDateTime = LocalDateTime.parse(date);
        return dateTimeFormatter.format(localDateTime);
    }


    /**
     * 字符串时间转日期
     * @param date
     * @param formatter
     * @return
     */
    public static LocalDate getLocalDate(String date, String formatter) {
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(formatter);
        return LocalDate.parse(date,dateTimeFormatter);
    }

    /**
     * 	计算两个日期之间相差小时数
     * @param startDateTime
     * @param endDateTime
     * @param formatter 对应的字符串日期格式
     * @return
     */
    public static long betweenHours(String startDateTime, String endDateTime, String formatter) {
        return between(startDateTime, endDateTime,formatter,DateUtilEnum.HOUR);
    }

    /**
     * 	计算两个日期之间相差小时数
     * @param startDateTime
     * @param endDateTime
     * @param formatter 对应的字符串日期格式
     * @return
     */
    public static long betweenDays(String startDateTime, String endDateTime, String formatter) {
        return between(startDateTime, endDateTime,formatter,DateUtilEnum.DAY);
    }

    /**
     * 	计算两个日期之间相差值
     * @param startDateTime
     * @param endDateTime
     * @param formatter
     * @param dateUtilEnum
     * @return
     */
    public static long between(String startDateTime, String endDateTime, String formatter,DateUtilEnum dateUtilEnum) {
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(formatter);
        LocalDateTime startTime = LocalDateTime.parse(startDateTime,dateTimeFormatter);
        LocalDateTime endTime = LocalDateTime.parse(endDateTime,dateTimeFormatter);
        switch (dateUtilEnum) {
            case DAY:
                return ChronoUnit.DAYS.between(startTime, endTime);
            case HOUR:
                return ChronoUnit.HOURS.between(startTime, endTime);
            case SECOND:
                return ChronoUnit.SECONDS.between(startTime, endTime);
            case WEEK:
                return ChronoUnit.WEEKS.between(startTime, endTime);
            case YEAR:
                return ChronoUnit.YEARS.between(startTime, endTime);
            default:
                break;
        }
        return 0;
    }

    /**
     * 	计算两个日期之间相差周数
     * @param startDateTime
     * @param endDateTime
     * @param formatter
     * @return
     */
    public static long betweenWeeks(String startDateTime, String endDateTime, String formatter) {
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(formatter);
        LocalDateTime startTime = LocalDateTime.parse(startDateTime,dateTimeFormatter);
        LocalDateTime endTime = LocalDateTime.parse(endDateTime,dateTimeFormatter);
        return ChronoUnit.WEEKS.between(startTime, endTime);
    }

    /**
     * -计算两个日期之间相差天数 Description: betweenDate
     *
     * @param startDate
     * @param endDate
     * @return
     */
    public static int betweenDate(String startDate, String endDate) {
        return (int) (LocalDate.parse(endDate).toEpochDay() - LocalDate.parse(startDate).toEpochDay());
    }

    /**
     * Description: 计算两个日期之间相差天数
     *
     * @param startDate
     * @param endDate
     * @return
     */
    public static int betweenDate(Date startDate, Date endDate) {
        if (null != startDate && null != endDate) {
            LocalDate endLocalDate = endDate.toInstant().atZone(ZONEID).toLocalDate();
            LocalDate startLocalDate = startDate.toInstant().atZone(ZONEID).toLocalDate();
            return (int) (endLocalDate.toEpochDay() - startLocalDate.toEpochDay());
        } else {
            return -1;
        }
    }
    /**
     * 获取时间分割
     *
     * 0 今年的开始时间和结束时间
     * 1 本月的开始时间和结束时间
     * 2 本周的开始时间和结束时间
     */
    public static Map<String,String> getTimeSplit(int splitType){
        Map<String,String> resultMap = new HashMap<>(16);
        LocalDateTime localDateTime = LocalDateTime.now();
        LocalDateTime startTime =  null;
        LocalDateTime endTime = null;
        switch (splitType){
            //本年
            case 0 :
                startTime = LocalDateTime.of(LocalDate.from(localDateTime.with(TemporalAdjusters.firstDayOfYear())),LocalTime.MIN);

                endTime = LocalDateTime.of(LocalDate.from(localDateTime.with(TemporalAdjusters.lastDayOfYear())),LocalTime.MAX);

                break;
            //本月
            case 1 :
                startTime = LocalDateTime.of(LocalDate.from(localDateTime.with(TemporalAdjusters.firstDayOfMonth())),LocalTime.MIN);

                endTime = LocalDateTime.of(LocalDate.from(localDateTime.with(TemporalAdjusters.lastDayOfMonth())),LocalTime.MAX);

                break;
            //本周
            default:
                TemporalField temporalField = WeekFields.of(Locale.FRANCE).dayOfWeek();
                int value = 1;
                startTime = LocalDateTime.of(LocalDate.from(localDateTime.with(temporalField, value)),LocalTime.MIN);
                value = 7;
                endTime = LocalDateTime.of(LocalDate.from(localDateTime.with(temporalField, value)),LocalTime.MAX);
                break;
        }
        resultMap.put("endTime",endTime.format(DateTimeFormatter.ofPattern(YYYY_MM_DD_HH_MM_SS)));
        resultMap.put("startTime",startTime.format(DateTimeFormatter.ofPattern(YYYY_MM_DD_HH_MM_SS)));
        return resultMap;

    }

    /**
     * 获取一天中的时间(从当前时间开始递减)
     * @param hours
     * @return
     */
    public static String[] getTimeOfDay(int hours){
        String[] hoursString = new String[hours];
        LocalDateTime now = LocalDateTime.now();
        hoursString[0] = now.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:00"));
        for (int i = 1; i < hoursString.length; i++) {
            LocalDateTime newTime = now.minusHours(i);
            hoursString[i] = newTime.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:00"));
        }
        return hoursString;
    }

    /**
     * 获取多天中的日期(从当前日期开始递减)
     * @param days
     * @return
     */
    public static String[] getDateInMultipleDay(int days){
        String[] daysString = new String[days];
        LocalDateTime now = LocalDateTime.now();
        daysString[0] = now.format(DateTimeFormatter.ofPattern(YYYY_MM_DD));
        for (int i = 1; i < daysString.length; i++) {
            LocalDateTime newTime = now.minusDays(i);
            daysString[i] = newTime.format(DateTimeFormatter.ofPattern(YYYY_MM_DD));
        }
        return daysString;
    }

}

根据所传入的日期格式 生成唯一编码

package org.autumn.code;

/**
 * @Description:根据所传入的日期格式 生成唯一编码
 * @Author: Zhangyuhan
 * @Date: 2022/4/19
 */
import java.time.LocalDateTime;
import java.time.ZoneOffset;
import java.time.format.DateTimeFormatter;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class NoUtil {
    private static Integer index = 1;
    private static ReadWriteLock lock = new ReentrantReadWriteLock();

    private NoUtil() {
    }

    private static int incr() {
        int var5;
        try {
            lock.writeLock().lock();
            if (index >= 9999) {
                index = 1;
            }

            Integer var0 = index;
            index = index + 1;
            var5 = var0;
        } finally {
            lock.writeLock().unlock();
        }

        return var5;
    }

    public static String generate(NoUtil.Type type) throws Exception {
        return generate(type, NoUtil.Model.TIMESTAMP);
    }

    /**
     * @Description: 根据所传格式 格式化时间
     * @Param: DateTimeFormatter
     */
    public static String format(DateTimeFormatter pattern) {
        return LocalDateTime.now().format(pattern);
    }

    public static String generate(NoUtil.Type type, NoUtil.Model model) throws Exception {
        switch(model) {
            case DATE:
                String date = format(DateTimeFormatter.ofPattern("yyyyMMdd"));
                return type.prefix() + date + String.format("%04d", incr());
            case DATE_TIME:
                String dateTime = format(DateTimeFormatter.ofPattern("yyyyMMddHHmmss"));
                return type.prefix() + dateTime + String.format("%04d", incr());
            case TIMESTAMP:
                return type.prefix() + LocalDateTime.now().toEpochSecond(ZoneOffset.ofHours(8)) + String.format("%04d", incr());
            default:
                throw new Exception("未知构建模式!");
        }
    }

    @Override
    public boolean equals(final Object o) {
        if (o == this) {
            return true;
        } else if (!(o instanceof NoUtil)) {
            return false;
        } else {
            NoUtil other = (NoUtil)o;
            return other.canEqual(this);
        }
    }

    protected boolean canEqual(final Object other) {
        return other instanceof NoUtil;
    }

    @Override
    public int hashCode() {
        boolean result = true;
        return 1;
    }

    @Override
    public String toString() {
        return "NoUtil()";
    }

    public static enum Model {
        DATE,
        DATE_TIME,
        TIMESTAMP;

        private Model() {
        }
    }

    public interface Type {
        String prefix();
    }
}

测试唯一编码生成

package org.autumn.code;

import lombok.Getter;
import lombok.extern.slf4j.Slf4j;

/**
 * @Description: 测试编号
 * @Author: Zhangyuhan
 * @Date: 2022/4/19
 */
@Slf4j
public class NumTest {
    public static void main(String[] args) throws Exception {
        //时间戳
        log.info("时间戳+编号--生成的编码为{}", NoUtil.generate(CodeType.codeOne, NoUtil.Model.TIMESTAMP));
        log.info("--------------------------");
        //Date
        log.info("年月日+编号--生成的编码为{}", NoUtil.generate(CodeType.codeOne, NoUtil.Model.DATE));
        log.info("--------------------------");
        //DATE_TIME 年月日时分秒 +编号
        log.info("年月日时分秒+编号--生成的编码为{}", NoUtil.generate(CodeType.codeOne, NoUtil.Model.DATE_TIME));
    }
}


//定义枚举类 给出类型
enum CodeType implements NoUtil.Type {
    codeOne("A");

    CodeType(String prefix) {
        this.prefix = prefix;
    }

    @Getter
    private String prefix;

    @Override
    public String prefix() {
        return this.prefix;
    }

}

测试结果