时间格式化

大狮纸

已于 2024-05-22 13:29:50 修改

阅读量273

点赞数 3

文章标签： java

于 2024-05-06 15:15:21 首次发布

本文链接：https://blog.csdn.net/qq_43391689/article/details/138496085

版权

日期字符串转日期类型

import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;
import org.apache.commons.lang.time.DateUtils;
import org.springframework.boot.jackson.JsonComponent;

import java.io.IOException;
import java.text.ParseException;
import java.util.Date;

import static java.util.regex.Pattern.compile;

/**
 * 日期字符串转日期类型
 * jack json消息转换器全局配置
 */
@JsonComponent
public class JsonDateDeserializer extends JsonDeserializer<Date> {
    private String[] patterns = {
            "yyyy-MM-dd"
            , "yyyy-MM-dd HH:mm:ss"
            , "yyyy-MM-dd HH:mm:ss.SSS"
            , "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'"
    };

    @Override
    public Date deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException {
        String dateAsString = jsonParser.getText();
        if (dateAsString == null || "".equals(dateAsString) || dateAsString.length() < 1) {
            return null;
        }
        //时间的毫秒数转日期
        if (compile("[0-9]*").matcher(dateAsString).matches()) {
            return new Date(Long.valueOf(dateAsString));
        }
        Date parseDate = null;
        try {
            parseDate = DateUtils.parseDate(dateAsString, patterns);
        } catch (ParseException e) {
            throw new IllegalArgumentException(e.getCause());
        }

        return parseDate;
    }
}

