Java8日期API

最新推荐文章于 2024-04-30 03:27:32 发布
最新推荐文章于 2024-04-30 03:27:32 发布
阅读量334 收藏
点赞数 1
分类专栏： Java8 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43863895/article/details/114990953
版权

Java8 日期API

简介

java8推出了一套全新的日期API，为什么要再出一套API呢，那是因为，之前的日期操作不是线程安全的，是可变的。Java8时间相关类在java.time包路径下，新的日期API之所有线程安全，是因为全新的日期操作都会返回一个新的对象实例，所有安全。

简单实用

LocalDate、LocalTime、LocalDateTime

LocalDate、LocalTime、LocalDateTime 类的实例是不可变的对象，分别表示使用 ISO-8601日历系统的日期、时间、日期和时间。它们提供
了简单的日期或时间，并不包含当前的时间信
息。也不包含与时区相关的信息。

这三个类都是由 final 修饰
在这里插入图片描述
获取当前时间

//获取当前时间
LocalDateTime now = LocalDateTime.now();
System.out.println(now);// 2021-03-18T20:49:40.549

获取指定日期，包括年月日时分秒

//指定 年月日时分秒
LocalDateTime ldt = LocalDateTime.of(2021, 3, 20, 12, 12,12);
System.out.println(ldt);// 2021-03-20T12:12:12
方法修饰符及返回值方法名称及参数方法说明
static LocalDateTimeof(int year, int month, int dayOfMonth, int hour, int minute)从年，月，日，小时和分钟获得 LocalDateTime的实例，将秒和纳秒设置为零
static LocalDateTimeof(int year, int month, int dayOfMonth, int hour, int minute, int second)从年，月，日，小时，分钟和秒获得 LocalDateTime的实例，将纳秒设置为零
static LocalDateTimeof(int year, int month, int dayOfMonth, int hour, int minute, int second, int nanoOfSecond)从年，月，日，小时，分钟和秒以及纳秒获得 LocalDateTime的实例
static LocalDateTimeof(int year, Month month, int dayOfMonth, int hour, int minute)从年，月，日，小时和分钟获得 LocalDateTime的实例，将秒和纳秒设置为零
static LocalDateTimeof(int year, Month month, int dayOfMonth, int hour, int minute, int second)从年，月，日，小时，分钟和秒获得 LocalDateTime的实例，将纳秒设置为零
static LocalDateTimeof(int year, Month month, int dayOfMonth, int hour, int minute, int second, int nanoOfSecond)从年，月，日，小时，分钟和秒以及纳秒获得 LocalDateTime的实例

对时间的加减操作

//获取当前时间
LocalDateTime now = LocalDateTime.now();
System.out.println(now);// 2021-03-18T21:12:07.982
LocalDateTime plusYears = now.plusYears(1);
System.out.println(plusYears);//2022-03-18T21:12:07.982
方法修饰符及返回值方法名称及参数方法说明
LocalDateTimeplus(long amountToAdd, TemporalUnit unit)amountToAdd:要增加的数值
TemporalUnit :单位，可以参考java.time.temporal.ChronoUnit枚举
LocalDateTimeplusDays(long days)加多少天
LocalDateTimeplusHours(long hours)加多少秒
LocalDateTimeplusMinutes(long minutes)加多少分钟
LocalDateTimeplusMonths(long months)加几个月
LocalDateTimeplusWeeks(long weeks)加多少星期
LocalDateTimeplusYears(long years)加多少年

同理还有对应的减日期的操作
minusxxx方法，这里就不一一列举了。

得到具体的年月日…

方法修饰符及返回值方法名称及参数方法说明
intget(TemporalField field)获取指定字段的值,TemporalField的实现类，参考java.time.temporal.ChronoField
intgetYear()获取年份
MonthgetMonth()使用 Month枚举获取月份字段
intgetMonthValue()月份 1 到 12
intgetDayOfMonth()获取 日 1到 31
intgetDayOfYear()一年中的第几天
DayOfWeekgetDayOfWeek()星期几
intgetHour()时
intgetMinute()分
intgetSecond()秒

修改时间

方法修饰符及返回值方法名称及参数方法说明
LocalDateTimewithDayOfYear(int dayOfYear)修改 day 字段
LocalDateTimewithHour(int hour)修改H字段
………
//获取当前时间
LocalDateTime now = LocalDateTime.now();
System.out.println(now);// 2021-03-18T21:43:46.373
System.out.println("年份: " + now.getYear());// 年份: 2021
System.out.println("月份: " + now.getMonth());//月份: MARCH
System.out.println("月份: " + now.getMonthValue());// 月份: 3
System.out.println("日: " + now.getDayOfMonth());// 日: 18
System.out.println("日: " + now.getDayOfYear());// 日: 77
System.out.println("星期 : " + now.getDayOfWeek());// 日: THURSDAY
System.out.println("时: " + now.getHour());// 时: 21
System.out.println("分: " + now.getMinute());// 分: 43
System.out.println("秒: " + now.getSecond());//秒: 46

