java基础之时间类型

已于 2025-01-14 16:03:14 修改
阅读量1w 收藏 21
点赞数 4
分类专栏： # java 文章标签： java html servlet
于 2018-05-30 11:23:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/csdnzhang365/article/details/80506968
版权

 日期时间格式化

 SimpleDateFormat格式化
SimpleDateFormat不是线程安全的，使用的时候，只能在方法内部创建新的局部变量。
 DateTimeFormatter格式化
DateTimeFormatter不但是不变对象，它还是线程安全的。

Date

Date 类主要封装了系统的日期和时间的信息，表示系统特定的时间戳，可以精确到毫秒。Date 对象表示时间的默认顺序是星期、月、日、小时、分、秒、年。

构造方法

Date()：使用该构造方法创建的对象可以获取本地的当前时间。

Date(long date)：表示从 GMT 时间1970 年 1 月 1 日 0 时 0 分 0 秒开始经过参数 date 指定的毫秒数。

Date date1 = new Date();    // 1、调用无参数构造函数
System.out.println(date1.toString());    // 输出：Wed May 18 21:24:40 CST 2016

Date date2 = new Date(60000);    // 2、调用含有一个long类型参数的构造函数
System.out.println(date2);    // 输出：Thu Jan 0108:01:00 CST 1970

常用方法

方法描述
boolean after(Date when)判断此日期是否在指定日期之后
boolean before(Date when)判断此日期是否在指定日期之前
int compareTo(Date anotherDate)比较两个日期的顺序
boolean equals(Object obj)比较两个日期的相等性
long getTime()返回自 1970 年 1 月 1 日 00:00:00 GMT 以来，此 Date 对象表示的毫秒数
String toString()把此 Date 对象转换为以下形式的 String: dow mon dd hh:mm:ss zzz yyyy。
其中 dow 是一周中的某一天(Sun、Mon、Tue、Wed、Thu、Fri 及 Sat)

时间格式

yyyy：年  
MM：月  
dd：日  
hh：1~12小时制(1-12)  
HH：24小时制(0-23)  
mm：分  
ss：秒  
S：毫秒  
E：星期几  
D：一年中的第几天  
F：一月中的第几个星期(会把这个月总共过的天数除以7)  
w：一年中的第几个星期  
W：一月中的第几星期(会根据实际情况来算)  
a：上下午标识  
k：和HH差不多，表示一天24小时制(1-24)。  
K：和hh差不多，表示一天12小时制(0-11)。  
z：表示时区    

常见用法

String⇋Date

// String 转 Date
String str = "1957-3-23 00:00:00";  
//1、定义转换格式  
SimpleDateFormat formatter  = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
//2、将str转化为date类型  输出为：Sat Mar 23 00:00:00 GMT+08:00 1957  
Date  date = formatter.parse(str);  
//---------------------------------------------------------------------------
// Date转String
//1、定义转换格式  
SimpleDateFormat formatter  = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
//2、将当前时间转化为String类型 
String dateString = formatter.format(new Date());

获取n分钟前的时间

Date now = new Date();
//timeRange分钟前的时间
Date beforeDate = new Date(now.getTime() - 1000*60*timeRange); 
//可以方便地修改日期格式
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String nowTime_10 = dateFormat.format(beforeDate);
//---------------------------------------------------------------------------
// 获取昨天
// 1天的时间=24小时 x 60分钟 x 60秒 x 1000毫秒 单位是L。
Date yesterday = new Date(today.getTime() - 86400000L);//86400000L

获取年

SimpleDateFormat formatter = new SimpleDateFormat("yyyy");
formatter.format(new Date());

 获取时间差

SimpleDateFormat simpleFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm");
String fromDate = simpleFormat.format("2016-05-01 12:00");  
String toDate = simpleFormat.format("2016-05-01 12:50");  
long from = simpleFormat.parse(fromDate).getTime();  
long to = simpleFormat.parse(toDate).getTime();  
int minutes = (int) ((to - from)/(1000 * 60));

判断某个日期是否在日期范围内

/**
 * 判断时间在时间区间内
 * @param nowTime   当前时间	
 * @param startTime	开始时间
 * @param endTime   结束时间
 * @return 
 */
