java8 日期工具类

一叶飘零_sweeeet

已于 2023-07-11 16:29:59 修改

阅读量311

点赞数 2

分类专栏： java8 文章标签： java java8 java utils

于 2023-05-22 11:48:35 首次发布

本文链接：https://blog.csdn.net/jam_yin/article/details/130804208

版权

java8 专栏收录该内容

14 篇文章 1 订阅

订阅专栏

以下是一个可用于处理日期和时间的Java 8工具类示例。它包括了常用的日期处理方法，例如获取当前日期、获取下一个日期等等。

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.Locale;

public class DateUtils {

    private static final DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd");

    /**
     * 获取当前日期
     *
     * @return 当前日期
     */
    public static LocalDate now() {
        return LocalDate.now();
    }

    /**
     * 获取下一个日期
     *
     * @param days 天数
     * @return 下一个日期
     */
    public static LocalDate nextDay(int days) {
        return now().plusDays(days);
    }

    /**
     * 获取下一个月的第一天
     *
     * @param year 年份
     * @param month 月份
     * @return 下一个月的第一天
     */
    public static LocalDate nextMonth(int year, int month) {
        LocalDate now = LocalDate.now();
        LocalDate nextMonth = now.withDayOfMonth(1);
        while (nextMonth.getYear() == year && nextMonth.getMonth() != month) {
            nextMonth = nextMonth.plusMonths(1);
        }
        return nextMonth;
    }

    /**
     * 获取指定日期的上一个月的最后一天
     *
     * @param date 日期
     * @return 上一个月的最后一天
     */
    public static LocalDate lastDayOfLastMonth(LocalDate date) {
        LocalDate lastDayOfMonth = date.withDayOfMonth(1).minusDays(1);
        while (lastDayOfMonth.getYear() == date.getYear() && lastDayOfMonth.getMonth() == date.getMonth()) {
            lastDayOfMonth = lastDayOfMonth.minusMonths(1);
        }
        return lastDayOfMonth;
    }

    /**
     * 获取指定日期的下一个周五
     *
     * @param date 日期
     * @return 下一个周五
     */
    public static LocalDate nextFriday(LocalDate date) {
        LocalDate nextMonday = date.with(nextDay(2));
        if (nextMonday.getDayOfWeek() != DateTimeFormatter.ofPattern("EEEE").getWeekendStart()) {
            nextMonday = nextMonday.plusDays(1);
        }
        return nextMonday;
    }

    /**
     * 获取指定日期的下一个工作日
     *
     * @param date 日期
     * @return 下一个工作日
     */
    public static LocalDate nextWorkingDay(LocalDate date) {
        LocalDate nextMonday = nextFriday(date);
        if (nextMonday.getDayOfWeek() == DateTimeFormatter.ofPattern("EEEE").getDayOfWeek() || nextMonday.getDayOfWeek() == DateTimeFormatter.ofPattern("MONDAY").getDayOfWeek()) {
            nextMonday = nextMonday.minusDays(1);
        }
        return nextMonday;
    }

    /**
     * 获取指定日期的上一年的年初月份
     *
     * @param date 日期
     * @return 上一年的年初月份
     */
    public static LocalDate lastYearFirstMonth(LocalDate date) {
        LocalDate lastDayOfLastYear = lastDayOfLastMonth(date.minusMonths(1));
        return LocalDate.of(lastDayOfLastYear.getYear(), lastDayOfLastYear.getMonthValue(), 1);
    }

    /**
     * 获取指定日期的上一年的年初周
     *
     * @param date 日期
     * @return 上一年的年初周
     */
    public static Weekday lastYearFirstDayOfWeek(LocalDate date) {
        LocalDate lastDayOfLastYear = lastDayOfLastMonth(date.minusMonths(1));
        return Weekday.of(lastDayOfLastYear.getDayOfWeek(), 1);
    }

    /**
     * 获取指定日期的上一年的年初日
     *
     * @param date 日期
     * @return 上一年的年初日
     */
    public static LocalDate lastYearFirstDayOfYear(LocalDate date) {
        LocalDate lastDayOfLastYear = lastDayOfLastMonth(date.minusMonths(1));
        return LocalDate.of(lastDayOfLastYear.getYear(), lastDayOfLastYear.getDayOfMonth(), 1);
    }

