文章目录
- 其他工具类
- 方法解释
-
- 1、formatNowOfTimestamp,格式化当前时间为【年月日时分秒】,时间戳
- 2、formatNowOfMin,格式化当前时间为【年-月-日 小时:分钟】
- 3、formatNowOfSec,格式化当前时间为【年-月-日 小时:分钟:秒】
- 4、formatNowOfHour,格式化当前时间为【年-月-日 小时】
- 5、formatNowOfDay,格式化当前时间为【年-月-日】
- 6、dateToLocalDate,data 转 LocalDate
- 7、dateToLocalDateTime,data 转 LocalDateTime
- 8、localDateTimeToDate,localDateTime 转 Date
- 9、localDateToDate,localDate 转 Date
- 10、compare(String date1, String date2),格式化时间YYYY_MM_DD_HH_MI_SS,然后比较两个时间
- 11、diffMillis(String start, String end),计算两个时间相差的毫秒数
- 12、diffSec(String start, String end),计算两个时间相差的秒数
- 13、diffMin(String start, String end),计算两个时间相差的分钟数
- 14、diffHour(String start, String end),计算两个时间相差的小时数
- 15、diffDay(String start, String end),计算两个时间相差的天数
- 16、minusYears(String time, int years),让time时间减去指定的年数
- 17、minusMonths(String time, int months),让time时间减去指定的月数
- 18、minusDay(String time, int days),让time时间减去指定的天数
- 19、minusHours(String time, int hours),让time时间减去指定的小时数
- 20、minusMin(String time, int minutes),让time时间减去指定的分钟数
- 21、minusSeconds(String time, int seconds),让time时间减去指定的秒数
- 22、isLastDayOfMonth,判断当前时间是否为当月的最后一天
- 23、isFirstDayOfMonth,判断当前时间是否为当月的第一天
- 24、getLastDayOfMonth,获取当月的最后一天,返回:年-月-日
- 25、getFirstDayOfMonth,获取当月的第一天,返回:年-月-日
- 26、parseStrToDate(String date, String originalFormat),string转date
- 27、formatDate(Date date, String format),date转换成字符串格式
- 28、formatString(String date, String originalFormat, String newFormat),把原时间格式,转换成另一种
- 29、dayOfStart,获取一天中的开始时间
- 30、dayOfEnd,获取一天中的结束时间
- 方法代码
- 使用测试
其他工具类
【Java常用工具类】数学计算
【Java常用工具类】字符串
【Java常用工具类】easyexcel基本使用演示
【Java常用工具类】集合操作常用方法
方法解释
1、formatNowOfTimestamp,格式化当前时间为【年月日时分秒】,时间戳
20200101000000
2、formatNowOfMin,格式化当前时间为【年-月-日 小时:分钟】
2020-01-01 00:00
3、formatNowOfSec,格式化当前时间为【年-月-日 小时:分钟:秒】
2020-01-01 00:00:00
4、formatNowOfHour,格式化当前时间为【年-月-日 小时】
2020-01-01 00
5、formatNowOfDay,格式化当前时间为【年-月-日】
2020-01-01
6、dateToLocalDate,data 转 LocalDate
7、dateToLocalDateTime,data 转 LocalDateTime
8、localDateTimeToDate,localDateTime 转 Date
9、localDateToDate,localDate 转 Date
10、compare(String date1, String date2),格式化时间YYYY_MM_DD_HH_MI_SS,然后比较两个时间
11、diffMillis(String start, String end),计算两个时间相差的毫秒数
start :2000-01-01 08:00:00,end :2000-01-01 08:00:02,相差的毫秒数:2000
12、diffSec(String start, String end),计算两个时间相差的秒数
start :2000-01-01 08:00:00,end :2000-01-01 08:00:02,相差的秒数:2
13、diffMin(String start, String end),计算两个时间相差的分钟数
start :2000-01-01 08:00:00,end :2000-01-01 08:01:00,相差的分钟数:1
14、diffHour(String start, String end),计算两个时间相差的小时数
start :2000-01-01 08:00:00,end :2000-01-01 09:00:00,相差的小时数:1
15、diffDay(String start, String end),计算两个时间相差的天数
start :2000-01-01 08:00:00,end :2000-01-02 08:00:00,相差的天数:1
16、minusYears(String time, int years),让time时间减去指定的年数
time : 2001-01-01 08:00:00,years:1,结果:2000-01-01 08:00:00
17、minusMonths(String time, int months),让time时间减去指定的月数
time : 2000-01-01 08:00:00,months:1,结果:1999-12-01 08:00:00
18、minusDay(String time, int days),让time时间减去指定的天数
time : 2000-01-01 08:00:00,days:1,结果:1999-12-31 08:00:00
19、minusHours(String time, int hours),让time时间减去指定的小时数
time : 2000-01-01 08:00:00,hours:1,结果:2000-01-01 07:00:00
20、minusMin(String time, int minutes),让time时间减去指定的分钟数
time : 2000-01-01 08:00:00,minutes:1,结果:2000-01-01 07:59:00
21、minusSeconds(String time, int seconds),让time时间减去指定的秒数
time : 2000-01-01 08:00:00,minutes:1,结果:2000-01-01 07:59:59
22、isLastDayOfMonth,判断当前时间是否为当月的最后一天
23、isFirstDayOfMonth,判断当前时间是否为当月的第一天
24、getLastDayOfMonth,获取当月的最后一天,返回:年-月-日
25、getFirstDayOfMonth,获取当月的第一天,返回:年-月-日
26、parseStrToDate(String date, String originalFormat),string转date
27、formatDate(Date date, String format),date转换成字符串格式
28、formatString(String date, String originalFormat, String newFormat),把原时间格式,转换成另一种
29、dayOfStart,获取一天中的开始时间
2020-01-01 00:00:00
30、dayOfEnd,获取一天中的结束时间
2020-01-01 23:59:59
方法代码
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.temporal.TemporalAdjusters;
import java.util.Date;
import static java.time.format.DateTimeFormatter.ofPattern;
/**
* 日期工具类
*/
public class LocalDateUtils {
/**
* yyyy-MM-dd
*/
public static final String YYYY_MM_DD = "yyyy-MM-dd";
/**
* yyyy-MM-dd HH
*/
public static final String YYYY_MM_DD_HH = "yyyy-MM-dd HH";
/**
* yyyy-MM-dd HH:mm
*/
public static final String YYYY_MM_DD_HH_MI = "yyyy-MM-dd HH:mm";
/**
* yyyy-MM-dd HH:mm:ss
*/
public static final String YYYY_MM_DD_HH_MI_SS = "yyyy-MM-dd HH:mm:ss";
/**
* yyyyMMddHHmmss
*/
public static final String YYYYMMDDHHMISS = "yyyyMMddHHmmss";
public static final String YYYYMMDDHHMISSMS = "yyyyMMddHHmmssSSS";
private static final DateTimeFormatter DATE_TIME_FORMATTER_DAY = ofPattern(YYYY_MM_DD);
private static final DateTimeFormatter DATE_TIME_FORMATTER_HOUR = ofPattern(YYYY_MM_DD_HH);
private static final DateTimeFormatter DATE_TIME_FORMATTER_MIN = ofPattern(YYYY_MM_DD_HH_MI);
private static final DateTimeFormatter DATE_TIME_FORMATTER_SEC = ofPattern(YYYY_MM_DD_HH_MI_SS);
private static final DateTimeFormatter DATE_TIME_FORMATTER_TIMESTAMP_SEC = ofPattern(YYYYMMDDHHMISS);
private static final DateTimeFormatter DATE_TIME_FORMATTER_TIMESTAMP_MS = ofPattern(YYYYMMDDHHMISSMS);
/**
* data 转 LocalDate
*
* @param date date
* @return LocalDate
*/
public static LocalDate dateToLocalDate(Date date) {
return date.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
}
/**
* data 转 LocalDateTime
*
* @param date date
* @return LocalDateTime
*/
public static LocalDateTime dateToLocalDateTime(Date date) {
return date.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime();
}
/**
* localDateTime 转 Date
*
* @param localDateTime localDateTime
* @return Date
*/
public static Date localDateTimeToDate(LocalDateTime localDateTime) {
return Date.from(localDateTime.atZone(ZoneId.systemDefault()).toInstant());
}
/**
* localDate 转 Date
*
* @param localDate localDate
* @return Date
*/
public static Date localDateToDate(LocalDate localDate) {
return Date.from(localDate.atStartOfDay(ZoneId.systemDefault()).toInstant());
}
/**
* 按照指定的format格式化,LocalDateUtils本身已经定义了一些常用格式,可直接使用,也可自定义
*
* @param format 时间格式
* @return
*/
public static String formatNow(String format) {
return LocalDateTime.now().format(ofPattern(format));
}
/**
* 格式化当前时间【年月日时分秒】
*
* @return 20000101000000000
*/
public static String formatNowOfTimestampMS() {
return LocalDateTime.now().format(DATE_TIME_FORMATTER_TIMESTAMP_MS);
}
/**
* 格式化当前时间【年月日时分秒】
*
* @return 20000101000000
*/
public static String formatNowOfTimestampSec() {
return LocalDateTime.now().format(DATE_TIME_FORMATTER_TIMESTAMP_SEC);
}
/**
* 格式化当前时间【年-月-日】
*
* @return 2000-01-01
*/
public static String formatNowOfDay() {
return LocalDateTime.now().format(DATE_TIME_FORMATTER_DAY);
}
/**
* 格式化当前时间【年-月-日 小时】
*
* @return 2000-01-01 08
*/
public static String formatNowOfHour() {
return LocalDateTime.now().format(DATE_TIME_FORMATTER_HOUR);
}
/**
* 格式化当前时间【年-月-日 小时:分钟】
*
* @return 2000-01-01 08:00
*/
public static String formatNowOfMin() {
return LocalDateTime.now().format(DATE_TIME_FORMATTER_MIN);
}
/**
* 格式化当前时间【年-月-日 小时:分钟:秒】
*
* @return 2000-01-01 08:00:00
*/
public static String formatNowOfSec() {
return LocalDateTime.now().format(DATE_TIME_FORMATTER_SEC);
}
/**
* 格式化时间为yyyy-MM-dd HH:mm:ss,然后进行比较
*
* @param date1 比较时间1
* @param date2 比较时间2
* @return -1、0、1
*/
public static int compare(String date1, String date2) {
LocalDateTime d1 = LocalDateTime.parse(date1, DATE_TIME_FORMATTER_SEC);
LocalDateTime d2 = LocalDateTime.parse(date2, DATE_TIME_FORMATTER_SEC);
return d1.compareTo(d2);
}
/**
* 计算两个时间相差的毫秒数
*
* @param start 【年-月-日 小时:分钟:秒】2000-01-01 08:00:00
* @param end 【年-月-日 小时:分钟:秒】2000-01-01 08:00:02
* @return 相差的毫秒数:2000
*/
public static long diffMillis(String start, String end) {
LocalDateTime startTime = LocalDateTime.parse(start, DATE_TIME_FORMATTER_SEC);
LocalDateTime endTime = LocalDateTime.parse(end, DATE_TIME_FORMATTER_SEC);
return Duration.between(startTime, endTime).toMillis();
}
/**
* 计算两个时间相差的秒数
*
* @param start 【年-月-日 小时:分钟:秒】2000-01-01 08:00:00
* @param end 【年-月-日 小时:分钟:秒】2000-01-01 08:00:02
* @return 相差的秒数:2
*/
public static long diffSec(String start, String end) {
LocalDateTime startTime = LocalDateTime.parse(start, DATE_TIME_FORMATTER_SEC);
LocalDateTime endTime = LocalDateTime.parse(end, DATE_TIME_FORMATTER_SEC);
return Duration.between(startTime, endTime).toMillis() / 1000;
}
/**
* 计算两个时间相差的分钟数
*
* @param start 【年-月-日 小时:分钟:秒】2000-01-01 08:00:00
* @param end 【年-月-日 小时:分钟:秒】2000-01-01 08:01:00
* @return 相差的分钟数:1
*/
public static long diffMin(String start, String end) {
LocalDateTime startTime = LocalDateTime.parse(start, DATE_TIME_FORMATTER_SEC);
LocalDateTime endTime = LocalDateTime.parse(end, DATE_TIME_FORMATTER_SEC);
return Duration.between(startTime, endTime).toMinutes();
}
/**
* 计算两个时间相差的小时数
*
* @param start 【年-月-日 小时:分钟:秒】2000-01-01 08:00:00
* @param end 【年-月-日 小时:分钟:秒】2000-01-01 09:00:00
* @return 相差的小时数:1
*/
public static long diffHour(String start, String end) {
LocalDateTime startTime = LocalDateTime.parse(start, DATE_TIME_FORMATTER_SEC);
LocalDateTime endTime = LocalDateTime.parse(end, DATE_TIME_FORMATTER_SEC);
return Duration.between(startTime, endTime).toHours();
}
/**
* 计算两个时间相差的天数
*
* @param start 【年-月-日 小时:分钟:秒】2000-01-01 08:00:00
* @param end 【年-月-日 小时:分钟:秒】2000-01-03 08:00:00
* @return 相差的天数:2
*/
public static long diffDay(String start, String end) {
LocalDateTime startTime = LocalDateTime.parse(start, DATE_TIME_FORMATTER_SEC);
LocalDateTime endTime = LocalDateTime.parse(end, DATE_TIME_FORMATTER_SEC);
return Duration.between(startTime, endTime).toDays();
}
/**
* 让time时间减去指定的年数
*
* @param time 【年-月-日 小时:分钟:秒】2000-01-01 08:00:00
* @param years 减去指定的年数
* @return 减去后的时间
*/
public static String minusYears(String time, int years) {
return LocalDateTime.parse(time, DATE_TIME_FORMATTER_SEC).minusYears(years).format(DATE_TIME_FORMATTER_SEC);
}
/**
* 让time时间减去指定的月数
*
* @param time 【年-月-日 小时:分钟:秒】2000-01-01 08:00:00
* @param months 减去指定的月数
* @return 减去后的时间
*/
public static String minusMonths(String time, int months) {
return LocalDateTime.parse(time, DATE_TIME_FORMATTER_SEC).minusMonths(months).format(DATE_TIME_FORMATTER_SEC);
}
/**
* 让time时间减去指定的天数
*
* @param time 【年-月-日 小时:分钟:秒】2000-01-01 08:00:00
* @param days 要减去的天数,当传入负数时,等于加上指定的天数
* @return 减去后的时间
*/
public static String minusDay(String time, int days) {
return LocalDateTime.parse(time, DATE_TIME_FORMATTER_SEC).minusDays(days).format(DATE_TIME_FORMATTER_SEC);
}
/**
* 让time时间减去指定的小时数
*
* @param time 【年-月-日 小时:分钟:秒】2000-01-01 08:00:00
* @param hours 要减去的小时数
* @return 减去后的时间
*/
public static String minusHours(String time, int hours) {
return LocalDateTime.parse(time, DATE_TIME_FORMATTER_SEC).minusHours(hours).format(DATE_TIME_FORMATTER_SEC);
}
/**
* 让time时间减去指定的分钟数
*
* @param time 【年-月-日 小时:分钟:秒】2000-01-01 08:00:00
* @param minutes 要减去的分钟数
* @return 减去后的时间
*/
public static String minusMin(String time, int minutes) {
return LocalDateTime.parse(time, DATE_TIME_FORMATTER_SEC).minusMinutes(minutes).format(DATE_TIME_FORMATTER_SEC);
}
/**
* 让time时间减去指定的秒数
*
* @param time 【年-月-日 小时:分钟:秒】2000-01-01 08:00:00
* @param seconds 要减去的秒数
* @return 减去后的时间
*/
public static String minusSeconds(String time, int seconds) {
return LocalDateTime.parse(time, DATE_TIME_FORMATTER_SEC).minusSeconds(seconds).format(DATE_TIME_FORMATTER_SEC);
}
/**
* 判断当前时间是否为当月的最后一天
*
* @return true/false
*/
public static boolean isLastDayOfMonth() {
LocalDate today = LocalDate.now();
LocalDate lastDayOfMonth = today.with(TemporalAdjusters.lastDayOfMonth());
return Period.between(today, lastDayOfMonth).getDays() == 0;
}
/**
* 判断当前时间是否为当月的第一天
*
* @return true/false
*/
public static boolean isFirstDayOfMonth() {
LocalDate today = LocalDate.now();
LocalDate firstDayOfMonth = today.with(TemporalAdjusters.firstDayOfMonth());
return Period.between(today, firstDayOfMonth).getDays() == 0;
}
/**
* 获取当月的最后一天
*
* @return yyyy-MM-dd 字符串
*/
public static String getLastDayOfMonth() {
LocalDate today = LocalDate.now();
LocalDate lastDayOfMonth = today.with(TemporalAdjusters.lastDayOfMonth());
return lastDayOfMonth.format(DATE_TIME_FORMATTER_DAY);
}
/**
* 获取当月的第一天
*
* @return yyyy-MM-dd 字符串
*/
public static String getFirstDayOfMonth() {
LocalDate today = LocalDate.now();
LocalDate firstDayOfMonth = today.with(TemporalAdjusters.firstDayOfMonth());
return firstDayOfMonth.format(DATE_TIME_FORMATTER_DAY);
}
/**
* string转date
*
* @param date 字符串
* @param originalFormat 当前字符串的日期格式
* @return
*/
public static Date parseStrToDate(String date, String originalFormat) {
final DateTimeFormatter formatter = DateTimeFormatter.ofPattern(originalFormat);
LocalDateTime time = LocalDateTime.from(LocalDate.parse(date, formatter).atStartOfDay());
return LocalDateUtils.localDateTimeToDate(time);
}
/**
* 把date按照指定格式转成字符串
*
* @param date date
* @param format 格式
* @return
*/
public static String formatDate(Date date, String format) {
LocalDateTime localDateTime = dateToLocalDateTime(date);
return localDateTime.format(ofPattern(format));
}
/**
* 把原时间格式,转换成另一种时间格式
*
* @param date string 时间
* @param originalFormat 原格式
* @param newFormat 转换后的格式
* @return
*/
public static String formatString(String date, String originalFormat, String newFormat) {
return LocalDateUtils.formatDate(parseStrToDate(date, originalFormat), newFormat);
}
/**
* 获取一天中的开始时间
*
* @return 2020-01-01 00:00:00
*/
public static String dayOfStart() {
LocalDateTime localDateTime = LocalDateTime.of(LocalDate.now(), LocalTime.MIN);
return localDateTime.format(DATE_TIME_FORMATTER_SEC);
}
/**
* 获取一天中的结束时间
*
* @return 2020-01-01 23:59:59
*/
public static String dayOfEnd() {
LocalDateTime localDateTime = LocalDateTime.of(LocalDate.now(), LocalTime.MAX);
return localDateTime.format(DATE_TIME_FORMATTER_SEC);
}
}
使用测试
import org.junit.Test;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.Date;
public class LocalDateUtilsTest {
@Test
public void dateToLocalDate() {
Date date = new Date();
LocalDate localDate = LocalDateUtils.dateToLocalDate(date);
System.out.println(localDate.toString());
}
@Test
public void dateToLocalDateTime() {
Date date = new Date();
LocalDateTime localDateTime = LocalDateUtils.dateToLocalDateTime(date);
System.out.println(localDateTime.toString());
}
@Test
public void localDateTimeToDate() {
LocalDateTime localDateTime = LocalDateUtils.dateToLocalDateTime(new Date());
Date date = LocalDateUtils.localDateTimeToDate(localDateTime);
System.out.println(date);
}
@Test
public void localDateToDate() {
Date date = LocalDateUtils.localDateToDate(LocalDateUtils.dateToLocalDate(new Date()));
System.out.println(date);
}
@Test
public void formatNow() {
System.out.println(LocalDateUtils.formatNow(LocalDateUtils.YYYY_MM_DD_HH_MI_SS));
}
@Test
public void formatNowOfTimestampMS() {
System.out.println(LocalDateUtils.formatNowOfTimestampMS());
}
@Test
public void formatNowOfTimestampSec() {
System.out.println(LocalDateUtils.formatNowOfTimestampSec());
}
@Test
public void formatNowOfDay() {
System.out.println(LocalDateUtils.formatNowOfDay());
}
@Test
public void formatNowOfHour() {
System.out.println(LocalDateUtils.formatNowOfHour());
}
@Test
public void formatNowOfMin() {
System.out.println(LocalDateUtils.formatNowOfMin());
}
@Test
public void formatNowOfSec() {
System.out.println(LocalDateUtils.formatNowOfSec());
}
@Test
public void formatDate() {
System.out.println(LocalDateUtils.formatDate(new Date(), LocalDateUtils.YYYY_MM_DD_HH));
}
@Test
public void formatString() {
System.out.println(LocalDateUtils.formatString("2020-01-01", LocalDateUtils.YYYY_MM_DD, LocalDateUtils.YYYY_MM_DD_HH_MI_SS));
}
@Test
public void compare() {
System.out.println(LocalDateUtils.compare("2020-01-01 00:00:00", "2020-01-02 00:00:00"));
}
@Test
public void diffMillis() {
System.out.println(LocalDateUtils.diffMillis("2020-01-01 00:00:00", "2020-01-02 00:00:00"));
}
@Test
public void diffSec() {
System.out.println(LocalDateUtils.diffSec("2020-01-01 00:00:00", "2020-01-02 00:00:00"));
}
@Test
public void diffMin() {
System.out.println(LocalDateUtils.diffMin("2020-01-01 00:00:00", "2020-01-02 00:00:00"));
}
@Test
public void diffHour() {
System.out.println(LocalDateUtils.diffHour("2020-01-01 00:00:00", "2020-01-02 00:00:00"));
}
@Test
public void diffDay() {
System.out.println(LocalDateUtils.diffDay("2020-01-01 00:00:00", "2020-01-02 00:00:00"));
}
@Test
public void minusYears() {
System.out.println(LocalDateUtils.minusYears("2020-01-01 10:10:10", 1));
}
@Test
public void minusMonths() {
System.out.println(LocalDateUtils.minusMonths("2020-01-01 10:10:10", 1));
}
@Test
public void minusDay() {
System.out.println(LocalDateUtils.minusDay("2020-01-01 10:10:10", 1));
}
@Test
public void minusHours() {
System.out.println(LocalDateUtils.minusHours("2020-01-01 10:10:10", 1));
}
@Test
public void minusMin() {
System.out.println(LocalDateUtils.minusMin("2020-01-01 10:10:10", 1));
}
@Test
public void minusSeconds() {
System.out.println(LocalDateUtils.minusSeconds("2020-01-01 10:10:10", 1));
}
@Test
public void isLastDayOfMonth() {
System.out.println(LocalDateUtils.isLastDayOfMonth());
}
@Test
public void isFirstDayOfMonth() {
System.out.println(LocalDateUtils.isFirstDayOfMonth());
}
@Test
public void getLastDayOfMonth() {
System.out.println(LocalDateUtils.getLastDayOfMonth());
}
@Test
public void getFirstDayOfMonth() {
System.out.println(LocalDateUtils.getFirstDayOfMonth());
}
@Test
public void parseStrToDate() {
System.out.println(LocalDateUtils.parseStrToDate("2020-01-01", LocalDateUtils.YYYY_MM_DD));
}
@Test
public void dayOfStart() {
System.out.println(LocalDateUtils.dayOfStart());
}
@Test
public void dayOfEnd() {
System.out.println(LocalDateUtils.dayOfEnd());
}
}