目录
- 日期类 Date
- 世界标准时间 （GMT=UTC）
- 获取日期对象及获取时间毫秒数的两种方法：
- Date对象获取所有日期数据
- Date对象获取当前日期
- 时间补零占位方法抽取获取时间日期
- SimpleDateFormat实现日期格式化与时间字符串解析
- 日期比较与标准时间转换
- 日期比较
- 标准时间转换
- 时区转换与构造方法将时间毫秒数转为日期对象
- 时区转换
- 时间毫秒数转为日期对象
- 日期工具类封装
- 日期对象格式化字符串
- 字符串解析时间
- 日期类 LocalDate
- 获取当前日期
- 根据参数设置日期
- 使用get方法获取日期
- 使用with方法替换当前日期
- 使用minus方法将当前日期推前
- 使用plus方法将当前日期推后
- 日期比较
- Date转换LocalDate
- 日期类 LocalTime
- 获取当前时间
- 根据参数设置时间
- 使用get方法获取时间
- 使用with方法替换当前日期
- 使用minus方法将当前日期推前
- 使用plus方法将当前日期推后
- 时间比较
- Date转换LocalTime
- 日期类 LocalDateTime
- 获取日期时间
- 格式化日期时间
- 字符串解析日期时间
- 比较日期时间
- 获取带有时区的时间并格式化时间
- 获取带有时区的时间毫秒数
- LocalDateTime与Date转换
- Date转换 LocalDateTime
- LocalDateTime转换Date
- LocalDateTime工具类封装
- LocalDateTime格式化为时间 指定的时间格式化字符串
- 根据时间字符串模板将时间格式字符串解析为LocalDateTime
- LocalDateTime类型的时间转为Date类型的时间
- Date类型的时间转为LocalDateTime类型的时间
日期类 Date
世界标准时间 （GMT=UTC）
GMT：格林威治标准时间 1900-01-01 00:00:00
从19 世纪中叶起，世界上以英国皇家格林尼治天文台公布的时间为标准时间，即“格林尼治标准时间（Greenwich Mean Time）”，简称GMT
UTC : 世界协调时间 1970-01-01 00:00:00
世界标准时间（Coordinated Universal Time），又称世界统一时间、国际协调时间、协调世界时，简称UTC，由原子钟提供，非常精确。
UTC与GMT的区别
这两者几乎是同一概念。它们都是指的格林尼治标准时间，只不过UTC的称呼更为正式一点。两者的区别在于前者是一个天文上的概念，而后者是基于一个原子钟。在UTC中，每一年或两年会有一个“闰秒”，而我们一般不理 会这个“闰秒”，但是在Java中，这造成我们有时会出现60秒或61秒。
北京时间GMT与UTC存在秒差。通常所说的北京时间，表示为UTC+8，即北京时间比世界标准时间快8小时，也即时差为8小时。
获取日期对象及获取时间毫秒数的两种方法：
方式一：使用系统类System.currentTimeMillis()获取毫秒数
输出的毫秒数是从1970-01-01 00:00:00到程序运行的时候的时间毫秒数
public class DateTest {
@Test
public void test01(){
// 标准时间 UTC GMT
// 1900-01-01 00:00:00
// 1970-01-01 00:00:00
Date date = new Date();
// Thu Apr 14 20:46:15 CST 2022
System.out.println(date);
long millis = System.currentTimeMillis();
// 1649940375497 1970-01-01 00:00:00到程序运行的时候的时间毫秒数
System.out.println(millis);
}
}输出时间毫秒数
Thu Apr 14 20:46:15 CST 2022
1649940375497方式二：使用date.getTime() 返回long数据类型
输出的毫秒数是从1970-01-01 00:00:00到程序运行的时候的时间毫秒数
public class DateTest {
@Test
public void test01(){
// 标准时间 UTC GMT
// 1900-01-01 00:00:00
// 1970-01-01 00:00:00
Date date = new Date();
// Thu Apr 14 20:46:15 CST 2022
System.out.println(date);
long time = date.getTime();
// 1649940375467 1970-01-01 00:00:00到程序运行的时候的时间毫秒数
System.out.println(time);
}
}输出时间毫秒数
Thu Apr 14 20:46:15 CST 2022
1649940375467Date对象获取所有日期数据
Date对象获取当前日期
Date 对象常用API
Date date = new Date();
方法 | 描述 |
date.getYear() | 获取当前年份，从1900年开始的在输出年份时date.getYear() + 1900 |
date.getMonth() | 获取当前月份(0-11,0代表1月) 所以获取当前月份是 date.getMonth()+1 |
date.getDate() | 获取当前日(1-31) |
date.getDay() | 获取当前星期X(0-6,0代表星期天) |
date.getTime() | 获取当前时间(从1970.1.1开始的毫秒数) |
date.getHours() | 获取当前小时数(0-23) |
date.getMinutes() | 获取当前分钟数(0-59) |
date.getSeconds() | 获取当前秒数(0-59) |
date.toLocaleString() | 获取当前日期( 年 月 日 下午 : : ) |
年份是从1900年开始的在输出年份时date.getYear() + 1900
月份date.getMonth()返回的是从0到11（0是一月份）所以月份date.getMonth()+1
日期使用date.getDate();
使用date.getDay()获取星期 ，0到6表示星期日到星期六
public class DateTest {
@Test
public void test02(){
// 日期字符串
StringBuilder dateText = new StringBuilder();
// 获取日期对象
Date date = new Date();
// 年 月 日 时 分 秒 星期
int year = date.getYear() + 1900;
dateText.append(year + "年");
int month = date.getMonth() + 1;
dateText.append(month < 10 ? "0" + month + "月" : month + "月");
int dayOfMonth = date.getDate();
dateText.append(dayOfMonth < 10 ? "0" + month + "日" : dayOfMonth + "日");
int hours = date.getHours();
dateText.append(hours < 10 ? "0" + hours + "时" : " " + hours + "时");
int minutes = date.getMinutes();
dateText.append(minutes < 10 ? "0" + minutes + "分" : minutes + "分");
int seconds = date.getSeconds();
dateText.append(seconds < 10 ? "0" + seconds + "秒" : seconds + "秒");
int dayOfWeek = date.getDay();
String weekDay = " 星期";
switch (dayOfWeek){
case 1 ->weekDay += "一";
case 2 ->weekDay += "二";
case 3 ->weekDay += "三";
case 4 ->weekDay += "四";
case 5 ->weekDay += "五";
case 6 ->weekDay += "六";
default -> weekDay += "日";
}
dateText.append(weekDay);
System.out.println(dateText.toString());
}
}输出当天的日期时间
2022年04月14日 22时27分48秒 星期四时间补零占位方法抽取获取时间日期
public abstract class BaseDateUtil {
/**
* 时间补零占位
* @param time 时间
* @return 补零后的字符串
*/
public static String zeroCompensation(int time){
if (time < 10 ){
return "0" + time;
}
return String.valueOf(time);
}
}public class DateTest {
@Test
public void test002(){
// 日期字符串
StringBuilder dateText = new StringBuilder();
// 获取日期对象
Date date = new Date();
// 年 月 日 时 分 秒 星期
int year = date.getYear() + 1900;
dateText.append(year + "年");
int month = date.getMonth() + 1;
dateText.append(BaseDateUtil.zeroCompensation(month) + "月");
int dayOfMonth = date.getDate();
dateText.append(BaseDateUtil.zeroCompensation(dayOfMonth) + "日 ");
int hours = date.getHours();
dateText.append(BaseDateUtil.zeroCompensation(hours) + "时");
int minutes = date.getMinutes();
dateText.append(BaseDateUtil.zeroCompensation(minutes) + "分");
int seconds = date.getSeconds();
dateText.append(BaseDateUtil.zeroCompensation(seconds) + "秒 ");
int dayOfWeek = date.getDay();
String weekDay = " 星期";
switch (dayOfWeek){
case 1 ->weekDay += "一";
case 2 ->weekDay += "二";
case 3 ->weekDay += "三";
case 4 ->weekDay += "四";
case 5 ->weekDay += "五";
case 6 ->weekDay += "六";
default -> weekDay += "日";
}
dateText.append(weekDay);
System.out.println(dateText);
}输出
2022年04月15日 10时15分02秒 星期五SimpleDateFormat实现日期格式化与时间字符串解析
SimpleDateFormat里的构造方法中需要传一个年月日时分秒模板
时间字符串模板中字母的定义：
日期格式化字符串
public class DateTest {
@Test
public void test03() {
Date date = new Date();
System.out.println(date);
// 实例化一个时间字符串格式对象 并传入时间字符串模板
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
// 将日期对象根据之前的时间字符串模板格式化为时间字符串
String format = dateFormat.format(date);
System.out.println(format);
}
}输出
Fri Apr 15 10:28:00 CST 2022
2022-04-15 10:28:00时区设置
public class DateTest {
@Test
public void test03() {
Date date = new Date();
System.out.println(date);
// 实例化一个时间字符串格式对象 并传入时间字符串模板
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
dateFormat.setTimeZone(TimeZone.getTimeZone("Asia/Shanghai"));
// 将日期对象根据之前的时间字符串模板格式化为时间字符串
String format = dateFormat.format(date);
System.out.println(format);
}
}输出
Fri Apr 15 10:28:39 CST 2022
2022-04-15 10:28:39字符串转换为时间
注意：字符串模板必须与字符串格式一致
public class DateTest {
@Test
public void test03() {
Date date = new Date();
System.out.println(date);
// 实例化一个时间字符串格式对象 并传入时间字符串模板
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
dateFormat.setTimeZone(TimeZone.getTimeZone("Asia/Shanghai"));
// 将日期对象根据之前的时间字符串模板格式化为时间字符串
String format = dateFormat.format(date);
System.out.println(format);
String source = "1983-11-22 20:30:00";
try {
// 根据时间字符串模板将时间字符串解析为日期对象
Date parse = dateFormat.parse(source);
System.out.println(parse);
}catch (ParseException e){
throw new RuntimeException(e);
}
}
}输出
Thu Apr 14 23:15:08 CST 2022
2022-04-14 23:15:08
Tue Nov 22 20:30:00 CST 1983日期比较与标准时间转换
日期比较
时间比较方式一：
public class DateTest {
@Test
public void test04() {
// 实例化一个时间字符串格式对象 并传入时间字符串模板
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String text01 = "1983-11-22 20:30:00";
String text02 = "1988-08-11 20:30:00";
try {
Date date01 = dateFormat.parse(text01);
Date date02 = dateFormat.parse(text02);
boolean isBefore = date01.getTime() - date02.getTime() < 0 ? true : false;
boolean isAfter = date01.getTime() - date02.getTime() > 0 ? true : false;
System.out.println(isBefore);
System.out.println(isAfter);
}catch (ParseException e){
throw new RuntimeException(e);
}
}
}输出
true
false使用系统自带方法时间比较方式二：
public class DateTest {
@Test
public void test05() {
// 实例化一个时间字符串格式对象 并传入时间字符串模板
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String text01 = "1983-11-22 20:30:00";
String text02 = "1988-08-11 20:30:00";
try {
Date date01 = dateFormat.parse(text01);
Date date02 = dateFormat.parse(text02);
System.out.println(date01.before(date02));
System.out.println(date01.after(date02));
}catch (ParseException e){
throw new RuntimeException(e);
}
}
}输出
true
false标准时间转换
public class DateTest {
@Test
public void test06() {
Date date = new Date();
System.out.println(date);
String gmtString = date.toGMTString();
String localeString = date.toLocaleString();
System.out.println(gmtString);
System.out.println(localeString);
}
}输出
Fri Apr 15 10:40:37 CST 2022
15 Apr 2022 02:40:37 GMT
2022年4月15日 上午10:40:37时区转换与构造方法将时间毫秒数转为日期对象
时区转换
public class DateTest {
@Test
public void test07() {
// 输出当前系统默认时区
// 1000 一秒钟
// 1000 * 60 一分钟
// 1000 * 60 * 60 一个小时
// 1000 * 60 * 60 * 8
// sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offset=28800000,dstSavings=0,useDaylight=false,transitions=31,lastRule=null]
System.out.println(TimeZone.getDefault());
// 定义时间字符串格式化模板
SimpleDateFormat tokyoSdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
// 格式化的时候设置时区
tokyoSdf.setTimeZone(TimeZone.getTimeZone("Asia/Tokyo"));
// 获取当前时间对象
Date tokyoDate = new Date();
// 将当前时间对象使用定义好的时间字符串模板格式化
String tokyoDateText = tokyoSdf.format(tokyoDate);
System.out.println(tokyoDateText);
SimpleDateFormat NewYorkSdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
NewYorkSdf.setTimeZone(TimeZone.getTimeZone("American/New Your"));
Date NewYorkDate = new Date();
String newYorkDateText = NewYorkSdf.format(NewYorkDate);
System.out.println(newYorkDateText);
}
}输出
sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offset=28800000,dstSavings=0,useDaylight=false,transitions=31,lastRule=null]
2022-04-15 11:46:40
2022-04-15 02:46:40时间毫秒数转为日期对象
Date()传入时间
public class DateTest {
@Test
public void test08() {
long time = System.currentTimeMillis();
time -= 1000 * 60 * 60;
Date date = new Date(time);
System.out.println(date);
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
dateFormat.setTimeZone(TimeZone.getTimeZone("Asia/Shanghai"));
String format = dateFormat.format(date);
System.out.println(format);
}
}输出
Fri Apr 15 10:26:23 CST 2022
2022-04-15 10:26:23日期工具类封装
日期对象格式化字符串
public abstract class BaseDateUtil {
/**
* 默认时区
*/
private final static String timeZone = "Asia/Shanghai";
/**
* 默认时间字符串模板
*/
private final static String pattern = "yyyy-MM-dd HH:mm:ss";
/**
* 将日期对象格式化为字符串
* @param date Date对象
* @return Date对象格式化后的日期字符串
*/
public static String format(Date date){
return format(date,timeZone,pattern);
}
/**
* 将日期对象格式化为字符串
* @param date Date对象
* @param pattern 日期格式化字符串模板
* @return Date对象格式化后的日期字符串
*/
public static String format(Date date, String pattern){
return format(date,timeZone,pattern);
}
/**
* 将日期对象格式化为字符串
* @param date Date对象
* @param timeZone 时区
* @param pattern 日期格式化字符串模板
* @return Date对象格式化后的日期字符串
*/
public static String format(Date date, String timeZone, String pattern){
SimpleDateFormat dateFormat = new SimpleDateFormat(pattern);
dateFormat.setTimeZone(TimeZone.getTimeZone(timeZone));
return dateFormat.format(date);
}
/**
* 时间补零占位
* @param time 时间
* @return 补零后的字符串
*/
public static String zeroCompensation(int time){
if (time < 10 ){
return "0" + time;
}
return String.valueOf(time);
}
}测试
public class BaseDateUtilTest {
@Test
public void format(){
System.out.println(BaseDateUtil.format(new Date(),"Asia/Shanghai","yyyy-MM-dd HH:mm:ss"));
System.out.println(BaseDateUtil.format(new Date(),"yyyy-MM-dd HH:mm:ss"));
System.out.println(BaseDateUtil.format(new Date()));
}
}输出
2022-04-16 15:55:07
2022-04-16 15:55:08
2022-04-16 15:55:08字符串解析时间
public abstract class BaseDateUtil {
/**
* 默认时区
*/
private final static String timeZone = "Asia/Shanghai";
/**
* 默认时间字符串模板
*/
private final static String pattern = "yyyy-MM-dd HH:mm:ss";
/**
* 将日期字符串解析为日期对象
* @param text 日期字符串
* @param timeZone 时区
* @param pattern 日期格式化字符串模板
* @return 日期字符串解析后的日期对象
* @throws ParseException
*/
public static Date parse(String text, String timeZone, String pattern) throws ParseException {
SimpleDateFormat dateFormat = new SimpleDateFormat(pattern);
dateFormat.setTimeZone(TimeZone.getTimeZone(timeZone));
return dateFormat.parse(text);
}
/**
* 将日期字符串解析为日期对象
* @param text 日期字符串
* @param pattern 日期格式化字符串模板
* @return 日期字符串解析后的日期对象
* @throws ParseException
*/
public static Date parse(String text, String pattern) throws ParseException {
return parse(text, timeZone, pattern);
}
/**
* 将日期字符串解析为日期对象
* @param text 日期字符串
* @return 日期字符串解析后的日期对象
* @throws ParseException
*/
public static Date parse(String text) throws ParseException {
return parse(text, timeZone, pattern);
}
/**
* 时间补零占位
* @param time 时间
* @return 补零后的字符串
*/
public static String zeroCompensation(int time){
if (time < 10 ){
return "0" + time;
}
return String.valueOf(time);
}
}测试
public class BaseDateUtilTest {
@Test
public void parse() throws ParseException {
System.out.println(BaseDateUtil.parse("1983-11-22 20:30:00","Asia/Shanghai","yyyy-MM-dd HH:mm:ss"));
System.out.println(BaseDateUtil.parse("1983-11-22 20:30:00","yyyy-MM-dd HH:mm:ss"));
System.out.println(BaseDateUtil.parse("1983-11-22 20:30:00"));
}
}输出
Tue Nov 22 20:30:00 CST 1983
Tue Nov 22 20:30:00 CST 1983
Tue Nov 22 20:30:00 CST 1983日期类 LocalDate
获取当前日期
使用java.time包下的LocalDate
使用LocalDate.now()方法获取默认时区的当前时间
public class LocalDateTest {
@Test
public void test(){
// 获取当前日期
LocalDate now = LocalDate.now();
System.out.println(now);
}
}输出
2022-04-16根据参数设置日期
使用LocalDate.of()方法传入参数
public class LocalDateTest {
@Test
public void test02(){
// 获取当前日期
LocalDate localDate = LocalDate.of(1983,11,22);
System.out.println(localDate);
}
}输出
1983-11-22使用get方法获取日期
方法 | 描述 |
now.getDayOfYear() | 获取当前日期所在年的第几天 |
now.getDayOfMonth() | 获取当前日期所在月的第几天 |
now.getDayOfWeek() | 获取当前日期所在周的星期 |
now.getMonthValue() | 获取当前日期所在月份的数值 |
now.getMonth() | 获取当前日期月份的英文单词 |
now.lengthOfMonth() | 获取当前日期所在月份有多少天 |
now.lengthOfYear() | 获取当前日期所在年份有多少天 |
now.isLeapYear() | 获取当前日期所在年是否是闰年 |
public class LocalDateTest {
@Test
public void test03(){
// 获取当前日期是所在年或月的第几天
LocalDate now = LocalDate.now();
System.out.println(now.getDayOfYear());
System.out.println(now.getDayOfMonth());
System.out.println(now.getDayOfWeek());
// 获取当前日期所在月份的数值
System.out.println(now.getMonth());
System.out.println(now.getMonthValue());
// 获取当前日期所在月份有多少天
System.out.println(now.lengthOfMonth());
// 获取当前日期所在年份有多少天
System.out.println(now.lengthOfYear());
// 获取当前日期所在年是否是闰年
System.out.println(now.isLeapYear());
}
}输出
106
16
SATURDAY
APRIL
4
30
365
false使用with方法替换当前日期
with开头的方法，是将参数替换localDate中的对应属性，重新计算得到新的日期
方法 | 描述 |
now.withDayOfMonth() | 将参数中的“日”替换localDate中的“日” |
now.withDayOfYear() | 将参数中的天数替换localDate中的天数（一年中的第几天） |
now.withMonth() | 将参数中的“月”替换localDate中的“月” |
now.withYear() | 将参数中的“年”替换localDate中的“年” |
public class LocalDateTest {
@Test
public void test04(){
// with开头的方法，是将参数替换localDate中的对应属性，重新计算得到新的日期
LocalDate now = LocalDate.now();
System.out.println(now);
// 将参数中的“日”替换localDate中的“日”
System.out.println(now.withDayOfMonth(7));
// 将参数中的天数替换localDate中的天数（一年中的第几天）
System.out.println(now.withDayOfYear(45));
// 将参数中的“月”替换localDate中的“月”
System.out.println(now.withMonth(11));
// 将参数中的“年”替换localDate中的“年”
System.out.println(now.withYear(1983));
System.out.println(now.withYear(1983).withMonth(11).withDayOfMonth(22));
}
}输出
2022-04-16
2022-04-07
2022-02-14
2022-11-16
1983-04-16
1983-11-22使用minus方法将当前日期推前
方法 | 描述 |
now.minusDays() | 将当前日期减一天 |
now.minusWeeks() | 将当前日期减一周 |
now.minusMonths() | 将当前日期减一月 |
now.minusYears() | 将当前日期减一年 |
public class LocalDateTest {
@Test
public void test05(){
LocalDate now = LocalDate.now();
System.out.println(now);
// 将当前日期减一天
System.out.println(now.minusDays(1));
// 将当前日期减一周
System.out.println(now.minusWeeks(1));
// 将当前日期减一月
System.out.println(now.minusMonths(1));
// 将当前日期减一年
System.out.println(now.minusYears(1));
System.out.println(now.minusYears(1).minusMonths(1).minusDays(1));
}
}输出
2022-04-16
2022-04-15
2022-04-09
2022-03-16
2021-04-16
2021-03-15使用plus方法将当前日期推后
方法 | 描述 |
now.plusDays() | 将当前日期加一天 |
now.plusWeeks() | 将当前日期加一周 |
now.plusMonths() | 将当前日期加一月 |
now.plusYears() | 将当前日期加一年 |
public class LocalDateTest {
@Test
public void test06(){
LocalDate now = LocalDate.now();
System.out.println(now);
// 将当前日期加一天
System.out.println(now.plusDays(1));
// 将当前日期加一周
System.out.println(now.plusWeeks(1));
// 将当前日期加一月
System.out.println(now.plusMonths(1));
// 将当前日期加一年
System.out.println(now.plusYears(1));
}
}
```
输出
```java
2022-04-16
2022-04-17
2022-04-23
2022-05-16
2023-04-16日期比较
方法 | 描述 |
date01.isBefore() | 比较日期之前 |
date02.isAfter() | 比较日期之后 |
public class LocalDateTest {
@Test
public void test07(){
LocalDate date01 = LocalDate.of(1983,11,22);
LocalDate date02 = LocalDate.of(1988,8,11);
System.out.println(date01.isBefore(date02));
System.out.println(date02.isAfter(date01));
}
}输出
true
trueDate转换LocalDate
public class LocalDateTest {
@Test
public void test08(){
Date date = new Date();
System.out.println(date);
OffsetDateTime offsetDateTime = date.toInstant().atOffset(ZoneOffset.of("+8"));
LocalDate localDate = offsetDateTime.toLocalDate();
System.out.println(localDate);
}
}输出
Sun Apr 17 09:39:28 CST 2022
2022-04-17日期类 LocalTime
获取当前时间
public class LocalTimeTest {
@Test
public void test01(){
// 获取当前时间
LocalTime now = LocalTime.now();
System.out.println(now);
}
}输出
22:34:16.606020490根据参数设置时间
public class LocalTimeTest {
@Test
public void test02(){
// 根据参数设置时间，参数分别是时，分，秒
LocalTime localTime = LocalTime.of(10,11,22);
System.out.println(localTime);
}
}输出
10:11:22使用get方法获取时间
方法 | 描述 |
now.getHour() | 获取当前小时 |
now.getMinute() | 获取当前分钟 |
now.getSecond() | 获取当前秒钟 |
now.getNano() | 获取当前毫秒数 |
public class LocalTimeTest {
@Test
public void test03(){
// 获取当前时，分，秒
LocalTime now = LocalTime.now();
System.out.println(now.getHour());
System.out.println(now.getMinute());
System.out.println(now.getSecond());
System.out.println(now.getNano());
}
}输出
22
59
28
45087385使用with方法替换当前日期
with开头的方法，是将参数替换localTime中的对应属性，重新计算得到新的时间
方法 | 描述 |
now.withHour() | 将参数中的“时”替换LocalTime中的“时” |
now.withMinute() | 将参数中的“分”替换LocalTime中的“分” |
now.withSecond() | 将参数中的“秒”替换LocalTime中的“秒” |
now.withNano() | 将参数中的“毫秒”替换LocalTime中的“毫秒” |
public class LocalTimeTest {
@Test
public void test04(){
// with开头的方法，是将参数替换LocalTime中的对应属性，重新计算得到新的时间
LocalTime now = LocalTime.now();
System.out.println(now);
// 将参数中的“时”替换LocalTime中的“时”
System.out.println(now.withHour(7));
// 将参数中的“分”替换LocalTime中的“分”
System.out.println(now.withMinute(1));
// 将参数中的“秒”替换LocalTime中的“秒”
System.out.println(now.withSecond(1));
// 将参数中的“毫秒”替换LocalTime中的“毫秒”
System.out.println(now.withNano(1));
}
}输出
22:57:20.135402090
07:57:20.135402090
22:01:20.135402090
22:57:01.135402090
22:57:20.000000001使用minus方法将当前日期推前
方法 | 描述 |
now.minusHours() | 将当前时间减一小时 |
now.withMinute() | 将当前时间减掉，重新得到新的分钟 |
now.minusSeconds() | 将当前时间减一秒钟 |
now.minusNanos() | 将当前时间减一毫秒钟 |
public class LocalTimeTest {
@Test
public void test05(){
LocalTime now = LocalTime.now();
System.out.println(now);
// 将当前时间减一小时
System.out.println(now.minusHours(1));
// 将当前时间减掉，重新得到新的分钟
System.out.println(now.withMinute(1));
// 将当前时间减一秒钟
System.out.println(now.minusSeconds(1));
// 将当前时间减一毫秒钟
System.out.println(now.minusNanos(1));
}
}输出
22:40:41.641537152
21:40:41.641537152
22:01:41.641537152
22:40:40.641537152
22:40:40.641537151使用plus方法将当前日期推后
方法 | 描述 |
now.plusHours() | 将当前时间加一小时 |
now.plusMinutes() | 将当前时间加一分钟 |
now.plusSeconds() | 将当前时间加一秒钟 |
now.plusNanos() | 将当前时间加一毫秒钟 |
public class LocalTimeTest {
@Test
public void test06(){
LocalTime now = LocalTime.now();
System.out.println(now);
// 将当前时间加一小时
System.out.println(now.plusHours(1));
// 将当前时间加一分钟
System.out.println(now.plusMinutes(1));
// 将当前时间加一秒钟
System.out.println(now.plusSeconds(1));
// 将当前时间加一毫秒钟
System.out.println(now.plusNanos(1));
}
}
```
输出
```java
22:53:25.377187110
23:53:25.377187110
22:54:25.377187110
22:53:26.377187110
22:53:25.377187111时间比较
方法 | 描述 |
time01.isBefore() | 比较时间之前 |
time02.isAfter() | 比较时间之后 |
public class LocalTimeTest {
@Test
public void test07(){
LocalTime time01 = LocalTime.of(8,8,8);
LocalTime time02 = LocalTime.of(6,6,6);
System.out.println(time01.isBefore(time02));
System.out.println(time02.isAfter(time01));
}
}输出
false
falseDate转换LocalTime
public class LocalTimeTest {
@Test
public void test08(){
Date date = new Date();
System.out.println(date);
OffsetDateTime offsetDateTime = date.toInstant().atOffset(ZoneOffset.of("+8"));
LocalTime localTime = offsetDateTime.toLocalTime ();
System.out.println(localTime);
}
}输出
Sun Apr 17 09:50:53 CST 2022
09:50:53.437日期类 LocalDateTime
获取日期时间
public class LocalDateTimeTest {
@Test
public void test01(){
LocalDateTime now = LocalDateTime.now();
System.out.println(now);
}
}输出
2022-04-16T23:09:15.341262720格式化日期时间
public class LocalDateTimeTest {
@Test
public void test02(){
LocalDateTime now = LocalDateTime.now();
System.out.println(now);
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String format = formatter.format(now);
System.out.println(format);
}
}输出
2022-04-16T23:10:49.533594172
2022-04-16 23:10:49字符串解析日期时间
public class LocalDateTimeTest {
@Test
public void test03(){
// 定义时间字符串
String text = "1983-11-22 20:30:30";
// 将时间字符串根据模板解析为LocalDateTime
LocalDateTime parse = LocalDateTime.parse(text, formatter);
System.out.println(parse);
}
}输出
1983-11-22T20:30:30比较日期时间
public class LocalDateTimeTest {
@Test
public void test04(){
// 定义时间字符串
String text = "1983-11-22 20:30:30";
// 将时间字符串根据模板解析为LocalDateTime
LocalDateTime parse = LocalDateTime.parse(text, formatter);
System.out.println(parse);
// 获取当前时间
LocalDateTime now = LocalDateTime.now();
// 判断某时刻是否在某时刻之前
System.out.println(parse.isBefore(now));
System.out.println(parse.isAfter(now));
// 判断某时刻与某时刻是否是同一时刻
System.out.println(parse.isEqual(now));
}
}输出
1983-11-22T20:30:30
true
false
false获取带有时区的时间并格式化时间
public class LocalDateTimeTest {
@Test
public void test05(){
// 获取当前时间
LocalDateTime bj = LocalDateTime.now();
// 获取带有时区的时间
LocalDateTime tokyo = LocalDateTime.now(ZoneId.of("+9"));
System.out.println("北京时间 >>> " + bj);
System.out.println("日本东京时间 >>> " + tokyo);
System.out.println(bj.format(formatter));
System.out.println(formatter.format(tokyo));
}
}输出
北京时间 >>> 2022-04-17T08:46:25.072974735
日本东京时间 >>> 2022-04-17T09:46:25.073142716
2022-04-17 08:46:25
2022-04-17 09:46:25获取带有时区的时间毫秒数
public class LocalDateTimeTest {
@Test
public void test06(){
long second = LocalDateTime.now(ZoneOffset.of("+9")).toEpochSecond(ZoneOffset.of("+8"));
System.out.println(second);
long milliSecond = LocalDateTime.now(ZoneOffset.of("+9")).toInstant(ZoneOffset.of("+8")).toEpochMilli();
System.out.println(milliSecond);
System.out.println(System.currentTimeMillis());
}
}输出
1650160803
1650160803540
1650157203540LocalDateTime与Date转换
Date转换 LocalDateTime
public class LocalDateTimeTest {
@Test
public void test07(){
Date date = new Date();
System.out.println(date);
OffsetDateTime offsetDateTime = date.toInstant().atOffset(ZoneOffset.of("+8"));
LocalDateTime localDateTime = offsetDateTime.toLocalDateTime();
System.out.println(localDateTime);
}
}输出
Sun Apr 17 11:04:22 CST 2022
2022-04-17T11:04:22.528LocalDateTime转换Date
public class LocalDateTimeTest {
@Test
public void test08(){
LocalDateTime now = LocalDateTime.now();
System.out.println(now);
Instant instant = LocalDateTime.now().toInstant(ZoneOffset.of("+8"));
Date date = Date.from(instant);
System.out.println(date);
}
}输出
2022-04-17T09:37:18.997785098
Sun Apr 17 09:37:18 CST 2022LocalDateTime工具类封装
LocalDateTime格式化为时间 指定的时间格式化字符串
public class BaseLocalDateTimeUtil {
/**
* 时间格式化模板字符串
*/
private final static String formatter = "yyyy-MM-dd HH:mm:ss";
/**
* 将LocalDateTime格式化为时间 指定的时间格式化字符串
* @param dateTime 欲被格式化的时间
* @return 根据时间格式字符串模板个还是花的时间字符串
*/
public static String format(LocalDateTime dateTime){
return DateTimeFormatter.ofPattern(formatter).format(dateTime);
}
/**
* 将LocalDateTime格式化为时间 指定的时间格式化字符串
* @param dateTime 欲被格式化的时间
* @param formatter 时间字符串模板
* @return 根据时间格式字符串模板个还是花的时间字符串
*/
public static String format(LocalDateTime dateTime,String formatter){
return DateTimeFormatter.ofPattern(formatter).format(dateTime);
}
}测试
public class BaseLocalDateTimeUtilTest {
@Test
public void format(){
LocalDateTime dateTime = LocalDateTime.now();
System.out.println(BaseLocalDateTimeUtil.format(dateTime));
System.out.println(BaseLocalDateTimeUtil.format(dateTime,"yyyy年MM月dd日 HH时mm分ss秒"));
}
}输出
2022-04-17 10:41:17
2022年04月17日 10时41分17秒根据时间字符串模板将时间格式字符串解析为LocalDateTime
public class BaseLocalDateTimeUtil {
/**
* 时间格式化模板字符串
*/
private final static String formatter = "yyyy-MM-dd HH:mm:ss";
/**
* 根据时间字符串模板将时间格式字符串解析为LocalDateTime
* @param text 时间字符串
* @return
*/
public static LocalDateTime parse(String text){
return LocalDateTime.parse(text,DateTimeFormatter.ofPattern(formatter));
}
/**
* 根据时间字符串模板将时间格式字符串解析为LocalDateTime
* @param text 时间字符串
* @param formatter 时间字符串模板
* @return
*/
public static LocalDateTime parse(String text,String formatter){
return LocalDateTime.parse(text,DateTimeFormatter.ofPattern(formatter));
}
}测试
public class BaseLocalDateTimeUtilTest {
@Test
public void parse(){
String text01 = "1983-11-22 20:30:30";
String text02 = "1983年11月22日 20时30分30秒";
System.out.println(BaseLocalDateTimeUtil.parse(text01));
System.out.println(BaseLocalDateTimeUtil.parse(text02,"yyyy年MM月dd日 HH时mm分ss秒"));
}
}输出
1983-11-22T20:30:30
1983-11-22T20:30:30LocalDateTime类型的时间转为Date类型的时间
public class BaseLocalDateTimeUtil {
/**
* 时间格式化模板字符串
*/
private final static String formatter = "yyyy-MM-dd HH:mm:ss";
/**
* 默认时区为东8区
*/
private static final ZoneOffset zoneOffset = ZoneOffset.of("+8");
/**
* LocalDateTime类型的时间转为Date类型的时间
* @param dateTime LocalDateTime
* @retur Date
*/
public static Date toDate(LocalDateTime dateTime){
return Date.from(dateTime.toInstant(zoneOffset));
}
/**
* LocalDateTime类型的时间转为Date类型的时间
* @param dateTime LocalDateTime
* @param zoneOffset 时区
* @retur Date
*/
public static Date toDate(LocalDateTime dateTime, ZoneOffset zoneOffset){
return Date.from(dateTime.toInstant(zoneOffset));
}
}测试
public class BaseLocalDateTimeUtilTest {
@Test
public void toDate(){
Date date01 = BaseLocalDateTimeUtil.toDate(LocalDateTime.now());
Date date02 = BaseLocalDateTimeUtil.toDate(LocalDateTime.now(), ZoneOffset.of("+9"));
System.out.println(date01);
System.out.println(date02);
}
}输出
Sun Apr 17 11:29:09 CST 2022
Sun Apr 17 10:29:09 CST 2022Date类型的时间转为LocalDateTime类型的时间
public class BaseLocalDateTimeUtil {
/**
* 时间格式化模板字符串
*/
private final static String formatter = "yyyy-MM-dd HH:mm:ss";
/**
* 默认时区为东8区
*/
private static final ZoneOffset zoneOffset = ZoneOffset.of("+8");
/**
* Date类型的时间转为LocalDateTime类型的时间
* @param date Date
* @retur Date
*/
public static LocalDateTime toDate(Date date){
return date.toInstant().atOffset(zoneOffset).toLocalDateTime();
}
/**
* Date类型的时间转为LocalDateTime类型的时间
* @param date Date
* @param zoneOffset 时区
* @retur Date
*/
public static LocalDateTime toDate(Date date, ZoneOffset zoneOffset){
return date.toInstant().atOffset(zoneOffset).toLocalDateTime();
}
}测试
public class BaseLocalDateTimeUtilTest {
@Test
public void toDate01() {
LocalDateTime localDateTime01 = BaseLocalDateTimeUtil.toDate01(Date.from(Instant.now()));
LocalDateTime localDateTime02 = BaseLocalDateTimeUtil.toDate01(Date.from(Instant.now()),ZoneOffset.of("+9"));
System.out.println(localDateTime01);
System.out.println(localDateTime02);
}
}输出
2022-04-17T20:18:50.389
2022-04-17T21:18:50.391
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