    //region 日期格式化工具类

    /**
     * 格式化日期
     *
     * @param date 日期
     * @param format 格式化字符串
     * @return 格式化后的日期字符串
     */
    public static String format(LocalDate date, String format) {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(format);
        return date.format(formatter);
    }

    /**
     * 格式化日期
     *
     * @param date 日期
     * @param format 格式化字符串
     * @param locale 日期格式化的地区
     * @return 格式化后的日期字符串
     */
    public static String format(LocalDate date, String format, Locale locale) {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(format, Locale.of(locale));
        return date.format(formatter);
    }

    //endregion

}

import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;

public class DateUtils {
    
    // 获取当前日期
    public static LocalDate getCurrentDate() {
        return LocalDate.now();
    }
    
    // 获取当前时间
    public static LocalTime getCurrentTime() {
        return LocalTime.now();
    }
    
    // 获取当前日期时间
    public static LocalDateTime getCurrentDateTime() {
        return LocalDateTime.now();
    }
    
    // 格式化日期为字符串
    public static String formatLocalDate(LocalDate date, String pattern) {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
        return date.format(formatter);
    }
    
    // 解析字符串为LocalDate
    public static LocalDate parseLocalDate(String dateStr, String pattern) {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
        return LocalDate.parse(dateStr, formatter);
    }
    
    // 增加指定天数
    public static LocalDate addDays(LocalDate date, long days) {
        return date.plusDays(days);
    }
    
    // 减少指定天数
    public static LocalDate minusDays(LocalDate date, long days) {
        return date.minusDays(days);
    }
    
    // 计算两个日期之间的天数差
    public static long getDaysBetween(LocalDate startDate, LocalDate endDate) {
        return ChronoUnit.DAYS.between(startDate, endDate);
    }
    
    // 获取指定日期所在月份的第一天
    public static LocalDate getFirstDayOfMonth(LocalDate date) {
        return date.withDayOfMonth(1);
    }
    
    // 获取指定日期所在月份的最后一天
    public static LocalDate getLastDayOfMonth(LocalDate date) {
        return date.withDayOfMonth(date.lengthOfMonth());
    }
    
    // 判断两个日期是否相等
    public static boolean isSameDate(LocalDate date1, LocalDate date2) {
        return date1.isEqual(date2);
    }
    
    // 判断日期是否在指定范围内
    public static boolean isDateInRange(LocalDate date, LocalDate startDate, LocalDate endDate) {
        return date.isAfter(startDate) && date.isBefore(endDate);
    }
    
    // 获取指定日期的星期几
    public static DayOfWeek getDayOfWeek(LocalDate date) {
        return date.getDayOfWeek();
    }
    
    // 判断是否为闰年
    public static boolean isLeapYear(int year) {
        return Year.of(year).isLeap();
    }
    
    // 获取指定月份的天数
    public static int getDaysInMonth(int year, int month) {
        return YearMonth.of(year, month).lengthOfMonth();
    }
    
    // 获取指定日期的年份
    public static int getYear(LocalDate date) {
        return date.getYear();
    }
    
    // 获取指定日期的月份
    public static int getMonth(LocalDate date) {
        return date.getMonthValue();
    }
    
    // 获取指定日期的天数
    public static int getDayOfMonth(LocalDate date) {
        return date.getDayOfMonth();
    }
    
    // 获取指定日期的小时数
    public static int getHour(LocalDateTime dateTime) {
        return dateTime.getHour();
    }
    
    // 获取指定日期的分钟数
    public static int getMinute(LocalDateTime dateTime) {
        return dateTime.getMinute();
    }
    
    // 获取指定日期的秒数
    public static int getSecond(LocalDateTime dateTime) {
        return dateTime.getSecond();
    }
    
    // 判断指定日期是否在当前日期之前
    public static boolean isBefore(LocalDate date) {
        return date.isBefore(LocalDate.now());
    }
    
    // 判断指定日期是否在当前日期之后
    public static boolean isAfter(LocalDate date) {
        return date.isAfter(LocalDate.now());
    }
    
    // 判断指定日期是否在当前日期之前或相等
    public static boolean isBeforeOrEqual(LocalDate date) {
        return date.isBefore(LocalDate.now()) || date.isEqual(LocalDate.now());
    }
    