public static boolean isEffectiveDate(Date dateTime, Date startTime, Date endTime) {
	if (dateTime.getTime() == startTime.getTime()
			|| dateTime.getTime() == endTime.getTime()) {
		return true;
	}
	Calendar date = Calendar.getInstance();
	date.setTime(dateTime);
	Calendar begin = Calendar.getInstance();
	begin.setTime(startTime);
	Calendar end = Calendar.getInstance();
	end.setTime(endTime);
	if (date.after(begin) && date.before(end)) {
		return true;
	} else {
		return false;
	}
}
//---------------------------------------------------------------------------
/**
 * 判断当前时间在时间区间内	
 * @param startTime	开始时间
 * @param endTime   结束时间
 * @return 
 */
public static boolean isEffectiveDate(String startTime, String endTime) {
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");// 要转换的日期格式
    Date dateStart = sdf.parse(startTime);
    long dateStartL = dateStart.getTime();
    Date dateEnd = sdf.parse(endTime);
    long dateEndL = dateEnd.getTime();
    long nowL = new Date().getTime();
    if (dateEndL > dateStartL) {
        if (nowL >= dateStartL && nowL < dateEndL) {
            return ture;
        }
    }
}

获取两个时间段内的日期

/**
 * 获取两个日期之间的所有年
 *
 * @param startTime
 * @param endTime
 * @return：YYYY-MM
 */
public static List<String> getYearBetweenDate(String startTime, String endTime){
	SimpleDateFormat sdf = new SimpleDateFormat("yyyy");
	// 声明保存日期集合
	List<String> list = new ArrayList<String>();
	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);
			//把日期增加一天
			calendar.add(Calendar.YEAR, 1);
			// 获取增加后的日期
			startDate=calendar.getTime();
		}
	} catch (ParseException e) {
		e.printStackTrace();
	}
	return list;
}

/**
 * 获取两个日期之间的所有月份 (年月)
 *
 * @param startTime
 * @param endTime
 * @return：YYYY-MM
 */
public static List<String> getMonthBetweenDate(String startTime, String endTime){
	SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM");
	// 声明保存日期集合
	List<String> list = new ArrayList<String>();
	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);
			//把日期增加一天
			calendar.add(Calendar.MONTH, 1);
			// 获取增加后的日期
			startDate=calendar.getTime();
		}
	} catch (ParseException e) {
		e.printStackTrace();
	}
	return list;
}

/**
 *  获取两个日期之间的所有日期 (年月日)
 *
 * @param startTime
 * @param endTime
 * @return
 */
public static List<String> getBetweenDays(String startTime, String endTime){
	SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
	// 声明保存日期集合
	List<String> list = new ArrayList<String>();
	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);
			//把日期增加一天
			calendar.add(Calendar.DATE, 1);
			// 获取增加后的日期
			startDate=calendar.getTime();
		}
	} catch (ParseException e) {
		e.printStackTrace();
	}
	return list;
}

时间戳

unix时间戳是从1970年1月1日（UTC/GMT的午夜）开始所经过的秒数

格式转换

时间戳⇋日期格式

// 时间戳 转换时间
// 1、10位数的时间戳（秒）
long time1 = 1527767665;
// 注意：如果是Unix时间戳记得乘以1000
String result1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date(time1 * 1000));
Date date1 = new Date(time1*1000);   //对应的就是时间戳对应的Date

// 2、13位数的时间戳（毫秒）
double time2 = 1515730332000d;
String result2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(time2);

//---------------------------------------------------------------------------

// 时间 转换 时间戳
String dateTime = "2022-02-22 22:22:22";
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date date = simpleDateFormat.parse(dateTime );
long dateL = date.getTime();
String dateStamp = String.valueOf(dateL);

 获取时间戳

// 有三种方式获取
// 第一、第二种：会精确到毫秒，第三种：只能精确到秒，毫秒用000替代
// 注意：获取到的时间戳除以1000就可获得Unix时间戳，就可传值给后台得到。
var time1 = date.getTime();
var time2 = date.valueOf();
var time3 = Date.parse(date);

Calendar

Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。

构造方法