Instant

Instant 时间戳
它是以Unix元年 1970年1月1日 00:00:00 到某时间的毫秒值。

获取当前时间戳

Instant instant = Instant.now();
System.out.println(instant);//2021-03-18T14:01:53.068Z

注意: 输出 2021-03-18T14:01:53.068Z ，但是系统时间为22:01:53
因为 输出的是UTC时间，北京时间需要在此基础上加8个小时，相差8个时区

进行偏移量计算

Instant instant = Instant.now();
System.out.println(instant);   //2021-03-18T14:18:38.049Z
		
OffsetDateTime atOffset = instant.atOffset(ZoneOffset.ofHours(8));	
System.out.println(atOffset);    //2021-03-18T22:18:38.049+08:00

//获取纳秒
System.out.println(instant.getNano());//49000000

//指定 时间戳,1970年1月1日0时0分0秒开始，加上3600秒(1个小时)
System.out.println(instant.ofEpochSecond(3600));//1970-01-01T01:00:00Z
方法修饰符及返回值方法名称及参数方法说明
longtoEpochMilli()1970-01-01T00:00:00Z到此时间戳的毫秒值
longgetEpochSecond()1970-01-01T00:00:00Z到此时间戳的秒数
intgetNano()获取 2021-03-18T14:18:38.049Z 秒后面的049Z的纳秒值
static InstantofEpochSecond(long epochSecond)从1970-01-01T00：00：00Z开始，加上指定的秒数获得一个 Instant的实例

Duration & Period

Duration是计算 两个 “时间” 之间的间隔
Period 是计算 两个 “日期” 之间的间隔

Instant instant1 = Instant.now();
Thread.sleep(3000);
Instant instant2 = Instant.now();
		
Duration between = Duration.between(instant1, instant2);
System.out.println(between);// PT3.011S
//获取 秒
System.out.println(between.getSeconds());// 3
		
//获取毫秒
System.out.println(between.toMillis());// 3011

//获取纳秒
System.out.println(between.getNano());//11000000


LocalDate ld1 = LocalDate.of(2021, 3, 18);
LocalDate ld2 = LocalDate.of(2022, 4, 19);
Period between = Period.between(ld1, ld2);
System.out.println(between);// P1Y1M1D  相差 1年 1月 1日
System.out.println(between.getYears());//1
System.out.println(between.getMonths());//1
System.out.println(between.getDays());//1

时间调整

TemporalAdjuster : 时间校正器。
有时我们可能需要获取例如：将日期调整到“下个周日”等操作
TemporalAdjusters: 该类通过静态方法提供了大量的常
用 TemporalAdjuster 的实现

    LocalDateTime ldt = LocalDateTime.now();
	System.out.println(ldt);// 2021-03-18T23:36:49.352
	LocalDateTime ldt2 = ldt.withMonth(5);
	System.out.println(ldt2);// 2021-05-18T23:36:49.352
	
	//下一个 周一，当前日期为 2021年03月18日，星期四
	LocalDateTime ldt3 = ldt.with(TemporalAdjusters.next(DayOfWeek.MONDAY));
	System.out.println(ldt3);// 2021-03-22T23:36:49.352
	
	//自定义，下一个工作日
	LocalDateTime ldt4 = ldt.with((temporal) -> {
		LocalDateTime localDateTime = (LocalDateTime) temporal;
		
		DayOfWeek dayOfWeek = localDateTime.getDayOfWeek();//获取星期几
		
		if(dayOfWeek.equals(DayOfWeek.FRIDAY)) {// 周五，下一个工作日 加3天
			return localDateTime.plusDays(3);
		}else if(dayOfWeek.equals(DayOfWeek.SATURDAY)) {
			return localDateTime.plusDays(2);
		}else {
			return localDateTime.plusDays(1);
		}
	});
	System.out.println(ldt4);// 2021-03-19T23:36:49.352

带时区的日期

ZonedDateTime 用来表示带时区信息的日期。

一个时区ID，如Europe/Paris
ZoneId用于识别用于在Instant和LocalDateTime之间转换的规则。

时区ID
该ID在系统内是唯一的。 有三种类型的ID。
最简单的ID是ZoneOffset 。 这由“Z”和以“+”或“ - ”开头的ID组成。

下一种类型的ID是具有某些形式的前缀的偏移样式ID，例如“GMT + 2”或“UTC + 01：00”。 识别的前缀是“UTC”，“GMT”和“UT”。 偏移量是后缀，在创建过程中将被归一化。 这些ID可以归一ZoneOffset使用normalized() 。

第三种类型的ID是基于区域的ID。 基于区域的ID必须为两个或更多个字符，而不是以“UTC”，“GMT”，“UT”+“或” - “开头。 基于区域的ID由配置定义，请参见ZoneRulesProvider 。 配置重点是提供从ID到底层的查找ZoneRules

