文章目录
日期格式转化及计算，比较使我们最常用的功能，现就工具类用法归结如下
测试pom
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>${spring.boot.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-dependencies</artifactId>
<version>${spring.cloud.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-alibaba-dependencies</artifactId>
<version>${spring.cloud.alibaba.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
<dependencies>
<!-- 引入 SpringMVC 相关依赖，并实现对其的自动配置 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-all</artifactId>
<version>5.7.22</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.junit.jupiter/junit-jupiter-api -->
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-api</artifactId>
<version>5.8.2</version>
<scope>test</scope>
</dependency>
<!-- 引入 Spring Cloud Alibaba Stream RocketMQ 相关依赖，将 RocketMQ 作为消息队列，并实现对其的自动配置 -->
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-stream-rocketmq</artifactId>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.12</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
</dependencies>
DateUtil.parse 方法
DateUtil.parse 方法会自动识别一些常用格式，包括：
yyyy-MM-dd HH:mm:ss
yyyy/MM/dd HH:mm:ss
yyyy.MM.dd HH:mm:ss
yyyy年MM月dd日 HH时mm分ss秒
yyyy-MM-dd yyyy/MM/dd
yyyy.MM.dd HH:mm:ss
HH时mm分ss秒
yyyy-MM-dd HH:mm
yyyy-MM-dd HH:mm:ss.SSS
yyyyMMddHHmmss
yyyyMMddHHmmssSSS
yyyyMMdd
EEE, dd MMM yyyy HH:mm:ss z
EEE MMM dd HH:mm:ss zzz yyyy
yyyy-MM-dd’T’HH:mm:ss’Z’
yyyy-MM-dd’T’HH:mm:ss.SSS’Z’
yyyy-MM-dd’T’HH:mm:ssZ
yyyy-MM-dd’T’HH:mm:ss.SSSZ
// 测试字符串与LocalDateTime的互相转换
String strDate = "2022-12-01 17:02:30";
LocalDateTime ldt = DateUtil.parseLocalDateTime(strDate);
String strDate1 = DateUtil.formatLocalDateTime(ldt);
System.out.println(ldt);
System.out.println(strDate1);
String strDate2 = "2022-12-01 17:02:30.111";
ldt = DateUtil.parseLocalDateTime(strDate2, DatePattern.NORM_DATETIME_MS_PATTERN);
strDate2 = DateUtil.format(ldt, DatePattern.NORM_DATETIME_PATTERN);
System.out.println(ldt);
----------------------------1
2022-05-06 00:00:00
----------------------------1
2022-12-01T17:02:30
2022-12-01 17:02:30
2022-12-01T17:02:30.111
2022-12-01 17:02:30
package com.liu.test.stream.rocketmq.consumer.Utils;
import cn.hutool.core.date.DatePattern;
import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUtil;
import lombok.extern.slf4j.Slf4j;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Calendar;
import java.util.Date;
import java.util.Locale;
import java.util.TimeZone;
import org.junit.Assert;
import org.junit.Test;
/**
* @author liu
* @date 2022年05月06日 10:57
*/
@Slf4j
public class DataUtileTest {
public void test(){
//当前时间
Date date = DateUtil.date();
//当前时间
Date date2 = DateUtil.date(Calendar.getInstance());
//当前时间
Date date3 = DateUtil.date(System.currentTimeMillis());
//当前时间字符串，格式：yyyy-MM-dd HH:mm:ss
String now = DateUtil.now();
//当前日期字符串，格式：yyyy-MM-dd
String today= DateUtil.today();
}
@Test
public void test1() {
// int i = DateUtil.ageOfNow("20110101");
// DateUtil.ageOfNow()
String dateStr = "2022-05-06";
Date date = DateUtil.parse(dateStr);
System.out.println("----------------------------1");
System.out.println(date);
System.out.println("----------------------------1");
// 测试字符串与LocalDateTime的互相转换
String strDate = "2022-12-01 17:02:30";
LocalDateTime ldt = DateUtil.parseLocalDateTime(strDate);
String strDate1 = DateUtil.formatLocalDateTime(ldt);
System.out.println(ldt);
System.out.println(strDate1);
String strDate2 = "2022-12-01 17:02:30.111";
ldt = DateUtil.parseLocalDateTime(strDate2, DatePattern.NORM_DATETIME_MS_PATTERN);
strDate2 = DateUtil.format(ldt, DatePattern.NORM_DATETIME_PATTERN);
System.out.println(ldt);
System.out.println(strDate2);
String str = "31-Aug-2020";
DateTimeFormatter dtf = DateTimeFormatter.ofPattern("dd-MMM-yyyy", Locale.US);
LocalDateTime localDateTime = LocalDate.parse(str, dtf).atStartOfDay();
Date date1 = DateUtil.date(localDateTime);
System.out.println(date1);
Assert.assertNotNull(date1);
String ymd1 = DateUtil.parse("2019-3-21 12:20:15", "yyyy-MM-dd").toString(DatePattern.PURE_DATE_PATTERN);
Assert.assertEquals("20190321", ymd1);
String ymd = DateUtil.parse("2021-05-16 21:20:15", "yyyy-MM-dd",Locale.US).toString(DatePattern.PURE_DATE_PATTERN);
Assert.assertEquals("20210516", ymd);
String ymd2 = DateUtil.parse("2021-05-16 21:20:15", "yyyy/MM/dd HH:mm:ss","yyyy.MM.dd HH:mm:ss","yyyy-MM-dd HH:mm:ss").toString(DatePattern.PURE_DATE_PATTERN);
Assert.assertEquals("20210516", ymd2);
DateTime dateTime =DateUtil.parseDateTime("2021-05-16 21:20:15");
Assert.assertEquals("2021-05-16 21:20:15", dateTime.toString("yyyy-MM-dd HH:mm:ss"));
String beginStr = "2020-03-11";
DateTime date4 = DateUtil.parseDate(beginStr);
Calendar calendar = date4.toCalendar();
final Calendar begin = DateUtil.beginOfWeek(calendar, false);
Assert.assertEquals("2020-03-08 00:00:00", DateUtil.date(begin).toString());
String beginStr5 = "22:10:00";
DateTime date5 = DateUtil.parseTimeToday(beginStr5);
System.out.println("date5:::::"+date5);
String str5 = "2022-05-06 22:10:00";
Date today1 = DateUtil.parse(str5);
System.out.println("today1:::::"+today1);
Assert.assertEquals(DateUtil.format(today1,"yyyy-MM-dd HH:mm:ss"), date5.toString());
testParseUTC();
}
public static void testParseUTC(){
String dateStr1 = "2018-09-13T05:34:31Z";
DateTime dt = DateUtil.parseUTC(dateStr1);
// parse方法支持UTC格式测试
DateTime dt2 = DateUtil.parse(dateStr1);
Assert.assertEquals(dt, dt2);
// 默认使用Pattern对应的时区，即UTC时区
String dateStr = dt.toString();
Assert.assertEquals("2018-09-13 05:34:31", dateStr);
// 使用当前（上海）时区
dateStr = dt.toString(TimeZone.getTimeZone("GMT+8:00"));
Assert.assertEquals("2018-09-13 13:34:31", dateStr);
dateStr1 = "2018-09-13T13:34:32+0800";
dt = DateUtil.parseUTC(dateStr1);
dateStr = dt.toString(TimeZone.getTimeZone("GMT+8:00"));
Assert.assertEquals("2018-09-13 13:34:32", dateStr);
dateStr1 = "2018-09-13T13:34:33+08:00";
dt = DateUtil.parseUTC(dateStr1);
dateStr = dt.toString(TimeZone.getTimeZone("GMT+8:00"));
Assert.assertEquals("2018-09-13 13:34:33", dateStr);
dateStr1 = "2018-09-13T13:34:34+0800";
dt = DateUtil.parse(dateStr1);
assert dt != null;
dateStr = dt.toString(TimeZone.getTimeZone("GMT+8:00"));
Assert.assertEquals("2018-09-13 13:34:34", dateStr);
dateStr1 = "2018-09-13T13:34:35+08:00";
dt = DateUtil.parse(dateStr1);
assert dt != null;
dateStr = dt.toString(TimeZone.getTimeZone("GMT+8:00"));
Assert.assertEquals("2018-09-13 13:34:35", dateStr);
dateStr1 = "2018-09-13T13:34:36.999+0800";
dt = DateUtil.parseUTC(dateStr1);
final SimpleDateFormat simpleDateFormat = new SimpleDateFormat(DatePattern.NORM_DATETIME_MS_PATTERN);
simpleDateFormat.setTimeZone(TimeZone.getTimeZone("GMT+8:00"));
dateStr = dt.toString(simpleDateFormat);
Assert.assertEquals("2018-09-13 13:34:36.999", dateStr);
dateStr1 = "2018-09-13T13:34:37.999+08:00";
dt = DateUtil.parseUTC(dateStr1);
dateStr = dt.toString(simpleDateFormat);
Assert.assertEquals("2018-09-13 13:34:37.999", dateStr);
dateStr1 = "2018-09-13T13:34:38.999+0800";
dt = DateUtil.parse(dateStr1);
assert dt != null;
dateStr = dt.toString(simpleDateFormat);
Assert.assertEquals("2018-09-13 13:34:38.999", dateStr);
dateStr1 = "2018-09-13T13:34:39.999+08:00";
dt = DateUtil.parse(dateStr1);
assert dt != null;
dateStr = dt.toString(simpleDateFormat);
Assert.assertEquals("2018-09-13 13:34:39.999", dateStr);
// 使用UTC时区
dateStr1 = "2018-09-13T13:34:39.99";
dt = DateUtil.parse(dateStr1);
assert dt != null;
dateStr = dt.toString();
Assert.assertEquals("2018-09-13 13:34:39", dateStr);
}
}
Connected to the target VM, address: ‘127.0.0.1:52523’, transport: ‘socket’
----------------------------1
2022-05-06 00:00:00
----------------------------1
2022-12-01T17:02:30
2022-12-01 17:02:30
2022-12-01T17:02:30.111
2022-12-01 17:02:30
2020-08-31 00:00:00
date5:::::2022-05-06 22:10:00
today1:::::2022-05-06 22:10:00
Disconnected from the target VM, address: ‘127.0.0.1:52523’, transport: ‘socket’
Process finished with exit code 0
@Test
@SneakyThrows
public void testFormat (){
String strDate = "2019-12-01 17:02:30";
LocalDateTime ldt = DateUtil.parseLocalDateTime(strDate);
String strDate1 = DateUtil.formatLocalDateTime(ldt);
Assert.assertEquals(strDate, strDate1);
String strDate2 = "2019-12-01 17:02:30.111";
ldt = DateUtil.parseLocalDateTime(strDate2, DatePattern.NORM_DATETIME_MS_PATTERN);
strDate1 = DateUtil.format(ldt, DatePattern.NORM_DATETIME_PATTERN);
Assert.assertEquals(strDate, strDate1);
String strDate3 = "2021-05-16";
SimpleDateFormat sdf3 = new SimpleDateFormat("yyyy-MM-dd");
Date localDate = sdf3.parse(strDate3);
Assert.assertEquals(strDate3, DateUtil.format(localDate, DatePattern.NORM_DATE_PATTERN));
//根据特定格式格式化日期
/*String str = "2021-05-16";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd", Locale.US);
Date date = DateUtil.parse(str);
String dateStr = DateUtil.format(date,sdf);
System.out.println(dateStr);
Assert.assertEquals(str, dateStr);*/
//根据特定格式格式化日期
/*String str = "2021-05-16";
DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd", Locale.US);
Date date = DateUtil.parse(str);
String dateStr = DateUtil.format(date,dtf);
System.out.println(dateStr);
Assert.assertEquals(str, dateStr);*/
/*String dateStr = "2017-03-01";
Date date = DateUtil.parse(dateStr);
String format = DateUtil.format(date, "yyyy/MM/dd");
Assert.assertEquals("2017/03/01", format);
// 常用格式的格式化
String formatDate = DateUtil.formatDate(date);
Assert.assertEquals("2017-03-01", formatDate);
String formatDateTime = DateUtil.formatDateTime(date);
Assert.assertEquals("2017-03-01 00:00:00", formatDateTime);
String formatTime = DateUtil.formatTime(date);
Assert.assertEquals("00:00:00", formatTime);*/
String dateStr = "2017-03-01";
Date date = DateUtil.parse(dateStr);
String format = DateUtil.format(date, "yyyy/MM/dd");
Assert.assertEquals("2017/03/01", format);
// 常用格式的格式化
String formatDate = DateUtil.formatDate(date);
Assert.assertEquals("2017-03-01", formatDate);
String formatDateTime = DateUtil.formatDateTime(date);
Assert.assertEquals("2017-03-01 00:00:00", formatDateTime);
String formatTime = DateUtil.formatTime(date);
Assert.assertEquals("00:00:00", formatTime);
String formatChineseDate = DateUtil.formatChineseDate(DateUtil.parse("2018-02-24"), true, false);
Assert.assertEquals("二〇一八年二月二十四日", formatChineseDate);
}
String dateStr2 = "2021-05-16 22:50:34.111";
DateTime date2 = DateUtil.parse(dateStr2,"yyyy-MM-dd HH:mm:ss.SSS");
int millisecond = DateUtil.millisecond(date2);
DateTime dateTime = DateUtil.endOfSecond(date2);
DateTime dateTime1 = DateUtil.endOfMinute(date2);
System.out.println(dateTime1);
Assert.assertEquals(999, DateUtil.millisecond(dateTime));
@Test
public void testOffset(){
//方法名称:cn.hutool.core.date.DateUtil.truncate(java.util.Date, cn.hutool.core.date.DateField)
/*String dateStr2 = "2020-02-29 12:59:34";
Date date2 = DateUtil.parse(dateStr2);
final DateTime dateTime = DateUtil.truncate(date2, DateField.HOUR);
Assert.assertEquals("2020-02-29 12:00:00", dateTime.toString());*/
//方法名称:cn.hutool.core.date.DateUtil.round(java.util.Date, cn.hutool.core.date.DateField)
/*String dateStr2 = "2020-02-29 12:59:34";
Date date2 = DateUtil.parse(dateStr2);
DateTime dateTime = DateUtil.round(date2, DateField.MINUTE);
Assert.assertEquals("2020-02-29 12:59:59", dateTime.toString());
dateStr2 = "2020-02-29 12:05:29";
date2 = DateUtil.parse(dateStr2);
dateTime = DateUtil.round(date2, DateField.MINUTE);
Assert.assertEquals("2020-02-29 12:05:00", dateTime.toString());*/
String dateStr2 = "2020-02-29 12:59:34";
Date date2 = DateUtil.parse(dateStr2);
DateTime dateTime = DateUtil.ceiling(date2, DateField.MINUTE);
Assert.assertEquals("2020-02-29 12:59:59", dateTime.toString());
}
String dateStr2 = "2021-05-16 22:50:34.111";
Date date2 = DateUtil.parse(dateStr2);
DateTime dateTime = DateUtil.beginOfSecond(date2);
Assert.assertEquals("2021-05-16 22:50:34", dateTime.toString());
DateTime dateTime1 = DateUtil.beginOfMinute(dateTime);
System.out.println(dateTime1);
Assert.assertEquals("2021-05-16 22:50:00", dateTime1.toString());
DateTime dateTime2 = DateUtil.beginOfDay(dateTime);
System.out.println(dateTime2);
Assert.assertEquals("2021-05-16 00:00:00", dateTime2.toString());
//昨天
DateTime dateTime = DateUtil.yesterday();
System.out.println(dateTime);
Assert.assertNotNull(dateTime);
//明天
DateTime dateTime = DateUtil.tomorrow();
System.out.println(dateTime);
Assert.assertNotNull(dateTime);
//上周
DateTime dateTime = DateUtil.lastWeek();
System.out.println(dateTime);
Assert.assertNotNull(dateTime);
//下周
DateTime dateTime = DateUtil.nextWeek();
System.out.println(dateTime);
Assert.assertNotNull(dateTime);
//上个月
DateTime dateTime = DateUtil.lastMonth();
System.out.println(dateTime);
Assert.assertNotNull(dateTime);
//偏移月
String dateStr2 = "2021-05-16 22:50:34";
DateTime date2 = DateUtil.parse(dateStr2);
DateTime dateTime = DateUtil.offsetMonth(date2,1);
Assert.assertEquals("2021-06-16 22:50:34", dateTime.toString());
dateTime = DateUtil.offsetMonth(date2,-1);
Assert.assertEquals("2021-04-16 22:50:34", dateTime.toString());
获取指定日期偏移指定时间后的时间，生成的偏移日期不影响原日期
String dateStr = "2017-03-01 22:33:23";
Date date = DateUtil.parse(dateStr);
Date newDate = DateUtil.offset(date, DateField.DAY_OF_MONTH, 2);
Assert.assertEquals("2017-03-03 22:33:23", newDate.toString());
between 判断两个日期相差的时长，只保留绝对值
String dateStr1 = "2017-03-01 22:34:23";
Date date1 = DateUtil.parse(dateStr1);
String dateStr2 = "2017-04-01 23:56:14";
Date date2 = DateUtil.parse(dateStr2);
// 相差月
long betweenMonth = DateUtil.betweenMonth(date1, date2, false);
Assert.assertEquals(1, betweenMonth);// 相差一个月
// 反向
betweenMonth = DateUtil.betweenMonth(date2, date1, false);
Assert.assertEquals(1, betweenMonth);// 相差一个月
// 相差天
long betweenDay = DateUtil.between(date1, date2, DateUnit.DAY);
Assert.assertEquals(31, betweenDay);// 相差一个月，31天
// 反向
betweenDay = DateUtil.between(date2, date1, DateUnit.DAY);
Assert.assertEquals(31, betweenDay);// 相差一个月，31天
// 相差小时
long betweenHour = DateUtil.between(date1, date2, DateUnit.HOUR);
Assert.assertEquals(745, betweenHour);
// 反向
betweenHour = DateUtil.between(date2, date1, DateUnit.HOUR);
Assert.assertEquals(745, betweenHour);
// 相差分
long betweenMinute = DateUtil.between(date1, date2, DateUnit.MINUTE);
Assert.assertEquals(44721, betweenMinute);
// 反向
betweenMinute = DateUtil.between(date2, date1, DateUnit.MINUTE);
Assert.assertEquals(44721, betweenMinute);
// 相差秒
long betweenSecond = DateUtil.between(date1, date2, DateUnit.SECOND);
Assert.assertEquals(2683311, betweenSecond);
// 反向
betweenSecond = DateUtil.between(date2, date1, DateUnit.SECOND);
Assert.assertEquals(2683311, betweenSecond);
// 相差秒
long betweenMS = DateUtil.between(date1, date2, DateUnit.MS);
Assert.assertEquals(2683311000L, betweenMS);
// 反向
betweenMS = DateUtil.between(date2, date1, DateUnit.MS);
Assert.assertEquals(2683311000L, betweenMS);
long between = DateUtil.between(DateUtil.parse("2019-05-06 02:15:00"), DateUtil.parse("2019-05-06 02:20:00"), DateUnit.HOUR);
Assert.assertEquals(0, between);
cn.hutool.core.date.DateUtil.betweenYear(java.util.Date, java.util.Date, boolean)
方法描述
计算两个日期相差年数
在非重置情况下，如果起始日期的月大于结束日期的月，年数要少算1（不足1年）
long betweenYear = DateUtil.betweenYear(DateUtil.parse("2021-05-18 22:15:00"), DateUtil.parse("2020-05-18 21:15:00"),true);
Assert.assertEquals(1, betweenYear);
betweenYear = DateUtil.betweenYear(DateUtil.parse("2020-05-18 22:15:00"), DateUtil.parse("2021-05-18 22:15:00"),true);
Assert.assertEquals(1, betweenYear);
betweenYear = DateUtil.betweenYear(DateUtil.parse("2020-05-18 22:15:00"), DateUtil.parse("2021-05-18 21:15:00"),false);
Assert.assertEquals(0, betweenYear);
betweenYear = DateUtil.betweenYear(DateUtil.parse("2020-05-18 22:15:00"), DateUtil.parse("2021-05-19 22:15:00"),false);
Assert.assertEquals(1, betweenYear);
betweenYear = DateUtil.betweenYear(DateUtil.parse("2020-05-18 22:15:00"), DateUtil.parse("2021-04-18 22:15:00"),false);
Assert.assertEquals(0, betweenYear);
level 级别，按照天、小时、分、秒、毫秒分为5个等级
String dateStr1 = "2017-03-01 22:34:23";
Date date1 = DateUtil.parse(dateStr1);
String dateStr2 = "2017-04-01 23:56:14";
Date date2 = DateUtil.parse(dateStr2);
long between = DateUtil.between(date1, date2, DateUnit.MS);
String formatBetween = DateUtil.formatBetween(between, BetweenFormatter.Level.MINUTE);
Assert.assertEquals("31天1小时21分", formatBetween);
当前日期是否在日期指定范围内
起始日期和结束日期可以互换
String dateStr = "2017-03-01 22:34:23.100";
Date date = DateUtil.parse(dateStr);
String dateStr1 = "2017-02-01 22:34:23.100";
Date date1 = DateUtil.parse(dateStr1);
String dateStr2 = "2017-04-01 23:56:14.001";
Date date2 = DateUtil.parse(dateStr2);
boolean isIn = DateUtil.isIn(date,date1,date2);
Assert.assertEquals(Boolean.TRUE, isIn);
dateStr = "2017-05-01 22:34:23.100";
date = DateUtil.parse(dateStr);
isIn = DateUtil.isIn(date,date1,date2);
Assert.assertEquals(Boolean.FALSE, isIn);
是否为相同时间
此方法比较两个日期的时间戳是否相同
String dateStr = "2017-02-01 22:34:23.100";
Date date = DateUtil.parse(dateStr);
String dateStr1 = "2017-02-01 22:34:23.100";
Date date1 = DateUtil.parse(dateStr1);
boolean isSameTime = DateUtil.isSameTime(date,date1);
Assert.assertEquals(Boolean.TRUE, isSameTime);
dateStr1 = "2017-02-01 22:34:23.110";
date1 = DateUtil.parse(dateStr1);
isSameTime = DateUtil.isSameTime(date,date1);
Assert.assertEquals(Boolean.FALSE, isSameTime);
String dateStr1 = "2021-05-19 22:34:23.100";
Date date1 = DateUtil.parse(dateStr1);
String dateStr2 = "2021-05-19 23:56:14.001";
Date date2 = DateUtil.parse(dateStr2);
boolean isSameDay = DateUtil.isSameDay(date1,date2);
Assert.assertEquals(Boolean.TRUE, isSameDay);
dateStr2 = "2021-05-20 23:56:14.001";
date2 = DateUtil.parse(dateStr2);
isSameDay = DateUtil.isSameDay(date1,date2);
Assert.assertEquals(Boolean.FALSE, isSameDay);
计时，常用于记录某段代码的执行时间，单位：纳秒
//计时，常用于记录某段代码的执行时间，单位：纳秒
int j= 0;
long nanoTimeStart = System.nanoTime();
for (int i = 0; i < 100000; i++) {
j=j+i;
}
long nanoTimeEnd = DateUtil.spendNt(nanoTimeStart);
System.out.println("运行时间为："+nanoTimeEnd+"纳秒");
System.out.println("j的值为："+j);
spendMs(long)
方法描述
计时，常用于记录某段代码的执行时间，单位：毫秒
TimeInterval timer = DateUtil.timer();
// ---------------------------------
// -------这是执行过程
// ---------------------------------
timer.interval();// 花费毫秒数
timer.intervalRestart();// 返回花费时间，并重置开始时间
timer.intervalMinute();// 花费分钟数
方法描述
创建秒表{@link StopWatch}，用于对代码块的执行时间计数
使用方法如下：
StopWatch stopWatch = DateUtil.createStopWatch();
// 任务1
stopWatch.start(“任务一”);
Thread.sleep(1000);
stopWatch.stop();
// 任务2
stopWatch.start(“任务一”);
Thread.sleep(2000);
stopWatch.stop();
// 打印出耗时
Console.log(stopWatch.prettyPrint());
StopWatch stopWatch = DateUtil.createStopWatch("任务名称");
// 任务1
stopWatch.start("任务一");
Thread.sleep(1000);
stopWatch.stop();
// 任务2
stopWatch.start("任务二");
Thread.sleep(2000);
stopWatch.stop();
// 打印出耗时
System.out.println(stopWatch.prettyPrint());
String birthDay = "2019-05-19";
//生日转为年龄，计算法定年龄(生日，标准日期字符串)
int ageOfNow = DateUtil.ageOfNow(birthDay);
System.out.println(ageOfNow);
String d1 = "2000-02-29";
String d2 = "2018-02-28";
final int age = DateUtil.age(DateUtil.parseDate(d1), DateUtil.parseDate(d2));
Assert.assertEquals(18, age);
方法描述
是否闰年
int second = DateUtil.timeToSecond("00:01:40");
Assert.assertEquals(100, second);
second = DateUtil.timeToSecond("00:00:40");
Assert.assertEquals(40, second);
second = DateUtil.timeToSecond("01:00:00");
Assert.assertEquals(3600, second);
second = DateUtil.timeToSecond("00:00:00");
Assert.assertEquals(0, second);
方法描述
秒数转为时间格式(HH:mm:ss)
String time = DateUtil.secondToTime(3600);
Assert.assertEquals("01:00:00", time);
time = DateUtil.secondToTime(3800);
Assert.assertEquals("01:03:20", time);
time = DateUtil.secondToTime(0);
Assert.assertEquals("00:00:00", time);
time = DateUtil.secondToTime(30);
Assert.assertEquals("00:00:30", time);
比较结果，如果date1 < date2，返回数小于0，date1==date2返回0，date1 > date2 大于0
Date date1 = DateUtil.parse("2021-04-13 23:59:59.999");
Date date2 = DateUtil.parse("2021-04-13 23:59:10");
Assert.assertEquals(1, DateUtil.compare(date1, date2));
Date date1 = DateUtil.parse("2021-04-13 23:59:59.999");
Date date2 = DateUtil.parse("2021-04-13 23:59:10");
Assert.assertEquals(1, DateUtil.compare(date1, date2, DatePattern.NORM_DATETIME_PATTERN));
Assert.assertEquals(0, DateUtil.compare(date1, date2, DatePattern.NORM_DATE_PATTERN));
Assert.assertEquals(0, DateUtil.compare(date1, date2, DatePattern.NORM_DATETIME_MINUTE_PATTERN));
Date date11 = DateUtil.parse("2021-04-13 23:59:59.999");
Date date22 = DateUtil.parse("2021-04-11 23:10:10");
Assert.assertEquals(0, DateUtil.compare(date11, date22, DatePattern.NORM_MONTH_PATTERN));
lengthOfYear(int)
int dayOfYear = DateUtil.dayOfYear(DateUtil.parse(“2020-01-01”));
Assert.assertEquals(1, dayOfYear);
int lengthOfYear = DateUtil.lengthOfYear(2020);
Assert.assertEquals(366, lengthOfYear);
int lengthOfMonth = DateUtil.lengthOfMonth(2,true);
Assert.assertEquals(29, lengthOfMonth);
lengthOfMonth = DateUtil.lengthOfMonth(2,false);
Assert.assertEquals(28, lengthOfMonth);
| 方法 | 描述 |
|---|---|
| cn.hutool.core.date.DateUtil.date() |
|
| cn.hutool.core.date.DateUtil.dateSecond() |
|
| cn.hutool.core.date.DateUtil.current() |
|
| cn.hutool.core.date.DateUtil.currentSeconds() |
|
| cn.hutool.core.date.DateUtil.now() |
|
| cn.hutool.core.date.DateUtil.today() |
|
// 当前时间
DateTime date = DateUtil.date();
System.out.println(date);
System.out.println(date.toString());
Assert.assertNotNull(date);
// 当前时间
DateTime date = DateUtil.date();
System.out.println("long时间："+date.getTime());
//当前时间 忽略毫秒
System.out.println("long时间忽略毫秒："+DateUtil.dateSecond().getTime());
//当前时间 忽略毫秒部分
Date date4 = DateUtil.dateSecond();
Assert.assertNotNull(date4);
| 方法 | 描述 |
|---|---|
| cn.hutool.core.date.DateUtil.dateNew(java.util.Date) |
|
| cn.hutool.core.date.DateUtil.date(long) |
|
| cn.hutool.core.date.DateUtil.date(java.util.Calendar) |
|
| cn.hutool.core.date.DateUtil.date(java.time.temporal.TemporalAccessor) |
|
获取日期的各种内容，包含：年，季度，月，周，星期，日，时，分，秒，毫秒
获得月份，从0开始计数
Date、long、Calendar之间的相互转换
//当前时间
Date date = DateUtil.date();
//当前时间
Date date2 = DateUtil.date(Calendar.getInstance());
//当前时间
Date date3 = DateUtil.date(System.currentTimeMillis());
//当前时间字符串，格式：yyyy-MM-dd HH:mm:ss
String now = DateUtil.now();
//当前日期字符串，格式：yyyy-MM-dd
String today= DateUtil.today();
由来
考虑工具类的局限性，在某些情况下使用并不简便，于是DateTime类诞生。DateTime对象充分吸取Joda-Time库的优点，并提供更多的便捷方法，这样我们在开发时不必再单独导入Joda-Time库便可以享受简单快速的日期时间处理过程。
DateTime类继承于java.util.Date类，为Date类扩展了众多简便方法，这些方法多是DateUtil静态方法的对象表现形式，使用DateTime对象可以完全替代开发中Date对象的使用。
新建对象
DateTime对象包含众多的构造方法，构造方法支持的参数有：
Date
Calendar
String(日期字符串，第二个参数是日期格式)
long 毫秒数
构建对象有两种方式：DateTime.of()和new DateTime()：
Date date = new Date();
//new方式创建
DateTime time = new DateTime(date);
Console.log(time);
//of方式创建
DateTime now = DateTime.now();
DateTime dt = DateTime.of(date);
使用对象
DateTime的成员方法与DateUtil中的静态方法所对应，因为是成员方法，因此可以使用更少的参数操作日期时间。
示例：获取日期成员（年、月、日等）
DateTime dateTime = new DateTime(“2017-01-05 12:34:23”, DatePattern.NORM_DATETIME_FORMAT);
//年，结果：2017
int year = dateTime.year();
//季度（非季节），结果：Season.SPRING
Season season = dateTime.seasonEnum();
//月份，结果：Month.JANUARY
Month month = dateTime.monthEnum();
//日，结果：5
int day = dateTime.dayOfMonth();
更多成员方法请参阅API文档。
对象的可变性
DateTime对象默认是可变对象（调用offset、setField、setTime方法默认变更自身），但是这种可变性有时候会引起很多问题（例如多个地方共用DateTime对象）。我们可以调用setMutable(false)方法使其变为不可变对象。在不可变模式下，offset、setField方法返回一个新对象，setTime方法抛出异常。
DateTime dateTime = new DateTime(“2017-01-05 12:34:23”, DatePattern.NORM_DATETIME_FORMAT);
//默认情况下DateTime为可变对象，此时offsite == dateTime
DateTime offsite = dateTime.offsite(DateField.YEAR, 0);
//设置为不可变对象后变动将返回新对象，此时offsite != dateTime
dateTime.setMutable(false);
offsite = dateTime.offsite(DateField.YEAR, 0);
格式化为字符串
调用toString()方法即可返回格式为yyyy-MM-dd HH:mm:ss的字符串，调用toString(String format)可以返回指定格式的字符串。
DateTime dateTime = new DateTime(“2017-01-05 12:34:23”, DatePattern.NORM_DATETIME_FORMAT);
//结果：2017-01-05 12:34:23
String dateStr = dateTime.toString();
//结果：2017/01/05
大约一年前，我决定确保每个包含非唯一文本的Flash通知都将从模块中的方法中获取文本。我这样做的最初原因是为了避免一遍又一遍地输入相同的字符串。如果我想更改措辞，我可以在一个地方轻松完成，而且一遍又一遍地重复同一件事而出现拼写错误的可能性也会降低。我最终得到的是这样的:moduleMessagesdefformat_error_messages(errors)errors.map{|attribute,message|"Error:#{attribute.to_s.titleize}#{message}."}enddeferror_message_could_not_find(obje
无论您是想搭建桌面端、WEB端或者移动端APP应用，HOOPSPlatform组件都可以为您提供弹性的3D集成架构，同时，由工业领域3D技术专家组成的HOOPS技术团队也能为您提供技术支持服务。如果您的客户期望有一种在多个平台（桌面/WEB/APP，而且某些客户端是“瘦”客户端）快速、方便地将数据接入到3D应用系统的解决方案，并且当访问数据时，在各个平台上的性能和用户体验保持一致，HOOPSPlatform将帮助您完成。利用HOOPSPlatform，您可以开发在任何环境下的3D基础应用架构。HOOPSPlatform可以帮您打造3D创新型产品，HOOPSSDK包含的技术有：快速且准确的CAD
?博客主页：https://xiaoy.blog.csdn.net?本文由呆呆敲代码的小Y原创，首发于CSDN??学习专栏推荐：Unity系统学习专栏?游戏制作专栏推荐：游戏制作?Unity实战100例专栏推荐：Unity实战100例教程?欢迎点赞?收藏⭐留言?如有错误敬请指正！?未来很长，值得我们全力奔赴更美好的生活✨------------------❤️分割线❤️-------------------------
C#实现简易绘图工具一.引言实验目的:通过制作窗体应用程序(C#画图软件),熟悉基本的窗体设计过程以及控件设计,事件处理等,熟悉使用C#的winform窗体进行绘图的基本步骤,对于面向对象编程有更加深刻的体会.Tutorial任务设计一个具有基本功能的画图软件**·包括简单的新建文件,保存,重新绘图等功能**·实现一些基本图形的绘制,包括铅笔和基本形状等,学习橡皮工具的创建**·设计一个合理舒适的UI界面**注明:你可能需要先了解一些关于winform窗体应用程序绘图的基本知识,以及关于GDI+类和结构的知识二.实验环境Windows系统下的visualstudio2017C#窗体应用程序三.
1.postman介绍Postman一款非常流行的API调试工具。其实，开发人员用的更多。因为测试人员做接口测试会有更多选择，例如Jmeter、soapUI等。不过，对于开发过程中去调试接口，Postman确实足够的简单方便，而且功能强大。2.下载安装官网地址:https://www.postman.com/下载完成后双击安装吧，安装过程极其简单，无需任何操作3.使用教程这里以百度为例,工具使用简单，填写URL地址即可发送请求，在下方查看响应结果和响应状态码常用方法都有支持请求方法:getpostputdeleteGet、Post、Put与Delete的作用get：请求方法一般是用于数据查询，
我最喜欢的Google文档功能之一是它会在我工作时不断自动保存我的文档版本。这意味着即使我在进行关键更改之前忘记在某个点进行保存，也很有可能会自动创建一个保存点。至少，我可以将文档恢复到错误更改之前的状态，并从该点继续工作。对于在MacOS(或UNIX)上运行的Ruby编码器，是否有具有等效功能的工具？例如，一个工具会每隔几分钟自动将Gitcheckin我的本地存储库以获取我正在处理的文件。也许我有点偏执，但这点小保险可以让我在日常工作中安心。 最佳答案 虚拟机有些人可能讨厌我对此的回应，但我在编码时经常使用VIM，它具有自动保存功
我正在尝试上传文件。一个简单的hello.txt。我正在关注文档，但无法将其上传到我的存储桶。#STARTAWSCLIENTs3=Aws::S3::Resource.newbucket=s3.bucket(BUCKET_NAME)begins3.buckets[BUCKET_NAME].objects[KEY].write(:file=>FILE_NAME)puts"Uploadingfile#{FILE_NAME}tobucket#{BUCKET_NAME}."bucket.objects.eachdo|obj|puts"#{obj.key}=>#{obj.etag}"endresc
我有一个Highstock图表(带有标记和阴影的线条)，并且想以编程方式显示一个highstock工具提示，例如，当我选择某个表上的一行(包含图表数据)我想显示相应的highstock工具提示。这可能吗？ 最佳答案 股票图表thissolution不起作用:在thisexample你必须更换这个:chart.tooltip.refresh(chart.series[0].data[i]);为此:chart.tooltip.refresh([chart.series[0].points[i]]);解决方案可用here.
电脑上可以截取图片吗？如果可以，该如何操作呢？相信很多小伙伴都只知道一两种截图的方式，知道的并不全面。其实，电脑上有多种方式截图的，而且非常方便。电脑怎么截图？今天我们就来教大家如何使用电脑截取图片的8种常用方式！操作环境：演示机型：Delloptiplex7050系统版本：Windows10方法一：系统自带截图具体操作：同时按下电脑的自带截图键【Windows+shift+S】，可以选择其中一种方式来截取图片：截屏有矩形截屏、任意形状截屏、窗口截屏和全屏截图。 方法二：QQ截图具体操作：在电脑登录QQ，然后同时按下【Ctrl+Alt+A】，可以任意截图你需要的界面，可以把截图的页面直接下载，
一、机器人介绍 此处是基于MATLABRVC工具箱，对ABB-IRB-1200型号的微型机械臂进行正逆向运动学分析，并利Simulink工具实现对机械臂进行具有动力学参数的末端轨迹规划仿真，最后根据机械模型设计Simulink-Adams联合仿真。 图1.ABBIRB 1200尺寸参数示意图ABBIRB 1200提供的两种型号广泛适用于各作业，且两者间零部件通用，两种型号的工作范围分别为700 mm 和 900 mm，大有效负载分别为 7 kg 和5 kg。 IRB 1200 能够在狭小空间内能发挥其工作范围与性能优势，具有全新的设计、小型化的体积、高效的性能、易于集成、便捷的接