时间格式化方法

        /**
	 * 获取前几个月或者后几个月的时间
	 * 
	 * @param month 月 -3 前三月 3 后三月
	 * @return
	 */
        public static String getTime(int month) {
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
            Date date = new Date();
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(date);
            calendar.add(Calendar.MONTH, month); //设置时间
            date = calendar.getTime();
            String defaultStartDate = simpleDateFormat.format(date); //格式化前month月的时间
            return defaultStartDate;
        }
        /**
	 * 返回格式化后的日期信息。
	 * 
	 * @param date
	 * @param format
	 * @return
	 */
	public static String getDateStr(Date date, String pattern) {
		SimpleDateFormat sdf = new SimpleDateFormat(pattern);
		return sdf.format(date);
	}
        //把字符串类型的日期变成指定的日期格式
	public static Date getDateFromStr(String dateStr, String pattern)
			throws ParseException {
		SimpleDateFormat sdf = new SimpleDateFormat(pattern);
		Date date = sdf.parse(dateStr);
		return date;
	}
	//格式化字符串类型的日期，返回字符串类型日期，dateStr和pattern格式一致
        //eg：dateStr：2022/7/28 11:22:21 pattern：yyyy/MM/dd HH:mm:ss
	public static String getStrFromStr(String dateStr, String pattern)
			throws ParseException {
		SimpleDateFormat sdf = new SimpleDateFormat(pattern);
		Date date = sdf.parse(dateStr);
		SimpleDateFormat sdf1 = new SimpleDateFormat(pattern);
		String dates=sdf1.format(date);
		return dates;
	}
	// 获取两时间相差时间
	public static String getTimeDifferenceBetwennTwoDate(Date startDate,
			Date endDate) {
		long end = endDate.getTime();
		long start = startDate.getTime();
		long hours = (end - start) / (3600 * 1000);
		long mins = ((end - start) - hours * (3600 * 1000)) / (1000 * 60);
		long secs = (((end - start) - hours * (3600 * 1000)) - (1000 * 60 * mins)) / 1000;
		String timeDifference = hours + "-" + mins + "-" + secs;
		return timeDifference;
	}
 
	/**
	 * 获取当前日期Date类型
	 */
	public static Date getNowDate() {
		return new Date();
	}
 
	/**
	 * 根据传入的date类型的值获取一个长整型的参数
	 * 
	 * @param date
	 * @return
	 */
	public static long getLongFromDate(Date date) {
		long time = date.getTime();
		return time;
	}
 
	/**
	 * 根据插入的日期字符串和匹配类型获取一个长整型的参数
	 * 
	 * @param dateStr
	 * @param pattern
	 * @return
	 */
	public static long getLongFromStr(String dateStr, String pattern) {
		Date date = null;
		try {
			date = getDateFromStr(dateStr, pattern);
		} catch (ParseException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		long time = getLongFromDate(date);
		return time;
	}
 
	/**
	 * 根据天数和现在时刻获取Date 类型的若干天以前的日期
	 * 
	 * @param now
	 *            现在
	 * @param serveral
	 * @return
	 */
	public static Date getServeralDaysBeforeNowTime(Date now, Integer serveral) {
		long nowTime = now.getTime();
		long serveralDaysBeforeNowTime = nowTime - (86400000 * serveral);
		Date date = new Date(serveralDaysBeforeNowTime);
		return date;
	}
 
	/**
	 * 根据现在的时间生成2017/11/10 00:11:23 格式的字符串
	 * 
	 * @param now
	 *            现在
	 * @param serveral
	 * @return
	 */
	public static String getNowDateStringByAlert() {
		String pattern = "yyyy/MM/dd HH:mm:ss";
		return getDateStr(new Date(), pattern);
	}
 
	/**
	 * 获取现在时间
	 * 
	 * @return返回字符串格式 yyyy-MM-dd HH:mm:ss
	 */
	public static String getStringDate() {
		Date currentTime = new Date();
		SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String dateString = formatter.format(currentTime);
		return dateString;
	}
	/**
	 * 获取年
	 * 
	 * @return返回字符串格式 yyyy-MM-dd HH:mm:ss
	 */
	public static String getStringYear() {
		Date currentTime = new Date();
		SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
		String dateString = formatter.format(currentTime);
		String dateStr=dateString.split("-")[0];
		return dateStr;
	}
	/**
	 * 获取月
	 * 
	 * @return返回字符串格式 yyyy-MM-dd HH:mm:ss
	 */
	public static String getStringMouth() {
		Date currentTime = new Date();
		SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
		String dateString = formatter.format(currentTime);
		String dateStr=dateString.split("-")[1];
		return dateStr;
	}
	/**
	 * 获取日
	 * 
	 * @return返回字符串格式 yyyy-MM-dd HH:mm:ss
	 */
	public static String getStringTaday() {
		Date currentTime = new Date();
		SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
		String dateString = formatter.format(currentTime);
		String dateStr=dateString.split("-")[2];
		return dateStr;
	}
    /**
     * 获取月份天时间列表
     *
     * @param monthTime 月份时间 格式 yyyy-MM
     * @return 月份天时间列表
     */
    public static List<String> getDayListOfMonth(String monthTime) {

        if (monthTime.length() != 7) {
            return null;
        }
        String[] split = monthTime.split("-");
        List<String> list = new ArrayList<String>();
        String ystr = split[0];
        String mstr = split[1];

        Calendar a = Calendar.getInstance();
        a.set(Calendar.YEAR, Integer.parseInt(ystr));//年份
        a.set(Calendar.MONTH, Integer.parseInt(mstr) - 1);//月份
        a.set(Calendar.DATE, 1);
        a.roll(Calendar.DATE, -1);

        int maxDate = a.get(Calendar.DATE);

        for (int i = 0; i < maxDate; i++) {
            int d = i + 1;
            String dstr = "";
            if (d < 10) {
                dstr = "0" + String.valueOf(d);
            } else {
                dstr = String.valueOf(d);
            }
            String day = ystr + "-" + mstr + "-" + dstr;
            list.add(day);
        }

        return list;
    }
        /**
         * 获取某月的天数
         *
         * @return返回该月的天数
         */
        public static int getDaysOfMonth(Date date) {
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		return calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
	}

	/**
	 * 获取该月天数
	 * 
	 * @return返回字符串格式 yyyy-MM-dd HH:mm:ss
	 */
	public static String getStringTadaysNum() {
		Date currentTime = new Date();
		SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
		String dateString = formatter.format(currentTime);
		String dateStr=dateString.split("-")[2];
		if(dateStr.equals("01") || dateStr.equals("03") || dateStr.equals("05") || dateStr.equals("07") || dateStr.equals("08") || dateStr.equals("10") || dateStr.equals("12")) {
			return "31";
		}else if(dateStr.equals("04") || dateStr.equals("06") || dateStr.equals("09") || dateStr.equals("11")){
			return "30";
		}else {
			int y=Integer.parseInt(dateString.split("-")[0]);
			if(y%4==0 && y%100!=0 || y%400==0) {
				return "29";
			}else {
				return "28";
			}
		}
	}

java 实体类时间格式化

// EasyExcel导出excel时间格式化
import com.alibaba.excel.annotation.format.DateTimeFormat;

@DateTimeFormat(value = "yyyy-MM-dd HH:mm:ss")
private Date time;

// 时间格式化
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date time;

在mybatis-plus中使用时间查询：

queryWrapper.apply("DATE_FORMAT(create_time,'%Y-%m-%d %T') BETWEEN {0} and {1}",params);

pattern: 格式化表达式
timezone: 时区

使用mybatis范围筛选的时候大于等于小于怎么写

含义	原符号	转义字符
小于	<	<
小于等于	<=	<=
大于	>	>
大于等于	>=	>=
逻辑与（和）	&	&
单引号	‘	'
双引号	“	"

@JsonFormat 
默认是标准时区的时间，多出现少8小时的情况
使用时，按需求加上时区 北京时间 东八区 timezone=”GMT+8”
作用:将日期类型数据在JSON格式和java.util.Date对象之间转换。
约束时间的 接收格式 和 响应格式 (接收和响应的都是 JSON字符串 ) ，与传输方向没有关系（前端到后端or后端到前端都可以使用）

@DateTimeFormat 
作用:主要对Date、Calendar、Long及Joda时间类型的属性进行格式化处理，
主要处理前端时间类型与后端pojo对象中的成员变量进行数据绑定，约束前端
传入的时间类型参数格式，所约束的时间格式并不会影响后端返回前端的时间类型数据格式；

区别：
@JsonFormat注解是Jackson的注解，SpringMVC 和 SpringBoot 的默认 json 解析器便是 Jackson；
@DateTimeFormat注解是 spring 的注解。
@DateTimeFormat注解只接收处理 前端form表单post请求里键值对有时间的参数转换
@JsonFormat注解只能处理标准的post请求(Content-type=application/json)里的时间转换。

总结：

前端传给后端
当前端传来的是键值对(两种form表单post请求)，用@DateTimeFormat 规定接收的时间格式。
当前端传来json串，后台用@ReuqestBody接收，用@JsonFormat规定接收的时间格式。
后端传给前端
后端返回给前端的时间值，只能用@JsonFormat返回指定格式字符给前端，@DateTimeFormat无法决定返回值的格式。

LocalDateTime 获取时间

// 获取当前时间时间戳(秒)
Long second = LocalDateTime.now().toEpochSecond(ZoneOffset.of("+8"));

// 获取当前时间时间戳(毫秒)
Long milliSecond = LocalDateTime.now().toInstant(ZoneOffset.of("+8")).toEpochMilli();

// 获取当前时间并格式化
String time = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));