时区规则由政府界定，频繁变化。 有一些组织，这里被称为组，监视时区更改并整理它们。 默认组是IANA时区数据库（TZDB）。 其他组织包括国际航协（航空业机构）和微软。

方法修饰符及方法返回值方法名称及参数方法说明
static SetgetAvailableZoneIds()获取所有可用的时区ID
static ZoneIdof(String zoneId)zoneId可以参考 getAvailableZoneIds 返回集合里面的值

获取当前时间(指定时区)

LocalDateTime sh = LocalDateTime.now(ZoneId.of("Asia/Shanghai"));//上海
LocalDateTime tokyo = LocalDateTime.now(ZoneId.of("Asia/Tokyo"));//东京

System.out.println(sh);      // 上海时间: 2021-03-19T11:59:44.378
System.out.println(tokyo);   //  东京时间: 2021-03-19T12:59:44.378

显示时区信息

LocalDateTime tokyo = LocalDateTime.now(ZoneId.of("Asia/Tokyo"));//东京
System.out.println("东京时间: " + tokyo);  
		
LocalDateTime ldt = LocalDateTime.now(ZoneId.of("Asia/Tokyo"));
ZonedDateTime atZone = ldt.atZone(ZoneId.of("Asia/Tokyo"));
System.out.println("东京时间: " + atZone);

东京时间: 2021-03-19T13:27:03.599
东京时间: 2021-03-19T13:27:03.599+09:00[Asia/Tokyo]
注意:
LocalDateTime ldt = LocalDateTime.now(ZoneId.of(“Asia/Tokyo”));
ZonedDateTime atZone = ldt.atZone(ZoneId.of(“Asia/Tokyo”));
这里在构建时间时必须指定相同的时区

DateTimeFormatter 日期格式化

日期转字符串

DateTimeFormatter类已经写好了很多日期格式
在这里插入图片描述

DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ISO_DATE;
LocalDateTime ldt = LocalDateTime.now();
String format = ldt.format(dateTimeFormatter);
System.out.println("格式化前: " + ldt);// 格式化前: 2021-03-19T11:19:35.369
System.out.println("格式化后： " +format);//格式化后： 2021-03-19

自定义格式

DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ISO_DATE;
LocalDateTime ldt = LocalDateTime.now();		
DateTimeFormatter pattern = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss");
String format2 = ldt.format(pattern);
System.out.println(format2);   //    2021/03/19 11:19:35

字符串转日期

LocalDateTime ldt = LocalDateTime.now();	
DateTimeFormatter pattern = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss");
String format2 = ldt.format(pattern);
System.out.println(format2);//  2021/03/19 11:19:35
		
LocalDateTime parse = ldt.parse(format2,pattern);
System.out.println(parse);//  2021-03-19T11:19:35

注意: 将字符串转日期使，parse方法如果不传格式化匹配器的话，默认是按照ISO 8601标准格式(类似 2021-03-19T11:19:35 )去转换
在这里插入图片描述

时间转换

//时间戳 转 LocalDateTime
		Instant instant = Instant.now();
		LocalDateTime ldt = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
		System.out.println(ldt);
		
		//时间戳转时区时间
		ZonedDateTime zonedDateTime = ZonedDateTime.ofInstant(instant, ZoneId.systemDefault());
		System.out.println(zonedDateTime);
		
		//LocalDateTime 转时间戳 因为LocalDateTime不带时区信息，因此需要指定当前时区到UTC的offset
		Instant instant2 = ldt.toInstant(ZoneOffset.ofHours(8));
		System.out.println(instant2);
		
		//时区时间转时间戳 ZonedDateTime自带时区信息
		Instant instant3 = zonedDateTime.toInstant();
		System.out.println(instant3);
		
		// LocalDateTime转时区时间（为时间加上时区信息）
		ZonedDateTime zonedDateTime2 = ZonedDateTime.of(ldt, ZoneId.systemDefault());
		//ZonedDateTime atZone = ldt.atZone(ZoneId.systemDefault()); 也可以使用这种方式
		//System.out.println(atZone);
		System.out.println(zonedDateTime2);
		
		// 时区时间转换为LocalDateTime，将时区时间的时区信息去除
        LocalDateTime ldt2 = zonedDateTime.toLocalDateTime();
        System.out.println(ldt2);

输出如下

2021-03-19T13:41:50.708
2021-03-19T13:41:50.708+08:00[Asia/Shanghai]
2021-03-19T05:41:50.708Z
2021-03-19T05:41:50.708Z
2021-03-19T13:41:50.708+08:00[Asia/Shanghai]
2021-03-19T13:41:50.708

LocalDateTime与Date转换

Instant和Date是新老时间转换的桥梁，二者都是时间戳的表现形式，但Date在打印时会转换成当前时区时间（可通过设置TimeZone调整），Instant打印时默认是0时区时间