Calendar是一个抽象类，不能直接new一个实例，创建实例的方法如下：

// 获得实例默认是当前日期
Calendar calendar = Calendar.getInstance();

 常用方法

方法描述
void add(int field, int amount)根据日历的规则，为给定的日历字段添加或减去指定的时间量。
int get(int field)返回给定日历字段的值。
void set(int year, int month, int date)设置日历字段 YEAR、MONTH 和 DAY_OF_MONTH 的值。
void set(int year, int month, int date, int hourOfDay, int minute)设置日历字段 YEAR、MONTH、DAY_OF_MONTH、HOUR_OF_DAY 和 MINUTE 的值。
void set(int year, int month, int date, int hourOfDay, int minute, int second)设置字段 YEAR、MONTH、DAY_OF_MONTH、HOUR、MINUTE 和 SECOND 的值。

常量

Calendar.AM_PM = 9;  // 0表示在中午12点之前，1表示中午12点之后（包括12点）
Calendar.ERA = 0;  // 表示纪元，0表示BC（公元前），1表示AD（公元）
Calendar.YEAR = 1; // 表示年份
Calendar.MONTH = 2;  // 表示月份，0表示1月，1表示2月，以此类推
Calendar.WEEK_OF_YEAR = 3;  // 本年中第几个星期
Calendar.WEEK_OF_MONTH = 4;  // 本月中第几个星期
Calendar.DAY_OF_MONTH = 5;  // 一月中第几天
Calendar.DAY_OF_YEAR = 6;  // 一年中第几天
Calendar.DAY_OF_WEEK = 7;  // 一周中第几天，从周日开始，周日是1
Calendar.DAY_OF_WEEK_IN_MONTH = 8;  // 当月中第几个星期
Calendar.HOUR = 10;  // 小时，十二小时制
Calendar.HOUR_OF_DAY = 11;  // 小时，二十四小时制
Calendar.MINUTE = 12;  // 分钟
Calendar.SECOND = 13;  // 秒
Calendar.MILLISECOND = 14;  // 毫秒
Calendar.ZONE_OFFSET = 15;  // 
Calendar.DST_OFFSET = 16;  // 
 
Calendar.JANUARY = 0;  // 一月
Calendar.FEBRUARY;  // 二月
Calendar.MARCH;  // 三月
Calendar.APRIL;  // 四月
Calendar.MAY;  // 五月
Calendar.JUNE;  // 六月
Calendar.JULY;  // 七月
Calendar.AUGUST;  // 八月
Calendar.SEPTEMBER;  // 九月
Calendar.OCTOBER;  // 十月
Calendar.NOVEMBER;  // 十一月
Calendar.DECEMBER = 11;  // 十二月
 
Calendar.SUNDAY = 1;  // 星期日
Calendar.MONDAY;  // 星期一
Calendar.TUESDAY;  // 星期二
Calendar.WEDNESDAY;  // 星期三
Calendar.THURSDAY;  // 星期四
Calendar.FRIDAY;  // 星期五
Calendar.SATURDAY = 7;  // 星期六

 常见用法

//获取对应日期的年份
int year = calendar.get(Calendar.YEAR);

//获取对应日期的月份
//月份从0开始
int month = calendar.get(Calendar.MONTH)+1;

//获取对应日期
int day = calendar.get(Calendar.DATE);

//判断当前时间是上午还是下午
//0为上午，1为下午
int am_pm = calendar.get(Calendar.AM_PM);

//获取对应日期的时间 （小时）
//12小时制，即下午1点显示为1而不是13
int hours = calendar.get(Calendar.HOUR);

//获取对应日期的时间  （分钟）
int minute = calendar.get(Calendar.MINUTE);

//获取对应日期是该周的第几天
int dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK);

//获取对应日期是该月的第几天
int dayOfMonth = calendar.get(Calendar.DAY_OF_MONTH);

//获取对应日期是该年的第几天
int dayOfYear = calendar.get(Calendar.DAY_OF_YEAR);

//获取对应日期是该月的第几周
int weekOfMonth = calendar.get(Calendar.WEEK_OF_MONTH);