// 获取前一天时间
String time = LocalDateTime.now().plusDays(-1).format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));

// 获取前一个月时间
String time = LocalDateTime.now().plusMonths(-1).format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));

// 获取后一天时间
String time = LocalDateTime.now().plusDays(1).format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));

// 获取当前月的第一天和最后一天 2021-11-01~2021-11-30
LocalDate date = LocalDate.now();
LocalDate firstDay = date.with(TemporalAdjusters.firstDayOfMonth()); // 获取当前月的第一天
LocalDate lastDay = date.with(TemporalAdjusters.lastDayOfMonth()); // 获取当前月的最后一天

// 获取上个月的第一天和最后一天 2021-10-01~2021-10-31
LocalDate date = LocalDate.now();
LocalDate lastMonth = date.minusMonths(1); // 当前月份减1
LocalDate firstDay = lastMonth.with(TemporalAdjusters.firstDayOfMonth()); // 获取上个月的第一天
LocalDate lastDay = lastMonth.with(TemporalAdjusters.lastDayOfMonth()); // 获取上个月的最后一天

// 获取指定月的上个月的第一天和最后一天 2021-02-01~2021-02-28
LocalDate date = LocalDate.of(2021, 3, 14);
LocalDate lastMonth = date.minusMonths(1); // 当前月份减1
LocalDate firstDay = lastMonth.with(TemporalAdjusters.firstDayOfMonth()); // 获取指定月的上个月的第一天
LocalDate lastDay = lastMonth.with(TemporalAdjusters.lastDayOfMonth()); // 获取指定月的上个月的最后一天