Date 转 LocalDateTime

        // Date 转 LocalDateTime
		Date date = new Date();
		System.out.println(date);
		
		Instant instant = date.toInstant();
		// 方法 一
		LocalDateTime ldt = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
		System.out.println(ldt);
		
		//方法二
		LocalDateTime ldt2 = instant.atZone(ZoneId.systemDefault()).toLocalDateTime();
		System.out.println(ldt2);

输出

Fri Mar 19 13:58:09 CST 2021
2021-03-19T13:58:09.634
2021-03-19T13:58:09.634

LocalDateTime 转 Date

        ZoneId zoneId = ZoneId.systemDefault();
		// 第一步 将 LocalDateTime 转为 ZonedDateTime
		LocalDateTime ldt = LocalDateTime.now();		
		ZonedDateTime zone = ldt.atZone(zoneId);
		// 也可以 使用这种方式
		//ZonedDateTime zone2 = ZonedDateTime.of(ldt, zoneId);
		// 第二步 将ZonedDateTime转为instant
		Instant instant = zone.toInstant();
		
		// 从Instant 获取Date
		Date date = Date.from(instant);
		System.out.println("LocalDateTime = " + ldt);
		System.out.println("Date = " + date);

输出

LocalDateTime = 2021-03-19T14:10:05.968
Date = Fri Mar 19 14:10:05 CST 2021

工具类 LocalDateTimeUtils

package com.qianxun.utils;

import java.time.DayOfWeek;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoField;
import java.time.temporal.TemporalAccessor;
import java.time.temporal.TemporalField;
import java.time.temporal.UnsupportedTemporalTypeException;
import java.util.Date;


/**
 * JDK8+中的LocalDateTime 工具类封装
 * 
 * @author qianxun
 *
 */
public class LocalDateTimeUtils {

	private static final ZoneId ZONE_ID_DEFAULT = ZoneId.systemDefault();

	private static final ZoneId ZONE_ID_UTC = ZoneId.of("UTC");

	//private static String YYYY_MM_DD = "yyyy-MM-dd";

	//private static String YYYYMMDDHHMMSS = "yyyyMMddHHmmss";

	private static String YYYY_MM_DD_HH_MM_SS = "yyyy-MM-dd HH:mm:ss";
	
	private static String[] parsePatterns = {
            "yyyy-MM-dd", "yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd HH:mm", 
            "yyyy/MM/dd", "yyyy/MM/dd HH:mm:ss", "yyyy/MM/dd HH:mm", 
            "yyyy.MM.dd HH:mm:ss"};

	/**
	 * <pre>
	 * 当前时间，默认时区
	 * 返回格式如下 2021-03-19T14:29:08.551
	 * </pre>
	 * 
	 * @return {@link LocalDateTime}
	 */
	public static LocalDateTime now() {
		return LocalDateTime.now();
	}

	/**
	 * 日期路径 即年/月/日 如2021/03/18
	 */
	public static final String datePath() {

		return format(now(), "yyyy/MM/dd");
	}

	/******** 日期转换部分 start ***/

	/**
	 * 使用系统默认时区，将Instant 转 LocalDateTime
	 * 
	 * @param instant
	 *            {@link Instant}
	 * @return {@link LocalDateTime}
	 */
	public static LocalDateTime toLocalDateTime(Instant instant) {
		return toLocalDateTime(instant, null);
	}

	/**
	 * 使用UTC时区(格林威治 时间标准时间 0时区),将Instant 转 LocalDateTime
	 *
	 * @param instant
	 *            {@link Instant}
	 * @return {@link LocalDateTime}
	 */
	public static LocalDateTime toLocalDateTimeUTC(Instant instant) {
		return toLocalDateTime(instant, ZONE_ID_UTC);
	}

	/**
	 * <pre>
	 * 使用指定的时区id,将Instant 转 LocalDateTime，
	 * 如果 ZoneId 为 NULL 则使用系统默认时区
	 * </pre>
	 * 
	 * @param instant
	 *            {@link Instant}
	 * @param zoneId
	 *            {@link ZoneId}
	 * @return {@link LocalDateTime}
	 */
	public static LocalDateTime toLocalDateTime(Instant instant, ZoneId zoneId) {
		if (null == instant) {
			return null;
		}
		// ZoneId 为 NULL 则使用系统默认时区
		ZoneId zoneIdUse = (null == zoneId) ? ZONE_ID_DEFAULT : zoneId;

		return LocalDateTime.ofInstant(instant, zoneIdUse);
	}

	/**
	 * ZonedDateTime 转 LocalDateTime
	 * 
	 * @param zonedDateTime
	 *            {@link ZonedDateTime}
	 * @return {@link LocalDateTime}
	 */
	public static LocalDateTime toLocalDateTime(ZonedDateTime zonedDateTime) {
		if (null == zonedDateTime) {
			return null;
		}
		return zonedDateTime.toLocalDateTime();
	}