    // 判断指定日期是否在当前日期之后或相等
    public static boolean isAfterOrEqual(LocalDate date) {
        return date.isAfter(LocalDate.now()) || date.isEqual(LocalDate.now());
    }
    
    // 获取指定日期的年龄
    public static int getAge(LocalDate birthDate) {
        LocalDate currentDate = LocalDate.now();
        return Period.between(birthDate, currentDate).getYears();
    }
    
    // 获取指定日期的季度
    public static int getQuarter(LocalDate date) {
        return (date.getMonthValue() - 1) / 3 + 1;
    }
    
    // 获取指定日期的下一个工作日
    public static LocalDate getNextWorkingDay(LocalDate date) {
        do {
            date = date.plusDays(1);
        } while (date.getDayOfWeek() == DayOfWeek.SATURDAY || date.getDayOfWeek() == DayOfWeek.SUNDAY);
        return date;
    }
    
    // 获取指定日期的上一个工作日
    public static LocalDate getPreviousWorkingDay(LocalDate date) {
        do {
            date = date.minusDays(1);
        } while (date.getDayOfWeek() == DayOfWeek.SATURDAY || date.getDayOfWeek() == DayOfWeek.SUNDAY);
        return date;
    }
    
    // 获取指定日期所在周的第一天（周一）
    public static LocalDate getFirstDayOfWeek(LocalDate date) {
        return date.with(DayOfWeek.MONDAY);
    }
    
    // 获取指定日期所在周的最后一天（周日）
    public static LocalDate getLastDayOfWeek(LocalDate date) {
        return date.with(DayOfWeek.SUNDAY);
    }
    
    // 获取指定日期所在年的第一天
    public static LocalDate getFirstDayOfYear(LocalDate date) {
        return date.withDayOfYear(1);
    }
    
    // 获取指定日期所在年的最后一天
    public static LocalDate getLastDayOfYear(LocalDate date) {
        return date.withDayOfYear(date.lengthOfYear());
    }
    
    // 获取指定日期所在季度的第一天
    public static LocalDate getFirstDayOfQuarter(LocalDate date) {
        int month = (date.getMonthValue() - 1) / 3 * 3 + 1;
        return LocalDate.of(date.getYear(), month, 1);
    }
    
    // 获取指定日期所在季度的最后一天
    public static LocalDate getLastDayOfQuarter(LocalDate date) {
        int month = (date.getMonthValue() - 1) / 3 * 3 + 3;
        return LocalDate.of(date.getYear(), month, Month.of(month).maxLength());
    }
    
    // 判断指定日期是否为工作日（周一至周五）
    public static boolean isWeekday(LocalDate date) {
        return date.getDayOfWeek() != DayOfWeek.SATURDAY && date.getDayOfWeek() != DayOfWeek.SUNDAY;
    }
    
    // 判断指定日期是否为周末（周六或周日）
    public static boolean isWeekend(LocalDate date) {
        return date.getDayOfWeek() == DayOfWeek.SATURDAY || date.getDayOfWeek() == DayOfWeek.SUNDAY;
    }
    
    // 获取指定日期所在月份的工作日天数
    public static int getWeekdayCountOfMonth(LocalDate date) {
        int weekdayCount = 0;
        LocalDate firstDayOfMonth = getFirstDayOfMonth(date);
        LocalDate lastDayOfMonth = getLastDayOfMonth(date);
        
        while (!firstDayOfMonth.isAfter(lastDayOfMonth)) {
            if (isWeekday(firstDayOfMonth)) {
                weekdayCount++;
            }
            firstDayOfMonth = firstDayOfMonth.plusDays(1);
        }
        
        return weekdayCount;
    }
    
    // 获取指定日期所在月份的周末天数
    public static int getWeekendCountOfMonth(LocalDate date) {
        int weekendCount = 0;
        LocalDate firstDayOfMonth = getFirstDayOfMonth(date);
        LocalDate lastDayOfMonth = getLastDayOfMonth(date);
        
        while (!firstDayOfMonth.isAfter(lastDayOfMonth)) {
            if (isWeekend(firstDayOfMonth)) {
                weekendCount++;
            }
            firstDayOfMonth = firstDayOfMonth.plusDays(1);
        }
        
        return weekendCount;
    }
    