// 获取上一年的第一个月和最后一个月 2020-01-01~2020-12-31
LocalDate date = LocalDate.now();
LocalDate lastMonth = date.minusYears(1);
LocalDate firstMonths = lastMonth.with(TemporalAdjusters.firstDayOfYear());
LocalDate lastMonths = lastMonth.with(TemporalAdjusters.lastDayOfYear());

// 获取上周周数 第几周
WeekFields weekFields = WeekFields.of(Locale.getDefault());
int weekNum = LocalDateTime.now().plusDays(-7).get(weekFields.weekOfWeekBasedYear());
System.out.println("上周周数:" + weekNum);

LocalDate now = LocalDate.now();
// 今天是星期几
DayOfWeek dayOfWeek = now.getDayOfWeek();
System.out.println("今天星期" + dayOfWeek.getValue());
// 不包括当天，时间是前一天，需要获取时间+1天
now = now.plusDays(1);
// 本周的第一天
LocalDate first = now.minusDays(dayOfWeek.getValue());
System.out.println("本周第一天:" + first);
// 本周的最后一天
LocalDate last = now.plusDays(7 - dayOfWeek.getValue() - 1);
System.out.println("本周最后一天:" + last);
// 上周的第一天
System.out.println("上周的第一天:" + first.minusWeeks(1));
// 上周的最后一天
System.out.println("上周的最后一天:" + last.minusWeeks(1));

// 获取指定时间
LocalDate localDate = LocalDate.of(2022, 12, 31);
System.out.println(localDate);// 2022-12-31

// 获取当年的天数
int lengthOfYear = now.lengthOfYear();
System.out.println(lengthOfYear); // 365

// 获取当月天数
int lengthOfMonth = now.lengthOfMonth();
System.out.println(lengthOfMonth); //31

// 当天为当年的第多少天
int dayOfYear = now.getDayOfYear();
System.out.println(dayOfYear);// 138

// 当天为当月的第多少天
int dayOfMonth = now.getDayOfMonth();
System.out.println(dayOfMonth);// 18

// 当天为周几
DayOfWeek dayOfWeek = now.getDayOfWeek();
System.out.println(dayOfWeek.toString());// THURSDAY
System.out.println(dayOfWeek.getValue());// 4

// 获取年份或月份
int year = localDate.getYear();
System.out.println(year); // 2022
Month month = localDate.getMonth();
int value = month.getValue();
System.out.println(value); // 12
// 多少号就是当月的第多少天

// 判断指定日期是否是当前日期
LocalDate now = LocalDate.now();
System.out.println(now); // 2023-05-18
LocalDate date = LocalDate.of(2023, 5, 18);
boolean equal = date.isEqual(now);
System.out.println(equal); // true