//获取对应日期是该年的第几周
int weekOfYear = calendar.get(Calendar.WEEK_OF_YEAR);

//获取当前月份的最大天数
calendar.getActualMaximum(Calendar.DAY_OF_MONTH);

Calendar⇋String

//1.Calendar 转化 String
Calendar calendat = Calendar.getInstance();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd")0;
String dateStr = sdf.format(calendar.getTime());

//2.String 转化Calendar
String str="2010-5-27";
SimpleDateFormat sdf= new SimpleDateFormat("yyyy-MM-dd");
Date date =sdf.parse(str);
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);

获取N天、小时之后的整点时间

/**
* 获取days天后整点的时间
*
* @param days
* @return
*/
public static Date getExpireOfDays(int days) {
	Calendar c1 = Calendar.getInstance();
	c1.set(Calendar.HOUR_OF_DAY, 0);
	c1.set(Calendar.MINUTE, 0);
	c1.set(Calendar.SECOND, 0);
	c1.set(Calendar.MILLISECOND, 0); 

	c1.add(Calendar.DATE, days); 
	return c1.getTime();
}

/**
 * 获取hours小时后整点的时间
 *
 * @param hours
 * @return
 */
public static Date getExpireOfHours(int hours) {
	Calendar c1 = Calendar.getInstance();
	c1.set(Calendar.MINUTE, 0);
	c1.set(Calendar.SECOND, 0);
	c1.set(Calendar.MILLISECOND, 0); 

	c1.add(Calendar.HOUR_OF_DAY, hours);

	return c1.getTime();
}

获取两个时间段内的所有日期

// 格式 yyyy-MM-dd
public static List<String> getBetweenDate(String begin,String end){
    SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
    List<String> betweenList = new ArrayList<String>();
    try{
        Calendar startDay = Calendar.getInstance();
        startDay.setTime(format.parse(begin));
        startDay.add(Calendar.DATE, -1);
        
        while(true){
            startDay.add(Calendar.DATE, 1);
            Date newDate = startDay.getTime();
            String newend=format.format(newDate);
            betweenList.add(newend);
            if(end.equals(newend)){
                break;
            }
        }
    }catch (Exception e) {
        e.printStackTrace();
    }
    return betweenList;
}

时间加5分钟

Calendar nowTime = Calendar.getInstance();
nowTime.add(Calendar.MINUTE, 5);
System.out.println(sdf.format(nowTime.getTime()));

两个时间相差的天数

方法1：通过Calendar类的日期比较。

只是通过日期来进行比较两个日期的相差天数的比较，没有精确到相差到一天的时间。如果是只是纯粹通过日期（年月日）来比较比较的话就是方式一。

 * date2比date1多的天数
 * @param date1    
 * @param date2
 * @return    
 */
public static int differentDays(Date date1,Date date2) {
	Calendar cal1 = Calendar.getInstance();
	cal1.setTime(date1);
	
	Calendar cal2 = Calendar.getInstance();
	cal2.setTime(date2);
    int day1= cal1.get(Calendar.DAY_OF_YEAR);
	int day2 = cal2.get(Calendar.DAY_OF_YEAR);
	
	int year1 = cal1.get(Calendar.YEAR);
	int year2 = cal2.get(Calendar.YEAR);
	if(year1 != year2) { //同一年
		int timeDistance = 0 ;
		for(int i = year1 ; i < year2 ; i ++) {
			if(i%4==0 && i%100!=0 || i%400==0) { //闰年   
				timeDistance += 366;
			} else {//不是闰年
				timeDistance += 365;
			}
		}
		return timeDistance + (day2-day1) ;
	} else { //不同年
		System.out.println("判断day2 - day1 : " + (day2-day1));
		return day2-day1;
	}
}

方法2：直接通过计算两个日期的毫秒数，他们的差除以一天的毫秒数，即可得到我们想要的两个日期相差的天数。

/**
 * 通过时间秒毫秒数判断两个时间的间隔
 * @param date1
 * @param date2
 * @return
 */
public static int differentDaysByMillisecond(Date date1,Date date2){
	int days = (int) ((date2.getTime() - date1.getTime()) / (1000*3600*24));
	return days;
}