	/**
	 * 使用系统默认时区，Date 转 LocalDateTime
	 * 
	 * @param date
	 *            {@link Date}
	 * @return {@link LocalDateTime}
	 */
	public static LocalDateTime toLocalDateTime(Date date) {
		if (null == date) {
			return null;
		}
		Instant instant = date.toInstant();
		return LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
	}

	/**
	 * 毫秒转{@link LocalDateTime}，使用默认时区
	 *
	 * <p>
	 * 注意：此方法使用默认时区，如果非UTC，会产生时间偏移
	 * </p>
	 *
	 * @param epochMilli
	 *            从1970-01-01T00:00:00Z开始计数的毫秒数
	 * @return {@link LocalDateTime}
	 */
	public static LocalDateTime toLocalDateTime(long epochMilli) {
		return toLocalDateTime(Instant.ofEpochMilli(epochMilli));
	}

	/**
	 * 毫秒转{@link LocalDateTime}，使用UTC时区
	 *
	 * @param epochMilli
	 *            从1970-01-01T00:00:00Z开始计数的毫秒数
	 * @return {@link LocalDateTime}
	 */
	public static LocalDateTime toLocalDateTimeUTC(long epochMilli) {
		return toLocalDateTimeUTC(Instant.ofEpochMilli(epochMilli));
	}

	/******** 日期转换部分 end ***/

	/** 日期时间 解析部分 start */

	/**
	 * 解析日期时间字符串为{@link LocalDateTime}，仅支持yyyy-MM-dd'T'HH:mm:ss格式，例如：2007-12-03T10:15:30
	 *
	 * @param text
	 *            日期时间字符串
	 * @return {@link LocalDateTime}
	 */
	public static LocalDateTime parse(CharSequence text) {
		return parse(text, (DateTimeFormatter) null);
	}

	/**
	 * 解析日期时间字符串为{@link LocalDate}，仅支持yyyy-MM-dd，例如：2021-03-18
	 *
	 * @param text
	 *            日期时间字符串
	 * @return {@link LocalDate}
	 */
	public static LocalDate parseDate(CharSequence text) {
		return parseDate(text, (DateTimeFormatter) null);
	}

	/**
	 * 解析日期时间字符串为{@link LocalDateTime}，格式支持日期时间、日期、时间
	 *
	 * @param text
	 *            日期时间字符串
	 * @param formatter
	 *            日期格式化器，预定义的格式见：{@link DateTimeFormatter}
	 * @return {@link LocalDateTime}
	 */
	public static LocalDateTime parse(CharSequence text, DateTimeFormatter formatter) {
		if (null == text) {
			return null;
		}
		if (null == formatter) {
			// 使用ISO 8601标准格式
			return LocalDateTime.parse(text);
		}
		// return LocalDateTime.parse(text,formatter);
		return of(formatter.parse(text));
	}

	/**
	 * 解析日期字符串为{@link LocalDateTime}
	 * 
	 * @param text
	 * @param format
	 * @return
	 */
	public static LocalDateTime parse(CharSequence text, String format) {
		if (null == text) {
			return null;
		}
		return parse(text, DateTimeFormatter.ofPattern(format));
	}
	
	/**
	 * 通过给定的日期格式解析日期时间字符串。<br>
	 * 传入的日期格式会逐个尝试，直到解析成功，返回{@link LocalDateTime}对象，否则抛出{@link RuntimeException}异常
	 * 
	 * @param text
	 * @param format
	 * @return
	 */
	public static LocalDateTime parse(String text, String... format) {
		if (null == text) {
			return null;
		}
		return parseByPatterns(text, parsePatterns);
	}
	

	/**
	 * 解析日期时间字符串为{@link LocalDate}，格式支持日期
	 *
	 * @param text
	 *            日期时间字符串
	 * @param formatter
	 *            日期格式化器，预定义的格式见：{@link DateTimeFormatter}
	 * @return {@link LocalDate}
	 */
	public static LocalDate parseDate(CharSequence text, DateTimeFormatter formatter) {
		if (null == text) {
			return null;
		}
		if (null == formatter) {
			return LocalDate.parse(text);
		}

		return ofDate(formatter.parse(text));
	}

	/**
	 * 解析日期字符串为{@link LocalDate}
	 *
	 * @param text
	 *            日期字符串
	 * @param format
	 *            日期格式，类似于yyyy-MM-dd
	 * @return {@link LocalDateTime}
	 */
	public static LocalDate parseDate(CharSequence text, String format) {
		if (null == text) {
			return null;
		}
		return parseDate(text, DateTimeFormatter.ofPattern(format));
	}

	/**
	 * 格式化日期时间为yyyy-MM-dd HH:mm:ss格式
	 *
	 * @param time
	 *            {@link LocalDateTime}
	 * @return 格式化后的字符串
	 */
	@SuppressWarnings("unused")
	private static String formatNormal(LocalDateTime time) {
		return format(time, DateTimeFormatter.ofPattern(YYYY_MM_DD_HH_MM_SS));
	}