// 判断日期是否在某日期之后
LocalDate date1 = LocalDate.of(1995, 5, 18);
LocalDate date2 = LocalDate.of(2023, 5, 18);
boolean equal = date1.isAfter(date2);
System.out.println(equal); // false

// 判断日期是否在某日期之前
LocalDate date1 = LocalDate.of(1995, 5, 18);
LocalDate date2 = LocalDate.of(2023, 5, 18);
boolean equal = date1.isBefore(date2);
System.out.println(equal); // true

时间大小比较

日期为String类型

可以使用String的compareTo方法，注意日期格式必须一致。

String date1 = "20220214"；
String date2 = "20210114";
if(date1.compareTo(date2) > 0) {
	System.out.println("date1 大于 date2");
}

日期为date类型

使用Date类型的before() 或 after() 方法

// date1 = "2019-09-29 11:23:50"；
// date2 = "2019-09-29 11:21:20";

// date1在date2之后
if(date1.after(date2)==true){
       System.out.println("date1 大于 date2");  
}
// date2在date1之前
if(date2.before(date1)==true){
       System.out.println("date1 大于 date2"); 
}

转换为秒比较大小

将日期转换为Date类型，使用getTime()方法，比较两日期的大小；

Date date1=df.parse(beginTime);
Date date2=df.parse(endTime);