比较日期时间大小

 // 比较 年 月 日
SimpleDateFormat sdf  =new SimpleDateFormat("yyyy-MM-dd"); //创建日期转换对象：年 月 日
String date = "2018-11-11"; //假设 设定日期是  2018-11-11		
Date today = new Date();    //今天 实际日期是  2018-11-12    Debug：Wed Nov 12 12:08:12 CST 2018
try {         
	Date dateD = sdf.parse(date); //将字符串转换为 date 类型  Debug：Sun Nov 11 00:00:00 CST 2018
	boolean flag = dateD.getTime() >= today.getTime();
	System.err.println("flag = "+flag);  // flag = false
} catch (ParseException e1) {
	// TODO Auto-generated catch block
	e1.printStackTrace();
}

LocalDate、LocalTime、LocalDateTime

LocalDate、LocalTime、LocalDateTime是java8对日期、时间提供的新接口。 这些类是不可变的，一旦实例化，值就固定了，有点类似于String类，所以这些类都是线程安全的。

获取时间最值

当前时间：LocalDate now = LocalDate.now();

当月第一天：now.with(TemporalAdjusters.firstDayOfMonth())
本月第2天：now.withDayOfMonth(2)
下月第一天：now.with(TemporalAdjusters.firstDayOfNextMonth())
当月最后一天：now.with(TemporalAdjusters.lastDayOfMonth())

明年第一天：now.with(TemporalAdjusters.firstDayOfNextYear())
本年第一天：now.with(TemporalAdjusters.firstDayOfYear())
本年最后一天：now.with(TemporalAdjusters.lastDayOfYear())

当月的第一个星期一：now.with(TemporalAdjusters.firstInMonth(DayOfWeek.MONDAY))
当月的最后一个星期一：now.with(TemporalAdjusters.lastInMonth(DayOfWeek.MONDAY))
当月第三周星期五：now.with(TemporalAdjusters.dayOfWeekInMonth(3, DayOfWeek.FRIDAY))

本周一：now.with(DayOfWeek.MONDAY)
上周二：now.minusWeeks(1).with(ChronoField.DAY_OF_WEEK, 2)
下周二：now.plusWeeks(1).with(ChronoField.DAY_OF_WEEK, 2)

上一个周一(不包括当天)：now.with(TemporalAdjusters.previous(DayOfWeek.MONDAY))
上一个周一(包括当天)：now.with(TemporalAdjusters.previousOrSame(DayOfWeek.MONDAY))
下一个周日(不包括当天)：now.with(TemporalAdjusters.next(DayOfWeek.SUNDAY))
下一个周日(包括当天)：now.with(TemporalAdjusters.nextOrSame(DayOfWeek.SUNDAY))

// 获取当前时间零点以及24点
LocalDateTime.of(LocalDateTime.now().toLocalDate(), LocalTime.MIN);
LocalDateTime.of(LocalDateTime.now().toLocalDate(), LocalTime.MAX);

// 获取今年第一天及最后一天
LocalDate.from(LocalDateTime.now().with(TemporalAdjusters.firstDayOfYear()));
LocalDate.from(LocalDateTime.now().with(TemporalAdjusters.lastDayOfYear()));
 
// 获取当前月第一天及最后一天
LocalDate.from(LocalDateTime.now().with(TemporalAdjusters.firstDayOfMonth()));
LocalDate.from(LocalDateTime.now().with(TemporalAdjusters.lastDayOfMonth()));

LocalDate是针对于年月日的

创建方法

//获取当前日期 年月日(2022-05-31)
LocalDate localDate = LocalDate.now();
//输入年月日设置时间
LocalDate localDate = LocalDate.of(year,month,day);

格式化

String localTime = LocalDate.now().format(DateTimeFormatter.ofPattern("HH:mm:ss"));

 获取年月日星期

//获取年份
int year = localDate.getYear();
int year = localDate.get(ChronoField.YEAR);

//获取月
//注意getMonth方法返回的是Month类
//可通过getValue方法获得一个long类型的值，然后可以强转为int类型进行使用
Month month = localDate.getMonth();	// MAY 对象
int month1 = localDate.get(ChronoField.MONTH_OF_YEAR);	// 5