    // 获取指定日期所在年份的工作日天数
    public static int getWeekdayCountOfYear(LocalDate date) {
        int weekdayCount = 0;
        LocalDate firstDayOfYear = getFirstDayOfYear(date);
        LocalDate lastDayOfYear = getLastDayOfYear(date);
        
        while (!firstDayOfYear.isAfter(lastDayOfYear)) {
            if (isWeekday(firstDayOfYear)) {
                weekdayCount++;
            }
            firstDayOfYear = firstDayOfYear.plusDays(1);
        }
        
        return weekdayCount;
    }
    
   }

// 获取指定日期的年份和季度
public static String getYearAndQuarter(LocalDate date) {
    int year = date.getYear();
    int quarter = getQuarter(date);
    return year + "Q" + quarter;
}

// 获取指定日期所在周的起始日期和结束日期
public static String getWeekStartAndEnd(LocalDate date) {
    LocalDate weekStart = getFirstDayOfWeek(date);
    LocalDate weekEnd = getLastDayOfWeek(date);
    return weekStart + " - " + weekEnd;
}

// 判断指定日期是否为闰年的2月29日
public static boolean isLeapYearFebruary29(LocalDate date) {
    return date.getMonthValue() == 2 && date.getDayOfMonth() == 29 && isLeapYear(date.getYear());
}

// 获取指定日期的开始时间（00:00:00）
public static LocalDateTime getStartOfDay(LocalDate date) {
    return date.atStartOfDay();
}

// 获取指定日期的结束时间（23:59:59）
public static LocalDateTime getEndOfDay(LocalDate date) {
    return date.atTime(LocalTime.MAX);
}

// 获取指定日期时间的开始时间（00:00:00）
public static LocalDateTime getStartOfDay(LocalDateTime dateTime) {
    LocalDate date = dateTime.toLocalDate();
    return date.atStartOfDay();
}

// 获取指定日期时间的结束时间（23:59:59）
public static LocalDateTime getEndOfDay(LocalDateTime dateTime) {
    LocalDate date = dateTime.toLocalDate();
    return date.atTime(LocalTime.MAX);
}

// 获取指定日期时间的开始时间（00:00:00）
public static LocalDateTime getStartOfHour(LocalDateTime dateTime) {
    int hour = dateTime.getHour();
    return dateTime.withHour(hour).withMinute(0).withSecond(0);
}

// 获取指定日期时间的结束时间（59:59:59）
public static LocalDateTime getEndOfHour(LocalDateTime dateTime) {
    int hour = dateTime.getHour();
    return dateTime.withHour(hour).withMinute(59).withSecond(59);
}

// 获取指定日期时间的开始时间（00:00:00）
public static LocalDateTime getStartOfMinute(LocalDateTime dateTime) {
    int minute = dateTime.getMinute();
    return dateTime.withMinute(minute).withSecond(0);
}

// 获取指定日期时间的结束时间（59:59）
public static LocalDateTime getEndOfMinute(LocalDateTime dateTime) {
    int minute = dateTime.getMinute();
    return dateTime.withMinute(minute).withSecond(59);
}

// 获取指定日期时间的开始时间（00:00）
public static LocalDateTime getStartOfSecond(LocalDateTime dateTime) {
    int second = dateTime.getSecond();
    return dateTime.withSecond(second);
}

// 获取指定日期时间的结束时间（59:59）
public static LocalDateTime getEndOfSecond(LocalDateTime dateTime) {
    int second = dateTime.getSecond();
    return dateTime.withSecond(second);
}

// 获取指定日期的季度起始日期和结束日期
public static String getQuarterStartAndEnd(LocalDate date) {
    LocalDate quarterStart = getFirstDayOfQuarter(date);
    LocalDate quarterEnd = getLastDayOfQuarter(date);
    return quarterStart + " - " + quarterEnd;
}

// 获取指定日期所在月份的起始日期和结束日期
public static String getMonthStartAndEnd(LocalDate date) {
    LocalDate monthStart = getFirstDayOfMonth(date);
    LocalDate monthEnd = getLastDayOfMonth(date);
    return monthStart + " - " + monthEnd;
}