long long1 =date1.getTime();
long long2= date2.getTime();
if(long1 > long2）{
      System.out.println("date1 > date2");
}

设置Date对象指定日期

// 第一种
// 年-1900，月-1，日，时，分，秒
// 2023-06-05 12:30:25
Date date=new Date(2023-1900,6-1,5,12,30,25);
// 2022-01-05 12:30:25
Date date=new Date(2022-1900,0,5,12,30,25);

// 第二种 使用此方法时必须按照 "年/月/日 时:分:秒" 的顺序格式
Date date=new Date("2023/06/05 12:30:25");

统计年，月，日，java补充无的数据

    @Override
    public R chart(TaxiOrderChartQuery query) throws ParseException {
        List<TaxiOrderChartVO> list = taxiOrderMapper.chart(query);
        //年 yyyy
        List<TaxiOrderChartVO> list1 = new ArrayList<>();
        //月 yyyy-MM
        List<TaxiOrderChartVO> list2 = new ArrayList<>();
        //日 yyyy-MM-dd
        List<TaxiOrderChartVO> list3 = new ArrayList<>();
        //按年统计,没有的年份补充0
        if (query.getType().equals("YEAR")){
            Integer end = Integer.valueOf(query.getEnd());
            Integer start = Integer.valueOf(query.getStart());
            for (int i = start; i <= end; i++) {
                TaxiOrderChartVO vo = new TaxiOrderChartVO();
                boolean flag = false;
                for (TaxiOrderChartVO chartVO : list) {
                    if (chartVO.getType().equals(String.valueOf(i))){
                        flag = true;
                        vo.setOrderNum(chartVO.getOrderNum());
                        vo.setUseNum(chartVO.getUseNum());
                        vo.setType(chartVO.getType());
                    }
                }
                if (!flag){
                    vo.setUseNum(0);
                    vo.setType(String.valueOf(i));
                    vo.setOrderNum(0);
                }
                list1.add(vo);
            }
            return R.ok(list1);
        }
        //按月统计,2023-01至2023-12,没有的部分补充0
        if (query.getType().equals("MONTH")){
            List<String> monthBetweenDate = DateUtils.getMonthBetweenDate(query.getStart(), query.getEnd());
            for (String month : monthBetweenDate) {
                TaxiOrderChartVO vo  = new TaxiOrderChartVO();
                boolean flag = false;
                for (TaxiOrderChartVO chartVO : list) {
                    if (chartVO.getType().equals(month)){
                        flag = true;
                        vo.setOrderNum(chartVO.getOrderNum());
                        vo.setUseNum(chartVO.getUseNum());
                        vo.setType(chartVO.getType());
                    }

                }
                if (!flag){
                    vo.setUseNum(0);
                    vo.setType(month);
                    vo.setOrderNum(0);
                }
                list2.add(vo);
            }

            return R.ok(list2);
        }
        //按日统计,2023-01-12至2023-02-10,没有的部分补充0
        if (query.getType().equals("DAY")){
            List<String> dayBetweenDate = DateUtils.getDayBetweenDate(query.getStart(), query.getEnd());
            for (String day : dayBetweenDate) {
                TaxiOrderChartVO vo  = new TaxiOrderChartVO();
                boolean flag = false;
                for (TaxiOrderChartVO chartVO : list) {
                    if (chartVO.getType().equals(day)){
                        flag = true;
                        vo.setOrderNum(chartVO.getOrderNum());
                        vo.setUseNum(chartVO.getUseNum());
                        vo.setType(chartVO.getType());
                    }

                }
                if (!flag){
                    vo.setUseNum(0);
                    vo.setType(day);
                    vo.setOrderNum(0);
                }
                list3.add(vo);
            }

            return R.ok(list3);
        }
        return R.ok(list);
    }

工具类：

package com.z.common.utils;

import java.text.SimpleDateFormat;
import java.util.*;

/**
 * @author z
 */

public class DateUtils {

    /**
     * 获取两个日期之间的所有月份 (年月)
     * @param startTime
     * @param endTime
     * @return：list
     */
    public static List<String> getMonthBetweenDate(String startTime, String endTime) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM");
        // 声明保存日期集合
        List<String> list = new ArrayList<>();
        try {
            // 转化成日期类型
            Date startDate = sdf.parse(startTime);
            Date endDate = sdf.parse(endTime);
            //用Calendar 进行日期比较判断
            Calendar calendar = Calendar.getInstance();
            while (startDate.getTime() <= endDate.getTime()) {
                // 把日期添加到集合
                list.add(sdf.format(startDate));
                // 设置日期
                calendar.setTime(startDate);
                //把月数增加 1
                calendar.add(Calendar.MONTH, 1);
                // 获取增加后的日期
                startDate = calendar.getTime();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return list;
    }

    /**
     * 获取两个日期之间的所有天数 (年月日)
     * @param startTime
     * @param endTime
     * @return：list
     */
    public static List<String> getDayBetweenDate(String startTime, String endTime) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        // 声明保存日期集合
        List<String> list = new ArrayList<>();
        try {
            // 转化成日期类型
            Date startDate = sdf.parse(startTime);
            Date endDate = sdf.parse(endTime);
            //用Calendar 进行日期比较判断
            Calendar calendar = Calendar.getInstance();
            while (startDate.getTime() <= endDate.getTime()) {
                // 把日期添加到集合
                list.add(sdf.format(startDate));
                // 设置日期
                calendar.setTime(startDate);
                //把天数增加 1
                calendar.add(Calendar.DATE, 1);
                // 获取增加后的日期
                startDate = calendar.getTime();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return list;
    }
    
}

原文章地址：
https://blog.csdn.net/weixin_42678425/article/details/106728070
https://www.jb51.net/article/235214.htm

大狮纸

关注

3
点赞
踩
9

收藏

觉得还不错? 一键收藏
2
评论
时间格式化

后端返回给前端的时间值，只能用@JsonFormat返回指定格式字符给前端，@DateTimeFormat无法决定返回值的格式。当前端传来的是键值对(两种form表单post请求)，用@DateTimeFormat 规定接收的时间格式。当前端传来json串，后台用@ReuqestBody接收，用@JsonFormat规定接收的时间格式。将日期转换为Date类型，使用getTime()方法，比较两日期的大小；使用Date类型的before() 或 after() 方法。
复制链接

扫一扫