//获取日
int day = localDate.getDayOfMonth();	// 31
int day1 = localDate.get(ChronoField.DAY_OF_MONTH);

//获取星期几
//注意getDayOfWeek方法返回的是DayOfWeek类
//可通过getValue方法获得一个long类型的值，然后可以强转为int类型进行使用
DayOfWeek dayOfWeek = localDate.getDayOfWeek();	// TUESDAY
int dayOfWeek1 = localDate.get(ChronoField.DAY_OF_WEEK);	// 2

修改时间

LocalDate localDate = LocalDate.now();
//增加一年
localDate = localDate.plusYears(1);
localDate = localDate.plus(1, ChronoUnit.YEARS);
//减少一个月
localDate = localDate.minusMonths(1);
localDate = localDate.minus(1, ChronoUnit.MONTHS);
//减少一日
localDate = localDate.minusDays(1);
localDate = localDate.minus(1, ChronoUnit.DAYS);
//通过使用with方法进行修改
//修改年为2020
localDate = localDate.withYear(2020);
//修改为2020
localDate = localDate.with(ChronoField.YEAR, 2020);

 转换

//----------------------------------------------------------

//1、String类型转换成LocalDate类型
LocalDate localDate = LocalDate.parse("2019-12-07");

//2、localDate转换成String 
LocalDate localDate = LocalDate.now();
//按照yyyyMMdd样式进行更改
String format = localDate.format(DateTimeFormatter.BASIC_ISO_DATE);
//按照yyyy-MM-dd样式进行更改
String format = localDate.format(DateTimeFormatter.ISO_DATE);
//自定义样式进行更改
DateTimeFormatter pattern = DateTimeFormatter.ofPattern("yyyy年MM月dd日");
String format = localDate.format(pattern);
//----------------------------------------------------------
// LocalDate 转 Date
LocalDate localDate = LocalDate.now();
System.out.println("local:"+localDate.getYear());
ZoneId zoneId = ZoneId.systemDefault();
Date date = Date.from(localDate.atStartOfDay().atZone(zoneId).toInstant());
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
System.out.println("date:"+calendar.get(Calendar.YEAR));

// Date 转 LocalDate
Date date = new Date();
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
LocalDate localDate = LocalDate.of(calendar.get(Calendar.YEAR),calendar.get(Calendar.MONTH),calendar.get(DAY_OF_MONTH));

LocalTime是针对于时分秒

创建方法

LocalTime timeNow = LocalTime.now();       // 14:35:51.207
LocalTime time = LocalTime.of(23, 59, 59); // 23:59:59

获取时分秒

// 15:29:18
LocalTime localTime = LocalTime.now();
//获取当前时间的小时数
localTime.getHour();
//获取当前时间的分钟数
localTime.getMinute();
//获取当前时间的秒数
localTime.getSecond();

 修改时间

// 15:29:18
LocalTime localTime = LocalTime.now();

//将参数中的"小时"替换localTime中的"小时"
localTime.withHour(1);
//将参数中的"分钟"替换localTime中的"分钟"
localTime.withMinute(1);
//将参数中的"秒"替换localTime中的"秒"
localTime.withSecond(1);

//将当前时间减一小时
localTime.minusHours(1);
//将当前时间减一分钟
localTime.minusMinutes(1);
//将当前时间减一秒
localTime.minusSeconds(10);
//将当前时间加一小时
localTime.plusHours(1);
//将当前时间加一分钟
localTime.plusMinutes(1);
//将当前时间加一秒
localTime.plusSeconds(10);
//将当前时间减一小时
localTime.minusHours(1);
//将当前时间减一分钟
localTime.minusMinutes(1);
//将当前时间减一秒
localTime.minusSeconds(10);
//将当前时间加一小时
localTime.plusHours(1);
//将当前时间加一分钟
localTime.plusMinutes(1);
//将当前时间加一秒
localTime.plusSeconds(10);

 比较时间

// 15:29:18
LocalTime localTime = LocalTime.now();