	/**
	 * 格式化日期时间为指定格式
	 *
	 * @param time
	 *            {@link LocalDateTime}
	 * @param formatter
	 *            日期格式化器，预定义的格式见：{@link DateTimeFormatter}
	 * @return 格式化后的字符串
	 */
	public static String format(LocalDateTime time, DateTimeFormatter formatter) {
		return format(time, formatter);
	}

	/**
	 * 格式化日期时间为指定格式
	 *
	 * @param time
	 *            {@link LocalDateTime}
	 * @param format
	 *            日期格式，类似于yyyy-MM-dd HH:mm:ss,SSS
	 * @return 格式化后的字符串
	 */
	public static String format(LocalDateTime time, String format) {
		if (null == time) {
			return null;
		}
		return format(time, DateTimeFormatter.ofPattern(format));
	}

	/**
	 * 格式化日期时间为指定格式
	 *
	 * @param time
	 *            {@link TemporalAccessor}
	 * @param formatter
	 *            日期格式化器，预定义的格式见：{@link DateTimeFormatter}
	 * @return 格式化后的字符串
	 */
	public static String format(TemporalAccessor time, DateTimeFormatter formatter) {
		if (null == time) {
			return null;
		}

		if (null == formatter) {
			formatter = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
		}

		try {
			return formatter.format(time);
		} catch (UnsupportedTemporalTypeException e) {
			if (time instanceof LocalDate && e.getMessage().contains("HourOfDay")) {
				// 用户传入LocalDate，但是要求格式化带有时间部分，转换为LocalDateTime重试
				return formatter.format(((LocalDate) time).atStartOfDay());
			} else if (time instanceof LocalTime && e.getMessage().contains("YearOfEra")) {
				// 用户传入LocalTime，但是要求格式化带有日期部分，转换为LocalDateTime重试
				return formatter.format(((LocalTime) time).atDate(LocalDate.now()));
			}
			throw e;
		}
	}

	/******** 日期转换部分 end ***/

	/**
	 * {@link TemporalAccessor}转{@link LocalDateTime}，使用默认时区
	 * 
	 * @param temporalAccessor
	 * @return
	 */
	public static LocalDateTime of(TemporalAccessor temporalAccessor) {
		if (null == temporalAccessor) {
			return null;
		}

		if (temporalAccessor instanceof LocalDate) {
			return ((LocalDate) temporalAccessor).atStartOfDay();
		}

		return LocalDateTime.of(getField(temporalAccessor, ChronoField.YEAR),
				getField(temporalAccessor, ChronoField.MONTH_OF_YEAR),
				getField(temporalAccessor, ChronoField.DAY_OF_MONTH),
				getField(temporalAccessor, ChronoField.HOUR_OF_DAY),
				getField(temporalAccessor, ChronoField.MINUTE_OF_HOUR),
				getField(temporalAccessor, ChronoField.SECOND_OF_MINUTE),
				getField(temporalAccessor, ChronoField.NANO_OF_SECOND));
	}

	/**
	 * {@link TemporalAccessor}转{@link LocalDate}，使用默认时区
	 * 
	 * @param temporalAccessor
	 * @return
	 */
	public static LocalDate ofDate(TemporalAccessor temporalAccessor) {
		if (null == temporalAccessor) {
			return null;
		}

		if (temporalAccessor instanceof LocalDateTime) {
			return ((LocalDateTime) temporalAccessor).toLocalDate();
		}

		return LocalDate.of(getField(temporalAccessor, ChronoField.YEAR),
				getField(temporalAccessor, ChronoField.MONTH_OF_YEAR),
				getField(temporalAccessor, ChronoField.DAY_OF_MONTH));
	}

	/**
	 * 获取下一个 工作日 默认 周一 至 周五
	 * 
	 * @return
	 */
	public static LocalDateTime getNextWorkDay() {
		LocalDateTime now = now();
		LocalDateTime workDay = now.with((temporal) -> {
			LocalDateTime localDateTime = (LocalDateTime) temporal;

			DayOfWeek dayOfWeek = localDateTime.getDayOfWeek();// 获取星期几

			if (dayOfWeek.equals(DayOfWeek.FRIDAY)) {// 周五，下一个工作日 加3天
				return localDateTime.plusDays(3);
			} else if (dayOfWeek.equals(DayOfWeek.SATURDAY)) {
				return localDateTime.plusDays(2);
			} else {
				return localDateTime.plusDays(1);
			}
		});
		return workDay;
	}

