本类是我自己写的一个时间工具类，自己觉得够用
package 你项目的包名
import java.time.DateTimeException;
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.time.temporal.TemporalAdjusters;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Pattern;
/**
* <p>处理日期，时间转换的工具类/p>
*
* @author shiwentian
* @since 30.06.2018
**/
public abstract class DateTimeUtils {
private static final Map<String, DateTimeFormatter> FORMATTER_MAP = new HashMap<>();
public static final String ISO_DATE_TIME = "yyyy-MM-dd HH:mm:ss";
public static final String ISO_LOCAL_DATE = "yyyy-MM-dd";
private DateTimeUtils() {
}
/**
* <p>获取当前时间，以字符串的形式返回
*
* @return 格式化后的时间yyyy-MM-dd HH:mm:ss
**/
public static String nowString() {
LocalDateTime ldt = LocalDateTime.now();
return ldt.format(DateTimeFormatter.ofPattern(ISO_DATE_TIME));
}
/**
* <p>获取当前时间，以字符串的形式返回
*
* @param formatter 具体的格式，例如yyyy-MM-dd HH:mm:ss
* @return 格式化后的时间
**/
public static String nowString(String formatter) {
LocalDateTime ldt = LocalDateTime.now();
return ldt.format(DateTimeFormatter.ofPattern(formatter));
}
/**
* <p>获取当前时间戳
*
* @return 1970-01-01到现在的毫秒数
**/
public static Long nowTimestamp() {
return Instant.now().toEpochMilli();
}
/**
* <p>获取当前Date
*
* @return 1970-01-01到现在的毫秒数
**/
public static Date nowDate() {
return Date.from(Instant.now());
}
/**
* <p>将{@link Date}转换成指定的字符串
*
* @param date 一个指定的日期
* @param formatter 需要格式化的字符串
* @return 格式化之后的字符串
**/
public static String dateToString(Date date, String formatter) {
DateTimeFormatter f = FORMATTER_MAP.computeIfAbsent(formatter, key -> DateTimeFormatter.ofPattern(formatter));
LocalDateTime ldt = dateToLocalDateTime(date);
return ldt.format(f);
}
/**
* <p>将{@link Date}转换成yyyy-MM-dd HH:mm:ss的格式
*
* @param date 一个指定的日期
* @return yyyy-MM-dd HH:mm:ss格式的字符串
**/
public static String dateToString(Date date) {
DateTimeFormatter f = FORMATTER_MAP.computeIfAbsent(ISO_DATE_TIME, key -> DateTimeFormatter.ofPattern(ISO_DATE_TIME));
LocalDateTime ldt = dateToLocalDateTime(date);
return ldt.format(f);
}
/**
* <p>将{@link Date}转换成时间戳
*
* @param date 日期
* @return 1970-01-01日到现在的毫秒数
**/
public static long dateToTimestamp(Date date) {
Instant instant = date.toInstant();
return instant.atZone(ZoneId.systemDefault()).toInstant().toEpochMilli();
}
/**
* <p>将String类型转换Date类型
*
* @param datetime 日期 只能转换5种格式：
* <table border=1>
* <tr>
* <td>yyyy-MM-dd HH:mm:ss.n</td>
* </tr>
* <tr>
* <td>yyyy-MM-dd HH:mm:ss</td>
* </tr>
* <tr>
* <td>yyyy-MM-dd</td>
* </tr>
* <tr>
* <td>yyyyMMddHHmmss</td>
* </tr>
* <tr>
* <td>yyyyMMdd</td>
* </tr>
* </table>
* @return date类型
**/
public static Date stringToDate(String datetime) {
if (datetime == null || "".equals(datetime)) {
throw new IllegalArgumentException("时间转换异常，参数不能为空");
}
LocalDateTime ldt = stringToLocalDateTime(datetime);
return localDateTimeToDate(ldt);
}
/**
* <p>
* 将String转换时间戳
* </p>
*
* @param datetime 日期 只能转换四种格式：
* <table border=1>
* <tr>
* <td>yyyy-MM-dd HH:mm:ss</td>
* </tr>
* <tr>
* <td>yyyy-MM-dd</td>
* </tr>
* <tr>
* <td>yyyyMMddHHmmss</td>
* </tr>
* <tr>
* <td>yyyyMMdd</td>
* </tr>
* </table>
* @return 1970-01-01日到现在的毫秒数
**/
public static long stringToTimeStamp(String datetime) {
Date date = stringToDate(datetime);
return date.toInstant().toEpochMilli();
}
/**
* <p>将String转换LocalDateTime
*
* @param datetime 日期 只能转换6种格式：
* <table border=1>
* <tr>
* <td>yyyy-MM-dd HH:mm:ss.n</td>
* </tr>
* <tr>
* <td>yyyy-MM-dd HH:mm:ss</td>
* </tr>
* <tr>
* <td>yyyy-MM-dd HH:mm</td>
* </tr>
* <tr>
* <td>yyyy-MM-dd</td>
* </tr>
* <tr>
* <td>yyyyMMddHHmmss</td>
* </tr>
* <tr>
* <td>yyyyMMdd</td>
* </tr>
* <tr>
* <td>yyyy.MM.dd</td>
* </tr>
* </table>
* @return LocalDateTime类型
**/
public static LocalDateTime stringToLocalDateTime(String datetime) {
LocalDateTime ldt = null;
try {
if (Pattern.matches("\\d{4}-\\d{2}-\\d{2}\\s\\d{2}:\\d{2}:\\d{2}.\\d+", datetime)) {
ldt = toISODateTime(datetime.substring(0, 19));
} else if (Pattern.matches("\\d{4}-\\d{2}-\\d{2}\\s\\d{2}:\\d{2}:\\d{2}", datetime)) {
ldt = toISODateTime(datetime);
} else if (Pattern.matches("\\d{4}-\\d{2}-\\d{2}\\s\\d{2}:\\d{2}", datetime)) {
ldt = toISODateTime(datetime + ":00");
} else if (Pattern.matches("\\d{4}-\\d{2}-\\d{2}", datetime)) {
ldt = toISODate(datetime);
} else if (Pattern.matches("\\d{14}", datetime)) {
ldt = toISOLocalDateTime(datetime);
} else if (Pattern.matches("\\d{8}", datetime)) {
ldt = toISOLocalDate(datetime);
} else if (Pattern.matches("\\d{4}.\\d{2}.\\d{2}", datetime)) {
ldt = toISOLocalDate(datetime.replace(".", ""));
} else {
throwErrorFormat(datetime);
}
} catch (DateTimeException ex) {
throw new IllegalArgumentException("非法的日期:" + datetime);
}
return ldt;
}
/**
* <p>将时间戳(long类型)转换成String
*
* @param timeStamp 1970-01-01日到现在的毫秒数
* @param formatter 日期的格式
* @return 格式化之后的时间
**/
public static String timeStampToString(long timeStamp, String formatter) {
Instant instant = Instant.ofEpochMilli(timeStamp);
LocalDateTime ldt = instantToLocalDateTime(instant);
return ldt.format(DateTimeFormatter.ofPattern(formatter));
}
/**
* <p>将时间戳(long类型)转换成String
*
* @param timeStamp 1970-01-01日到现在的毫秒数
* @return 字符串格式的时间，格式是yyyy-MM-DD HH:mm:ss
**/
public static String timeStampToString(long timeStamp) {
return timeStampToString(timeStamp, ISO_DATE_TIME);
}
/**
* <p>将时间戳(String类型)转换成String
*
* @return 字符串格式的时间，格式是yyyy-MM-DD HH:mm:ss
**/
public static String timeStampToString(String timeStamp) {
return timeStampToString(Long.parseLong(timeStamp), ISO_DATE_TIME);
}
/**
* <p>将时间戳(String类型)转换成Date
*
* @param timeStamp 1970-01-01日到现在的毫秒数
* @return Date类型
**/
public static Date timeStampToDate(long timeStamp) {
Instant instant = Instant.ofEpochMilli(timeStamp);
return Date.from(instant);
}
/**
* <p>将时间戳(String类型)转换成Date</p>
*
* @param timeStamp 1970-01-01日到现在的毫秒数
* @return 字符串格式的时间，格式是yyyy-MM-DD HH:mm:ss
**/
public static Date timeStampToDate(String timeStamp) {
Instant instant = Instant.ofEpochMilli(Long.parseLong(timeStamp));
return Date.from(instant);
}
/**
* <p>判断时间date是否在两个日期（date1和date2）之间</p>
*
* @param date 要判断的时间
* @param date1 时间边界1
* @param date2 时间边界2
* @return true表示date在date1和date2之间，false表示不在date1和date2之间
**/
public static boolean isBetween(String date, String date1, String date2) {
LocalDateTime ldt = stringToLocalDateTime(date);
LocalDateTime ldt1 = stringToLocalDateTime(date1);
LocalDateTime ldt2 = stringToLocalDateTime(date2);
return ldt1.isBefore(ldt) && ldt.isBefore(ldt2);
}
/**
* <p>判断时间date是否在两个日期（date1和date2）之间</p>
*
* @param date 要判断的时间
* @param date1 时间边界1
* @param date2 时间边界2
* @return true表示date在date1和date2之间，false表示不在date1和date2之间
**/
public static boolean isBetween(Date date, Date date1, Date date2) {
return date1.before(date) && date.before(date2);
}
/**
* <p>判断时间date是否在两个日期（date1和date2）之间</p>
*
* @param date 要判断的时间
* @param date1 时间边界1
* @param date2 时间边界2
* @return true表示date在date1和date2之间，false表示不在date1和date2之间
**/
public static boolean isBetween(long date, long date1, long date2) {
return date1 < date && date < date2;
}
/**
* <p>计算两个时间相隔多少天</p>
*
* <b>无关参数顺序，返回的是绝对值，一定是正数，不存在负数情况</b>
*
* @param date1 一个时间
* @param date2 另一个时间
* @return 两个时间相隔的天数
**/
public static long betweenDay(Date date1, Date date2) {
LocalDateTime ldt1 = dateToLocalDateTime(date1);
LocalDateTime ldt2 = dateToLocalDateTime(date2);
return Math.abs(ldt1.until(ldt2, ChronoUnit.DAYS));
}
/**
* <p>计算两个时间相隔多少年</p>
*
* <b>无关参数顺序，返回的是绝对值，一定是正数，不存在负数情况</b>
*
* @param date1 一个时间
* @param date2 另一个时间
* @return 两个时间相隔的年数
**/
public static long betweenYear(Date date1, Date date2) {
LocalDateTime ldt1 = dateToLocalDateTime(date1);
LocalDateTime ldt2 = dateToLocalDateTime(date2);
return Math.abs(ldt1.until(ldt2, ChronoUnit.YEARS));
}
/**
* <p>计算两个时间相隔多少小时</p>
*
* <b>无关参数顺序，返回的是绝对值，一定是正数，不存在负数情况</b>
*
* @param date1 一个时间
* @param date2 另一个时间
* @return 两个时间相隔的小时, 不足1小时返回0
**/
public static long betweenHour(Date date1, Date date2) {
LocalDateTime ldt1 = dateToLocalDateTime(date1);
LocalDateTime ldt2 = dateToLocalDateTime(date2);
return Math.abs(ldt1.until(ldt2, ChronoUnit.HOURS));
}
/**
* <p>计算两个时间相隔多少分钟</p>
*
* <b>无关参数顺序，返回的是绝对值，一定是正数，不存在负数情况</b>
*
* @return 两个时间相隔的分钟
**/
public static long betweenMinute(Date date1, Date date2) {
LocalDateTime ldt1 = dateToLocalDateTime(date1);
LocalDateTime ldt2 = dateToLocalDateTime(date2);
return Math.abs(ldt1.until(ldt2, ChronoUnit.MINUTES));
}
/**
* <p>计算两个时间相隔多少天</p>
*
* <b>无关参数顺序，返回的是绝对值，一定是正数，不存在负数情况</b>
*
* @return 两个时间相隔的天数
**/
public static long betweenDay(LocalDateTime ldt1, LocalDateTime ldt2) {
return Math.abs(ldt1.until(ldt2, ChronoUnit.DAYS));
}
/**
* <p>计算两个时间相隔多少年</p>
*
* <b>无关参数顺序，返回的是绝对值，一定是正数，不存在负数情况</b>
*
* @return 两个时间相隔的年数
**/
public static long betweenYear(LocalDateTime ldt1, LocalDateTime ldt2) {
return Math.abs(ldt1.until(ldt2, ChronoUnit.YEARS));
}
/**
* <p>计算两个时间相隔多少小时</p>
*
* <b>无关参数顺序，返回的是绝对值，一定是正数，不存在负数情况</b>
*
* @return 两个时间相隔的小时, 不足1小时返回0
**/
public static long betweenHour(LocalDateTime ldt1, LocalDateTime ldt2) {
return Math.abs(ldt1.until(ldt2, ChronoUnit.HOURS));
}
/**
* <p>计算两个时间相隔多少分钟</p>
*
* <b>无关参数顺序，返回的是绝对值，一定是正数，不存在负数情况</b>
*
* @return 两个时间相隔的分钟
**/
public static long betweenMinute(LocalDateTime ldt1, LocalDateTime ldt2) {
return Math.abs(ldt1.until(ldt2, ChronoUnit.MINUTES));
}
/**
* <p>计算两个时间相隔多少天</p>
*
* <b>无关参数顺序，返回的是绝对值，一定是正数，不存在负数情况</b>
*
* @param date1 日期 只能转换四种格式
* @param date2 日期 只能转换四种格式
* <table border=1>
* <tr>
* <td>yyyy-MM-dd HH:mm:ss</td>
* </tr>
* <tr>
* <td>yyyy-MM-dd</td>
* </tr>
* <tr>
* <td>yyyyMMddHHmmss</td>
* </tr>
* <tr>
* <td>yyyyMMdd</td>
* </tr>
* </table>
* @return 两个时间相隔的天数
**/
public static long betweenDay(String date1, String date2) {
LocalDateTime ldt1 = stringToLocalDateTime(date1);
LocalDateTime ldt2 = stringToLocalDateTime(date2);
return Math.abs(ldt1.until(ldt2, ChronoUnit.DAYS));
}
/**
* <p>计算两个时间相隔多少年</p>
*
* <b>无关参数顺序，返回的是绝对值，一定是正数，不存在负数情况</b>
*
* @param date1 日期 只能转换四种格式
* @param date2 日期 只能转换四种格式
* <table border=1>
* <tr>
* <td>yyyy-MM-dd HH:mm:ss</td>
* </tr>
* <tr>
* <td>yyyy-MM-dd</td>
* </tr>
* <tr>
* <td>yyyyMMddHHmmss</td>
* </tr>
* <tr>
* <td>yyyyMMdd</td>
* </tr>
* </table>
* @return 两个时间相隔的年数
**/
public static long betweenYear(String date1, String date2) {
LocalDateTime ldt1 = stringToLocalDateTime(date1);
LocalDateTime ldt2 = stringToLocalDateTime(date2);
return Math.abs(ldt1.until(ldt2, ChronoUnit.YEARS));
}
/**
* <p>计算两个时间相隔多少小时</p>
*
* <b>无关参数顺序，返回的是绝对值，一定是正数，不存在负数情况</b>
*
* @param date1 日期 只能转换四种格式
* @param date2 日期 只能转换四种格式
* <table border=1>
* <tr>
* <td>yyyy-MM-dd HH:mm:ss</td>
* </tr>
* <tr>
* <td>yyyy-MM-dd</td>
* </tr>
* <tr>
* <td>yyyyMMddHHmmss</td>
* </tr>
* <tr>
* <td>yyyyMMdd</td>
* </tr>
* </table>
* @return 两个时间相隔的小时
**/
public static long betweenHour(String date1, String date2) {
LocalDateTime ldt1 = stringToLocalDateTime(date1);
LocalDateTime ldt2 = stringToLocalDateTime(date2);
return Math.abs(ldt1.until(ldt2, ChronoUnit.HOURS));
}
/**
* <p>计算两个时间相隔多少分钟</p>
*
* <b>无关参数顺序，返回的是绝对值，一定是正数，不存在负数情况</b>
*
* @param date1 日期 只能转换四种格式
* @param date2 日期 只能转换四种格式
* <table border=1>
* <tr>
* <td>yyyy-MM-dd HH:mm:ss</td>
* </tr>
* <tr>
* <td>yyyy-MM-dd</td>
* </tr>
* <tr>
* <td>yyyyMMddHHmmss</td>
* </tr>
* <tr>
* <td>yyyyMMdd</td>
* </tr>
* </table>
* @return 两个时间相隔的分钟
**/
public static long betweenMinute(String date1, String date2) {
LocalDateTime ldt1 = stringToLocalDateTime(date1);
LocalDateTime ldt2 = stringToLocalDateTime(date2);
return Math.abs(ldt1.until(ldt2, ChronoUnit.MINUTES));
}
/**
* <p>计算两个时间相隔多少天</p>
* <b>无关参数顺序，返回的是绝对值，一定是正数，不存在负数情况</b>
*
* @param date1 1970.1.1到某个时间的毫秒数
* @param date2 1970.1.1到某个时间的毫秒数
* @return 两个时间相隔的天数
**/
public static long betweenDay(long date1, long date2) {
long timeStamp = Math.abs(date1 - date2);
return timeStamp / (24 * 60 * 60 * 1000);
}
/**
* <p>计算两个时间相隔多少年</p>
* <b>无关参数顺序，返回的是绝对值，一定是正数，不存在负数情况</b>
*
* @param date1 1970.1.1到某个时间的毫秒数
* @param date2 1970.1.1到某个时间的毫秒数
* @return 两个时间相隔的年数
**/
public static long betweenYear(long date1, long date2) {
long timeStamp = Math.abs(date1 - date2);
return timeStamp / (365L * 24L * 60L * 60L * 1000L);
}
/**
* <p>计算两个时间相隔多少小时</p>
* <b>无关参数顺序，返回的是绝对值，一定是正数，不存在负数情况</b>
*
* @param date1 1970.1.1到某个时间的毫秒数
* @param date2 1970.1.1到某个时间的毫秒数
* @return 两个时间相隔的小时
**/
public static long betweenHour(long date1, long date2) {
long timeStamp = Math.abs(date1 - date2);
return timeStamp / (60 * 60 * 1000);
}
/**
* <p>计算两个时间相隔多少分钟</p>
*
* @param date1 1970.1.1到某个时间的毫秒数
* @param date2 1970.1.1到某个时间的毫秒数
* @return 两个时间相隔的分钟数
**/
public static long betweenMinute(long date1, long date2) {
long timeStamp = Math.abs(date1 - date2);
return timeStamp / (60 * 1000);
}
/**
* 获取本月的最后一天，例如当前6月，本方法则返回30（6月最后一天）
*
* @return 本月的最后一天，你可以使用LocalDate.getDayOfMonth()方法获取实际日期
**/
public static LocalDate getLastDayOfThisMonth() {
LocalDate today = LocalDate.now();
return today.with(TemporalAdjusters.lastDayOfMonth());
}
/**
* 获取上个月的最后一天，例如当前6月，本方法则返回31（5月最后一天）
*
* @return 上个月的最后一天，你可以使用LocalDate.getDayOfMonth()方法获取实际日期
**/
public static LocalDate getLastDayOfPreMonth() {
LocalDate today = LocalDate.now();
LocalDate previousMonth = today.plusMonths(-1);
return previousMonth.with(TemporalAdjusters.lastDayOfMonth());
}
// ============以下是本类自用方法===============================
private static Date localDateTimeToDate(LocalDateTime ldt) {
Instant instant = ldt.atZone(ZoneId.systemDefault()).toInstant();
return Date.from(instant);
}
private static LocalDateTime instantToLocalDateTime(Instant instant) {
return LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
}
private static LocalDateTime dateToLocalDateTime(Date date) {
Instant instant = date.toInstant();
ZoneId zone = ZoneId.systemDefault();
return LocalDateTime.ofInstant(instant, zone);
}
/**
* <p>
* 将yyyy-MM-dd hh:mm:ss格式的字符串转换成LocalDateTime
* </p>
*
* @param datetime yyyy-MM-dd hh:mm:ss
* @return LocalDateTime
**/
private static LocalDateTime toISODateTime(String datetime) {
String d = datetime.split(" ")[0];
String t = datetime.split(" ")[1];
return LocalDateTime.of(toInt(d.split("-")[0]), toInt(d.split("-")[1]), toInt(d.split("-")[2]), toInt(t.split(":")[0]), toInt(t.split(":")[1]), toInt(t.split(":")[2]));
}
/**
* <p>
* 将yyyy-MM-dd格式的字符串转换成LocalDateTime
* </p>
*
* @param datetime yyyy-MM-dd
* @return LocalDateTime
**/
private static LocalDateTime toISODate(String datetime) {
String d = datetime.split(" ")[0];
return LocalDateTime.of(toInt(d.split("-")[0]), toInt(d.split("-")[1]), toInt(d.split("-")[2]), 0, 0, 0);
}
/**
* <p>
* 将yyyyMMddhhmmss格式的字符串转换成LocalDateTime
* </p>
*
* @param datetime yyyyMMddhhmmss
* @return LocalDateTime
**/
private static LocalDateTime toISOLocalDateTime(String datetime) {
return LocalDateTime.of(toInt(datetime.substring(0, 4)), toInt(datetime.substring(4, 6)), toInt(datetime.substring(6, 8)), toInt(datetime.substring(8, 10)), toInt(datetime.substring(10, 12)), toInt(datetime.substring(12, 14)));
}
/**
* <p>
* 将yyyyMMdd格式的字符串转换成LocalDateTime
* </p>
*
* @param datetime yyyyMMdd
* @return LocalDateTime
**/
private static LocalDateTime toISOLocalDate(String datetime) {
return LocalDateTime.of(toInt(datetime.substring(0, 4)), toInt(datetime.substring(4, 6)), toInt(datetime.substring(6, 8)), 0, 0, 0);
}
/**
* <p>
* 隐式的抛出异常
* </p>
**/
private static void throwErrorFormat(String datetime) {
throw new IllegalArgumentException("无法解析[" + datetime + "]这个时间格式");
}
/**
* <p>
* 将string转换成int，只是因为Integer.parseInt太长了
* </p>
**/
private static int toInt(String v) {
return Integer.parseInt(v);
}
/**
* <p>
* 比较大小，结果为正数，则前者大, 负数则后者大, 0一边大
*
* @param t1 <table border=1>
* <tr>
* <td>yyyy-MM-dd HH:mm:ss.n</td>
* </tr>
* <tr>
* <td>yyyy-MM-dd HH:mm:ss</td>
* </tr>
* <tr>
* <td>yyyy-MM-dd</td>
* </tr>
* <tr>
* <td>yyyyMMddHHmmss</td>
* </tr>
* <tr>
* <td>yyyyMMdd</td>
* </tr>
* </table>
* @param t2 <table border=1>
* <tr>
* <td>yyyy-MM-dd HH:mm:ss.n</td>
* </tr>
* <tr>
* <td>yyyy-MM-dd HH:mm:ss</td>
* </tr>
* <tr>
* <td>yyyy-MM-dd</td>
* </tr>
* <tr>
* <td>yyyyMMddHHmmss</td>
* </tr>
* <tr>
* <td>yyyyMMdd</td>
* </tr>
* </table>
* @return 正数前者大, 负数 后者大, 0一边大
*/
public static int compare(String t1, String t2) {
LocalDateTime l1 = stringToLocalDateTime(t1);
LocalDateTime l2 = stringToLocalDateTime(t2);
return l1.compareTo(l2);
}
/**
* <p>
* 比较大小，结果为正数，则前者大, 负数则后者大, 0一边大
*
* @param t1 <table border=1>
* <tr>
* <td>yyyy-MM-dd HH:mm:ss.n</td>
* </tr>
* <tr>
* <td>yyyy-MM-dd HH:mm:ss</td>
* </tr>
* <tr>
* <td>yyyy-MM-dd</td>
* </tr>
* <tr>
* <td>yyyyMMddHHmmss</td>
* </tr>
* <tr>
* <td>yyyyMMdd</td>
* </tr>
* </table>
* @param t2 <table border=1>
* <tr>
* <td>yyyy-MM-dd HH:mm:ss.n</td>
* </tr>
* <tr>
* <td>yyyy-MM-dd HH:mm:ss</td>
* </tr>
* <tr>
* <td>yyyy-MM-dd</td>
* </tr>
* <tr>
* <td>yyyyMMddHHmmss</td>
* </tr>
* <tr>
* <td>yyyyMMdd</td>
* </tr>
* </table>
* @return 正数前者大, 负数 后者大, 0一边大
*/
public static int compare(Date t1, Date t2) {
LocalDateTime l1 = dateToLocalDateTime(t1);
LocalDateTime l2 = dateToLocalDateTime(t2);
return l1.compareTo(l2);
}
}
扫一扫
4537
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