//比较该时间与other时间的大小，返回正数，那么当前对象时间较晚（数字较大）:17
localTime.compareTo(LocalTime.of(15,29, 1)));
//比较该时间是否比参数时间早（true为早）:false
localTime.isBefore(LocalTime.of(15,29, 1)));
//比较该时间是否比参数时间晚（true为晚）:true
localTime.isAfter(LocalTime.of(15,29, 1)));
//比较两个时间是否相等（true为早）:true
localTime.equals(LocalTime.now()));

转换 

//1、String类型转换为LocalTime类型
LocalTime localTime = LocalTime.parse("17:26:00");

//2、LocalTime类型转换为String类型
//按照xx:xx:xx.xx样式进行转换
LocalTime localTime = LocalTime.now();
String format3 = localTime.format(DateTimeFormatter.ISO_TIME); 
//按照自定义样式进行转换
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("hh:mm:ss");
String format4 = localTime.format(formatter);

LocalDateTime是针对于年月日时分秒

创建方法

LocalDateTime dateTimeNow = LocalDateTime.now();  
LocalDateTime dateTime = LocalDateTime.of(2020, 1, 29, 23, 59, 59); // 2020-01-29T23:59:59

//获取本地当前的日期时间(不含时区)
LocalDateTime now = LocalDateTime.now(); // 2019-10-17T15:44:03.640
//从指定的时钟获取当前日期时间：这里用了UTC(世界标准时间)
LocalDateTime nowClock = LocalDateTime.now(Clock.systemUTC()); // 2019-10-17T07:57:42.404
//从指定时区中的系统时钟获取当前日期时间
LocalDateTime nowZoneId = LocalDateTime.now(ZoneId.systemDefault()); // 2019-10-17T16:09:04.127

修改时间

LocalDateTime localDateTime = LocalDateTime.now(); 
// 在该日期时间基础上增加或减少一定时间，参数1：时间量，可以是负数，参数2:时间单位
LocalDateTime plus = localDateTime.plus(1L, ChronoUnit.HOURS); // 2019-10-17T17:54:50.941
// 在该时间基础上增加一定时间
LocalDateTime plus1 = localDateTime.plus(Period.ofDays(1)); // 2019-10-18T16:54:50.941

// LocalDateTime    plusDays(long days)：增加指定天数
// LocalDateTime	plusHours(long hours)：增加指定小时数
// LocalDateTime	plusMinutes(long minutes)：增加指定分钟数
// LocalDateTime	plusMonths(long months)：增加指定月份数
// LocalDateTime	plusNanos(long nanos)：增加指定毫秒数
// LocalDateTime	plusSeconds(long seconds):增加指定秒数
// LocalDateTime	plusWeeks(long weeks):增加指定周数
// LocalDateTime	plusYears(long years):增加指定年数

 两个时间时间差

LocalDateTime now = LocalDateTime.of(2021,12,21,0,0,0);
LocalDateTime end = LocalDateTime.of(2022,03,21,23,59,59);

//1.相差的天数
long until = now.until(end, ChronoUnit.DAYS);

//2.相差的天数
Duration duration = Duration.between(now,end);
long days = duration.toDays();

  转换 

//----------------------------------------------------------
//1、String类型转换为LocalDateTime类型
//按照12小时计算
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss");
//按照24小时计算
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
LocalDate localDate = LocalDate.parse("2019-12-07 07:43:53",formatter);

//2、LocalDateTime类型转换为String类型
LocalDateTime localDateTime = LocalDateTime.now();
DateTimeFormatter formatter2 = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss");
String format5 = localDateTime.format(formatter2);
//----------------------------------------------------------
// LocalDateTime 转 Date
LocalDateTime localDateTime = LocalDateTime.now();
System.out.println("local:"+localDateTime.getYear());
ZoneId zoneId = ZoneId.systemDefault();
Date date = Date.from(localDateTime.atZone(zoneId).toInstant());
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
System.out.println("date:"+calendar.get(Calendar.YEAR));

// Date 转 LocalDateTime 
Date date = new Date();
LocalDateTime localDateTime = LocalDateTime.ofInstant(date.toInstant(),ZoneId.systemDefault());
//----------------------------------------------------------
/**  
 * 将时间戳（毫秒）转换为LocalDateTime  
 *  
 * @param timestamp 毫秒为单位的时间戳  
 * @return 对应的LocalDateTime对象  
 */ 