	/**
	 * 安全获取时间的某个属性，属性不存在返回0
	 *
	 * @param temporalAccessor
	 *            需要获取的时间对象
	 * @param field
	 *            需要获取的属性
	 * @return 时间的值，如果无法获取则默认为 0
	 */
	private static int getField(TemporalAccessor temporalAccessor, TemporalField field) {
		if (temporalAccessor.isSupported(field)) {
			return temporalAccessor.get(field);
		}
		return (int) field.range().getMinimum();
	}
	
	
	public static LocalDateTime parseByPatterns(String str,final String... parsePatterns) throws RuntimeException{
		if (str == null || parsePatterns == null) {
			throw new IllegalArgumentException("解析匹配格式不能为空");
		}
		
		for (final String parsePattern : parsePatterns){
			try {
				return parse(str, parsePattern);
			} catch (final DateTimeParseException ignore) {
				
			}
		}		
		throw new RuntimeException("解析失败...");
	}
}
千寻物语
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
18个Java8日期处理的实践(太有用了)
08-25
在 Java 8 中，引入了新的日期和时间 API，基于 ISO 标准日历系统，所有类都是不可变类型且线程安全。 以下是 Java 8 日期处理实践的 18 个示例，涵盖了日期处理的方方面面： 1. 获取今天的日期：使用 LocalDate....
B-java8-date-time-api-homework:Java8日期时间API的作业
03-31
Java8日期时间API作业 Java8日期时间API的课后作业 根据说明分别实现 根据MeetingSystemV3的说明在脑洞会议系统v2.0的基础上实现新增需求
Java8日期Api
qq_37436172的博客
07-11 421
java8推出了一套全新的日期API，为什么要再出一套API呢，那是因为，之前的日期操作不是线程安全的，是可变的。Java8时间相关类在java.time包路径下，新的日期API之所有线程安全，是因为全新的日期操作都会返回一个新的对象实例，所以安全。LocalDate(年月日)、LocalTime(时分秒纳秒)、LocalDateTime 类的实例是不可变的对象，分别表示使用 ISO-8601日历系统的日期、时间、日期和时间。它们提供 了简单的日期或时间，并不包含当前的时...
一步解决 java.time.temporal.UnsupportedTemporalTypeException: Unsupported field: YearOfEra
孤er尽悲欢绝的博客
12-01 1909
一步解决 java.time.temporal.UnsupportedTemporalTypeException: Unsupported field: YearOfEra
高级JAVA开发必备技能：java8 新日期时间API（(三)JSR-310：格式化和解析）（JAVA 小虚竹
最新发布
2401_84247617的博客
04-30 675
分析原因：是格式字符串与实际的时间不匹配中间的月份格式是MM，实际时间是7解决方案：保持格式字符串与实际的时间匹配。
java字符串时区转时间格式_如何在java.time中的模式字符串中格式化日期与时区？...
weixin_34550555的博客
02-24 1718
我有一个格式化程序的字符串模式yyyy-MM-dd HH:mm:ss Z如何使用这种模式解析java.util.Date？问题是此模式中的时区已经存在.String DATE_TIME_FORMAT = "yyyy-MM-dd HH:mm:ss Z";DateTimeFormatter.ofPattern(DATE_TIME_FORMAT).format(date.toInstant());这显然...
java8日期和时间API全解——更完善的日期和时间API
秃了也弱了
08-24 1258
在 Java 8 之前，我们处理日期时间需求时，使用 Date、Calender 和 SimpleDateFormat，来声明时间戳、使用日历处理日期和格式化解析日期时间。但是，这些类的 API 的缺点比较明显，比如可读性差、易用性差、使用起来冗余繁琐，SimpleDateFormat还有线程安全问题。比如：年份的起始选择是1900年，月份的起始从0开始。// 它的打印输出效果为： Tue Mar 18 00 : 00 : 00 CET 2014。
2024年网络安全山东省赛-SMB信息收集解析（中职组）_使用访问工具对服务器服务访问,将服务器中管理员桌面的文本文档里的内容作为 flag
2401_84252281的博客
04-26 629
任务环境说明：服务器场景：Server1。
解决Spring Boot和Feign中使用Java 8时间日期API（LocalDate等）的序列化问题
08-27
"解决Spring Boot和Feign中使用Java 8时间日期API（LocalDate等）的序列化问题" 在本文中，我们讨论了使用Java 8时间日期API（LocalDate等）在Spring Boot和Feign中的序列化问题，并提供了解决方案。 在Java 8中...
java8、jdk8日期转化成字符串详解
08-26
Java8 中引入了新的日期和时间 API，提供了更好的日期处理方式。在本文中，我们将详细介绍 Java8、JDK8 日期转化成字符串的相关知识点和代码。 日期转化成字符串的需求 在 Java 开发中，日期转化成字符串是很常见...
Java8的常用时间api实用指南
08-26
Java 8 引入了一套全新的时间日期API，极大地简化了日期和时间的处理，相比传统的`Calendar`类，新API更加直观且易于使用。在本文中，我们将深入探讨Java 8中的三个主要时间API：`Instant`、`LocalDate`和`...
python datetime模块源代码_python 常用日期处理-- datetime 模块的使用
weixin_28711397的博客
02-19 211
仅以此篇记录一下个人常用的 Python 处理日期的库与函数，主要涉及的类库有 Python 自带的 datetime, time 和 calendar，以及第三方的 dateutil。说到日期处理基本上要覆盖的概念有 date, time, datetime, timezone, calendar, 时间的比较与差值，解析与格式化显示等。在 datetime 模块中类之间的继承关系如下：obje...
Java8 日期/时间（Date Time）API指南
来啊 快活啊
04-11 1689
Java 8日期/时间（ Date/Time）API是开发人员最受追捧的变化之一，Java从一开始就没有对日期时间处理的一致性方法，因此日期/时间API也是除Java核心API以外另一项倍受欢迎的内容。为什么我们需要新的Java日期/时间API？ 在开始研究Java 8日期/时间API之前，让我们先来看一下为什么我们需要这样一个新的API。在Java中，现有的与日期和时间相关的类存在诸多问题，其中
Java 8的日期和时间 API
小黑说Java
12-30 188
在Java8中，不仅推出了Lambda表达式、streams流以及一些优化，对于日期和时间的处理也推出了全新的API。 本文将带大家全面的了解新的日期和时间API的使用。 LocalDate Java8中的Date/Time API都放在java.time包中；LocalDate表示一个只有年-月-日的日期对象，我们看一下如何来创建一个LocalDat.
Java 8-新的日期和时间API
杨钊
07-02 6277
日期和时间：LocalDate和LocalTime LocalDate类，该类的实例是一个不可变对象，它只提供了简单的日期，并不含当天的时间信息。另外，它也不附带任何与时区相关的信息。 可以通过静态工厂方法of创建一个LocalDate实例。LocalDate实例提供了多种方法来读取常用的值，比如年份、月份、星期几等。 LocalDate date=LocalDate.of(2014,3...
Java8新增加的时间日期API
热门推荐
底层码农
02-19 1万+
介绍：https://blog.csdn.net/qq_40794973/article/details/86882454#t67 Java8以前的实际日期API:http://www.runoob.com/java/java-date-time.html 常用类 LocalDateTime 创建对象： @Test public void test() { //no...
java8实战十一: java8----新的日期时间API
只有变秃 才能变强
12-02 8235
java8中 新的时间和日期APIJava的API提供了很多有用的组件，能帮助你构建复杂的应用。不过，Java API也不总是完美 的。我们相信大多数有经验的程序员都会赞同Java 8之前的库对日期和时间的支持就非常不理想。 然而，你也不用太担心：Java 8中引入全新的日期和时间API就是要解决这一问题。为了解决 这些问题，Oracle决定在原生的Java API中提供高质量的日期和时间支持
JAVA 8 新日期和时间API 学习总结
葵续浅笑的博客
03-07 2327
昨天学了Java8新的时间日期api，以前我们做时间计算大多涉及Date，Calendar类，现在几乎全部有了替代的API，使用更加简单易用，通过几个例子记录一下。1.取得瞬间点System.currentTimeMillis()以前我们为了测试程序性能，会用下面的语句拿到当前时间的瞬间点，然后前后做减法，得出毫秒值，现在有了专门的Instant类替代。// 代替System.currentTime
Java8新日期API精华篇
Xin6Yang的博客
11-15 302
为什么要学习新的日期API 旧的日期API（Date/Calender）计算困难，毫秒值计算容易出现误差 旧的日期API（Date/Calender）线程不安全 SimpleDateFormat类是线程不安全的，在多线程的情况下，全局共享一个 SimpleDateFormat类中的Calender对象有可能会出现异常 旧的日期API（Date/Calender）不符合开发规范，使用了魔法数字，初始化月份需-1等操作 ​ 最终JavaSE 8中引入了java.time包，这种全新的包从根
JDK8日期类型接口
08-12
JDK8引入了新的日期时间API，它位于java.time包中。这个API提供了一组日期、时间和时间间隔的类，以及相关的操作和功能。 在java.time包中，有以下几个核心接口： 1. LocalDate：表示一个日期，不包含具体的时间和时区信息。 2. LocalTime：表示一个时间，不包含具体的日期和时区信息。 3. LocalDateTime：表示一个日期和时间，不包含时区信息。 4. ZonedDateTime：表示一个带有时区的日期和时间。 5. Instant：表示从1970年1月1日开始的时间的秒数。 除了以上的接口，还有一些用于处理时间间隔的接口，比如Duration（表示一段时间的长度）和Period（表示以年、月或日为单位的时间间隔）。 这些接口都提供了丰富的方法来进行日期和时间的操作，比如计算两个日期之间的差值、格式化日期时间、比较日期时间等等。同时，它们也支持链式调用，使得代码更加简洁和易读。 总的来说，JDK8的日期类型接口提供了更加方便和强大的方式来处理日期和时间，使得开发者能够更轻松地进行日期和时间相关操作。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值