// 获取指定日期所在年份的起始日期和结束日期
public static String getYearStartAndEnd(LocalDate date) {
    LocalDate yearStart = getFirstDayOfYear(date);
    LocalDate yearEnd = getLastDayOfYear(date);
    return yearStart + " - " + yearEnd;
}

// 获取指定日期时间的起始日期时间和结束日期时间
public static String getDateTimeStartAndEnd(LocalDateTime dateTime) {
    LocalDateTime start = getStartOfDay(dateTime);
    LocalDateTime end = getEndOfDay(dateTime);
    return start + " - " + end;
}

// 获取指定日期时间的起始日期时间和结束日期时间
public static String getDateTimeStartAndEnd(LocalDate date) {
    LocalDateTime start = getStartOfDay(date);
    LocalDateTime end = getEndOfDay(date);
    return start + " - " + end;
}

// 获取指定日期时间的起始日期时间和结束日期时间
public static String getDateTimeStartAndEnd(LocalDateTime startDateTime, LocalDateTime endDateTime) {
    return startDateTime + " - " + endDateTime;
}

// 判断指定日期是否为今天
public static boolean isToday(LocalDate date) {
    return date.isEqual(LocalDate.now());
}

// 判断指定日期时间是否为今天
public static boolean isToday(LocalDateTime dateTime) {
    return dateTime.toLocalDate().isEqual(LocalDate.now());
}

// 判断指定日期是否为昨天
public static boolean isYesterday(LocalDate date) {
    return date.isEqual(LocalDate.now().minusDays(1));
}

// 判断指定日期时间是否为昨天
public static boolean isYesterday(LocalDateTime dateTime) {
    return dateTime.toLocalDate().isEqual(LocalDate.now().minusDays(1));
}

// 判断指定日期是否为明天
public static boolean isTomorrow(LocalDate date) {
    return date.isEqual(LocalDate.now().plusDays(1));
}

// 判断指定日期时间是否为明天
public static boolean isTomorrow(LocalDateTime dateTime) {
    return dateTime.toLocalDate().isEqual(LocalDate.now().plusDays(1));
}

// 判断指定日期是否在本周内
public static boolean isInCurrentWeek(LocalDate date) {
    LocalDate weekStart = getFirstDayOfWeek(LocalDate.now());
    LocalDate weekEnd = getLastDayOfWeek(LocalDate.now());
    return !date.isBefore(weekStart) && !date.isAfter(weekEnd);
}

// 判断指定日期时间是否在本周内
public static boolean isInCurrentWeek(LocalDateTime dateTime) {
    LocalDate weekStart = getFirstDayOfWeek(LocalDate.now());
    LocalDate weekEnd = getLastDayOfWeek(LocalDate.now());
    return !dateTime.toLocalDate().isBefore(weekStart) && !dateTime.toLocalDate().isAfter(weekEnd);
}

// 判断指定日期是否在本月内
public static boolean isInCurrentMonth(LocalDate date) {
    LocalDate monthStart = getFirstDayOfMonth(LocalDate.now());
    LocalDate monthEnd = getLastDayOfMonth(LocalDate.now());
    return !date.isBefore(monthStart) && !date.isAfter(monthEnd);
}

// 判断指定日期时间是否在本月内
public static boolean isInCurrentMonth(LocalDateTime dateTime) {
    LocalDate monthStart = getFirstDayOfMonth(LocalDate.now());
    LocalDate monthEnd = getLastDayOfMonth(LocalDate.now());
    return !dateTime.toLocalDate().isBefore(monthStart) && !dateTime.toLocalDate().isAfter(monthEnd);
}

// 判断指定日期是否在本年内
public static boolean isInCurrentYear(LocalDate date) {
    LocalDate yearStart = getFirstDayOfYear(LocalDate.now());
    LocalDate yearEnd = getLastDayOfYear(LocalDate.now());
    return !date.isBefore(yearStart) && !date.isAfter(yearEnd);
}

// 判断指定日期时间是否在本年内
public static boolean isInCurrentYear(LocalDateTime dateTime) {
    LocalDate yearStart = getFirstDayOfYear(LocalDate.now());
    LocalDate yearEnd = getLastDayOfYear(LocalDate.now());
    return !dateTime.toLocalDate().isBefore(yearStart) && !dateTime.toLocalDate().isAfter(yearEnd);
}