public static LocalDateTime timestampToLocalDateTime(long timestamp) {  
	// 使用系统默认时区将时间戳转换为Instant  
	Instant instant = Instant.ofEpochMilli(timestamp);  
	  
	// 假设我们想要使用系统默认时区，但你也可以指定其他时区，比如ZoneId.of("UTC")  
	ZoneId zoneId = ZoneId.systemDefault();  
	  
	// 将Instant转换为LocalDateTime  
	LocalDateTime localDateTime = LocalDateTime.ofInstant(instant, zoneId);  
	  
	return localDateTime;  
}

java8 对时间操作的类还有很多，在java.time包下去看看
Instant：时间戳
Duration：持续时间，时间差
LocalDate：只包含日期，比如：2016-10-20
LocalTime：只包含时间，比如：23:12:10
LocalDateTime：包含日期和时间，比如：2016-10-20 23:14:21
Period：时间段
ZoneOffset：时区偏移量，比如：+8:00
ZonedDateTime：带时区的时间
Clock：时钟，比如获取目前美国纽约的时间

LocalDateTime.now()生成的时间 转换成yyyy-MM-dd'T'HH:mm:ss.SSSXXX 带时区的格式会报Unsupported field: OffsetSeconds异常

解决：把LocalDateTime换成ZonedDateTime

// LocalDateTime转ZonedDateTime
ZonedDateTime serverDateTime = LocalDateTime.now().atZone(serverTimeZone);

ZonedDateTime

// ZonedDateTime.now()  默认时区
// yyyy-MM-dd'T'HH:mm:ss.SSSXXX：表示2018-03-04T12:00:00.000+08:00
// yyyy-MM-dd'T'HH:mm:ss.SSSZ：表示2015-12-06T11:18:57.000+0800
DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss.SSSXXX");  
System.out.println("本地默认时区："+dtf.format(ZonedDateTime.now()));
 
// 默认时区：ZoneId.systemDefault()
// 获取所有可使用时区：ZoneId.getAvailableZoneIds()
// 获取指定时区：ZoneId.of("")
System.out.println("世界标准时间UTC："+dtf.format(ZonedDateTime.now(ZoneId.of("UTC"))));
System.out.println("世界标准时间GMT："+dtf.format(ZonedDateTime.now(ZoneId.of("GMT"))));
System.out.println("世界标准时间UT："+dtf.format(ZonedDateTime.now(ZoneId.of("UT"))));

// 指定时区
ZoneId serverTimeZone = ZoneId.of("Asia/Seoul");
ZonedDateTime clientDateTime = serverDateTime.withZoneSameInstant(clientTimeZone);

LocalDateTime、LocalDate、Date的相互转换

LocalDateTime 转 LocalDate

LocalDateTime localDateTime = LocalDateTime.now();
LocalDate localDate = localDateTime.toLocalDate();

LocalDate 转 LocalDateTime

LocalDate localDate = LocalDate.now();
LocalDateTime localDateTime1 = localDate.atStartOfDay();
LocalDateTime localDateTime2 = localDate.atTime(8,20,33);
LocalDateTime localDateTime3 = localDate.atTime(LocalTime.now());

LocalDateTime、LocalDate 转 Date

LocalDateTime localDateTime = LocalDateTime.now();
LocalDate localDate = LocalDate.now();
//获取系统默认时区
ZoneId zoneId = ZoneId.systemDefault();
//时区的日期和时间
ZonedDateTime zonedDateTime = localDateTime.atZone(zoneId);
ZonedDateTime zonedDateTime1 = localDate.atStartOfDay().atZone(zoneId);
//获取时刻
Date date = Date.from(zonedDateTime.toInstant());
Date date = Date.from(zonedDateTime1.toInstant());

Date 转 LocalDateTime、LocalDate

Date date = new Date();
ZoneId zoneId = ZoneId.systemDefault();
LocalDateTime localDateTime = date.toInstant().atZone(zoneId).toLocalDateTime();
LocalDate localDate = date.toInstant().atZone(zoneId).toLocalDate();

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值