Date，LocalDateTime类型，获取今年开始时间，获取去年的今天。

Date类型时间和LocalDateTime时间相互转换。

1.将Date转为LocalDateTime，

Date date = new Date();
Instant instant = date.toInstant();
ZoneId zoneId = ZoneId.systemDefault();

LocalDateTime localDateTime = instant.atZone(zoneId).toLocalDateTime();

2.将LocalDateTime转换为Date

ZoneId zoneId = ZoneId.systemDefault();
LocalDateTime localDateTime = LocalDateTime.now();
ZonedDateTime zdt = localDateTime.atZone(zoneId);

Date date = Date.from(zdt.toInstant());

获取今年的开始时间，获取获取近一年的所有月份，获取今年起始时间和结束时间，根据时间获取年份……

import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.date.DateField;
import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUtil;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.time.temporal.TemporalAdjusters;
import java.util.*;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @description: TODO
 * @date: 2022/8/18 9:23
 */
public class DataDateUtils {


    //获取当天的起始时间
    public static String dayToday() {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Calendar cal = Calendar.getInstance();
        Date date = new Date();
        cal.setTime(date);
        Date time = cal.getTime();
        String dateDay = sdf.format(time);
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String format = null;
        try {
            Date parse = df.parse(dateDay + " 00:00:00");
            format = df.format(parse);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return format;
    }

    /**
     * 获取今年起始时间和结束时间
     */
    public static LocalDateTime getYearDay(Boolean firstFlag) {
        //获取当前时间
        LocalDate nowDate = LocalDate.now();
        LocalDate firstDayOfYear = nowDate.with(TemporalAdjusters.firstDayOfYear());
        LocalDate lastDayOfYear = nowDate.with(TemporalAdjusters.lastDayOfYear());
        //获取今年第一天
        LocalDateTime firstDateOfYear = LocalDateTime.of(firstDayOfYear, LocalTime.MIN);
        //获取今年最后一天
        LocalDateTime lastDateOfYear = LocalDateTime.of(lastDayOfYear, LocalTime.MAX);
        if (firstFlag) {
            return firstDateOfYear;
        } else {
            return lastDateOfYear;
        }
    }

    /**
     * 获取当天时间的起始时间和结束时间
     * @param startFlag
     * @return
     */
    public static LocalDateTime getToday(Boolean startFlag) {
        //获取当前日期
        LocalDate nowDate = LocalDate.now();
        //设置零点
        LocalDateTime beginTime = LocalDateTime.of(nowDate, LocalTime.MIN);
        //将时间进行格式化
        //设置当天的结束时间
        LocalDateTime endTime = LocalDateTime.of(nowDate, LocalTime.MAX);
        //将时间进行格式化
        if (startFlag) {
            return beginTime;
        } else {
            return endTime;
        }
    }

    /**
     * 获取上一年的开始时间和结束时间
     * @param firstFlag
     * @return
     */
    public static LocalDateTime getLastYearDay( boolean firstFlag){

        //获取今年第一天
        LocalDate lastYearStrDay = LocalDate.of(LocalDate.now().minusYears(1).getYear(), 1, 1);
        LocalDate firstDayOfYear = lastYearStrDay.with(TemporalAdjusters.firstDayOfYear());
        LocalDate lastDayOfYear = lastYearStrDay.with(TemporalAdjusters.lastDayOfYear());
        //获取今年第一天
        LocalDateTime firstDateOfYear = LocalDateTime.of(firstDayOfYear, LocalTime.MIN);
        //获取今年最后一天
        LocalDateTime lastDateOfYear = LocalDateTime.of(lastDayOfYear, LocalTime.MAX);
        if (firstFlag) {
            return firstDateOfYear;
        } else {
            return lastDateOfYear;
        }
    }

    /**
     * 获取上一年的开始日期和结束日期
     * @param firstFlag
     * @return
     */
    public static LocalDate getFirstYearDay( boolean firstFlag){

        //获取今年第一天
        LocalDate lastYearStrDay = LocalDate.of(LocalDate.now().minusYears(1).getYear(), 1, 1);
        LocalDate firstDayOfYear = lastYearStrDay.with(TemporalAdjusters.firstDayOfYear());
        LocalDate lastDayOfYear = lastYearStrDay.with(TemporalAdjusters.lastDayOfYear());

        if (firstFlag) {
            return firstDayOfYear;
        } else {
            return lastDayOfYear;
        }
    }
    /**
     * 获取今年的开始日期和结束日期
     * @param firstFlag
     * @return
     */
    public static LocalDate getNowYearDay( boolean firstFlag){

        //获取今年第一天
        LocalDate lastYearStrDay = LocalDate.of(LocalDate.now().getYear(), 1, 1);
        LocalDate firstDayOfYear = lastYearStrDay.with(TemporalAdjusters.firstDayOfYear());
        LocalDate lastDayOfYear = lastYearStrDay.with(TemporalAdjusters.lastDayOfYear());

        if (firstFlag) {
            return firstDayOfYear;
        } else {
            return lastDayOfYear;
        }
    }
    /**
     * 返回两个年月区间的所有年月字符 格式"yyyy-MM"
     */
    public static Set<String> generateDateInterval(LocalDate from,LocalDate to){
        if (ObjectUtil.isNull(from)||ObjectUtil.isNull(to)||from.isAfter(to)){
            return null;
        }
        Set<String> dateInterval = new LinkedHashSet<>();
        while (!from.isAfter(to)){
            String format = from.format(DateTimeFormatter.ofPattern("yyyy-MM"));
            dateInterval.add(format);
            from=from.plusMonths(1);
        }
        return dateInterval;
    }

    public static List<String> generateDateIntervalList(LocalDate from,LocalDate to){
        if (ObjectUtil.isNull(from)||ObjectUtil.isNull(to)||from.isAfter(to)){
            return null;
        }
        List<String> dateInterval = new ArrayList<>();
        while (!from.isAfter(to)){
            String format = from.format(DateTimeFormatter.ofPattern("yyyy-MM"));
            dateInterval.add(format);
            from=from.plusMonths(1);
        }
        return dateInterval;
    }


    /**
     * 获取今年开始时间或今天开始时间
     * @param b
     * @return
     */
    public static Date getStartYearOrDay(boolean b){

        String now = DateUtil.now();
        Date date = DateUtil.parse(now);
        Date startDate;
        if (b){
            startDate = DateUtil.beginOfYear(date);
        }else {
            startDate = DateUtil.beginOfDay(date);
        }
        return startDate;
    }

    /**
     * 获取当年的所有月份
     * @return
     */
    public static List<String> getMonthListOfDate(){
        String now = DateUtil.now();
        Date date = DateUtil.parse(now);
        DateTime start = DateUtil.beginOfYear(date);
        DateTime end = DateUtil.endOfYear(date);
        List<DateTime> dateTimes = DateUtil.rangeToList(start, end, DateField.MONTH);
        List<String> dateList = dateTimes.parallelStream().map(item -> {
            return DateUtil.format(item, "yyyy-MM");
        }).collect(Collectors.toList());

        return dateList;
    }

    /**
     * 获取去年今天
     * @param date
     * @return
     */
    public static Date getLastYearDay(Date date){
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        cal.add(Calendar.YEAR, -1);
        Date time = cal.getTime();
        return time;
    }

    /**
     * 根据时间获取年份
     * @param date
     * @return
     */
    public static String getYearByDate(Date date){
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        Integer y = c.get(Calendar.YEAR);
        return y.toString();
    }


    public static Date transferString2Date(String s) {
        Date date = new Date();
        try {
            date = new SimpleDateFormat("yyyy-MM").parse(s);
        } catch (ParseException e) {

        }
        return date;
    }


}