PostgreSQL提供了许多返回当前日期和时间的函数。这些 SQL 标准的函数全部都按照当前事务的开始时刻返回值：

select now();
select CURRENT_DATE;
select CURRENT_TIME;
select CURRENT_TIMESTAMP;
select CURRENT_TIME(precision);
select CURRENT_TIMESTAMP(precision);
select LOCALTIME;
select LOCALTIMESTAMP;
select LOCALTIME(precision);
select LOCALTIMESTAMP(precision);

--示例
SELECT CURRENT_TIME;
结果：14:39:53.662522-05

SELECT CURRENT_DATE;
结果：2001-12-23

SELECT CURRENT_TIMESTAMP;
结果：2001-12-23 14:39:53.662522-05

SELECT CURRENT_TIMESTAMP(2);
结果：2001-12-23 14:39:53.66-05

SELECT LOCALTIMESTAMP;
结果：2001-12-23 14:39:53.662522

通过now()获取的时间是最完整的时间，包括时区，秒也保留到了6位小数。

CURRENT_TIME和CURRENT_TIMESTAMP传递带有时区的值；

LOCALTIME和LOCALTIMESTAMP传递的值不带时区。

CURRENT_TIME、CURRENT_TIMESTAMP、LOCALTIME和 LOCALTIMESTAMP可以有选择地接受一个精度参数， 该精度导致结果的秒域被园整为指定小数位。如果没有精度参数，结果将被给予所能得到的全部精度。

 

PostgreSQL同样也提供了返回当前语句开始时间的函数， 它们会返回函数被调用时的真实当前时间。这些非 SQL 标准的函数列表如下：

select transaction_timestamp();
select statement_timestamp();
select clock_timestamp();
select timeofday();
select now();

transaction_timestamp()等价于CURRENT_TIMESTAMP，但是其命名清楚地反映了它的返回值。

statement_timestamp()返回当前语句的开始时刻（更准确的说是收到 客户端最后一条命令的时间）。

statement_timestamp()和transaction_timestamp()在一个事务的第一条命令期间返回值相同，但是在随后的命令中却不一定相同。 

clock_timestamp()返回真正的当前时间，因此它的值甚至在同一条 SQL 命令中都会变化。

timeofday()是一个有历史原因的PostgreSQL函数。和clock_timestamp()相似，timeofday()也返回真实的当前时间，但是它的结果是一个格式化的text串，而不是timestamp with time zone值。

now()是PostgreSQL的一个传统，等效于transaction_timestamp()。

 

将带有时区的格式的时间转换为不带时区的。类型转换参考：https://blog.csdn.net/lingyiwin/article/details/107244685
  select now()::timestamp(0)without time zone;（current_timestamp 是和now（）一样的）
 
 

表 9.30. 日期/时间函数 参考postgreSQL文档

函数	返回类型	描述	例子	结果
age(timestamp, timestamp)	interval	减去参数，生成一个使用年、月（而不是只用日）的“符号化”的结果	age(timestamp '2001-04-10', timestamp '1957-06-13')	43 年 9 月 27 日
age(timestamp)	interval	从current_date（在午夜）减去	age(timestamp '1957-06-13')	43 years 8 mons 3 days
clock_timestamp()	timestamp with time zone	当前日期和时间（在语句执行期间变化）；见第 9.9.4 节
current_date	date	当前日期；见第 9.9.4 节
current_time	time with time zone	当前时间（一天中的时间）；见第 9.9.4 节
current_timestamp	timestamp with time zone	当前日期和时间（当前事务开始时）；见第 9.9.4 节
date_part(text, timestamp)	double precision	获得子域（等价于extract）；见第 9.9.1 节	date_part('hour', timestamp '2001-02-16 20:38:40')	20
date_part(text, interval)	double precision	获得子域（等价于extract）；见第 9.9.1 节	date_part('month', interval '2 years 3 months')	3
date_trunc(text, timestamp)	timestamp	截断到指定精度；另见第 9.9.2 节	date_trunc('hour', timestamp '2001-02-16 20:38:40')	2001-02-16 20:00:00
date_trunc(text, interval)	interval	截断到指定精度；另见第 9.9.2 节	date_trunc('hour', interval '2 days 3 hours 40 minutes')	2 days 03:00:00
extract(field from timestamp)	double precision	获得子域；见第 9.9.1 节	extract(hour from timestamp '2001-02-16 20:38:40')	20
extract(field from interval)	double precision	获得子域；见第 9.9.1 节	extract(month from interval '2 years 3 months')	3
isfinite(date)	boolean	测试有限日期（不是+/-无限）	isfinite(date '2001-02-16')	true
isfinite(timestamp)	boolean	测试有限时间戳（不是+/-无限）	isfinite(timestamp '2001-02-16 21:28:30')	true
isfinite(interval)	boolean	测试有限间隔	isfinite(interval '4 hours')	true
justify_days(interval)	interval	调整间隔这样30天时间周期可以表示为月	justify_days(interval '35 days')	1 mon 5 days
justify_hours(interval)	interval	调整间隔这样24小时时间周期可以表示为日	justify_hours(interval '27 hours')	1 day 03:00:00
justify_interval(interval)	interval	使用justify_days和justify_hours调整间隔，使用额外的符号调整	justify_interval(interval '1 mon -1 hour')	29 days 23:00:00
localtime	time	当前时间（一天中的时间）；见第 9.9.4 节
localtimestamp	timestamp	当前日期和时间（当前事务的开始）；见第 9.9.4 节
make_date(year int, month int, day int)	date	从年、月、日域创建日期	make_date(2013, 7, 15)	2013-07-15
make_interval(years int DEFAULT 0, months int DEFAULT 0, weeks int DEFAULT 0, days int DEFAULT 0, hours int DEFAULT 0, mins int DEFAULT 0, secs double precision DEFAULT 0.0)	interval	从年、月、周、日、时、分、秒域创建 interval	make_interval(days => 10)	10 days
make_time(hour int, min int, sec double precision)	time	从时、分、秒域创建时间	make_time(8, 15, 23.5)	08:15:23.5
make_timestamp(year int, month int, day int, hour int, min int, sec double precision)	timestamp	从年、月、日、时、分、秒域创建时间戳	make_timestamp(2013, 7, 15, 8, 15, 23.5)	2013-07-15 08:15:23.5
make_timestamptz(year int, month int, day int, hour int, min int, sec double precision, [ timezone text ])	timestamp with time zone	从年、月、日、时、分、秒域创建带时区的时间戳。如果没有指定timezone， 则使用当前时区。	make_timestamptz(2013, 7, 15, 8, 15, 23.5)	2013-07-15 08:15:23.5+01
now()	timestamp with time zone	当前日期和时间（当前事务的开始）；见第 9.9.4 节
statement_timestamp()	timestamp with time zone	当前日期和时间（当前事务的开始）；见第 9.9.4 节
timeofday()	text	当前日期和时间（像clock_timestamp，但是作为一个text字符串）；见第 9.9.4 节
transaction_timestamp()	timestamp with time zone	当前日期和时间（当前事务的开始）；见第 9.9.4 节
to_timestamp(double precision)	timestamp with time zone	把 Unix 时间（从 1970-01-01 00:00:00+00 开始的秒）转换成 timestamp	to_timestamp(1284352323)	2010-09-13 04:32:03+00

LocalDateTime获取时间类

LocalDateTime获取时间类是java8提供的一个新的获取时间类，该类可以获取任意格式的时间，使用非常方便。

1. 获取当前当前时间

public void timeNow() {
		//输出当前时间
        LocalDateTime dateTime = LocalDateTime.now();
        System.out.println(dateTime);
    }

2.获取指定格式时间

public   void formatDateTime() {
        //格式化格式
        String format = "YYYY-MM-dd hh:mm:ss";
        // DateTimeFormatter.ofPattern方法根据指定的格式输出时间
        String formatDateTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern(format));

        System.out.println(formatDateTime);
    }

3.获取某个日期的时间

获取某个日期的时间可以通过选择不同的plus方法一直选择下去。

public void getDateTime() {
        //获取当前日期后一天的后一个小时
        LocalDateTime dateTime = LocalDateTime.now().plusDays(1).plusHours(1);
        System.out.println(dateTime);

        //格式化格式
        String format = "YYYY-MM-dd hh:mm:ss";
        //获取当前日期后三天以后3小时的时间并格式化输出
        String formatDate = LocalDateTime.now().plusDays(3).plusHours(3).format(DateTimeFormatter.ofPattern(format));
        System.out.println(formatDate);
    }
    ```
    

在java8以前，或许：

当你在做有关时间日期的操作时，你会想到用Date;
当你在做日期、月份、天数相加减时，你会想到用Calendar;
当你需要对时间日期进行格式化时，你会想到使用SimpleDateFormat或DateFormat下的其他子类；

但是，你必须知道，以上有关的时间日期操作对象，都是可变的、线程不安全的，同时，如果作为一个经常写过类似代码的人来说，尽管有相关对象提供某些操作，但并不能很快、很简单的就能得到最终想要的结果，如：要计算两个时间点之间相差的年、月、日、周、时、分、秒等，这些计算尽管原有API也能够实现，但原有API除了线程不安全之外，另外一个不足之处就是代码繁琐，性能低！

**为何我们总提多线程下，线程不安全？**对于初学者来说，可能觉得能够简单实现出功能就已经足够，但是真正的开发项目是不可能仅仅考虑功能的实现的，还要考虑项目的安全性、稳定性、高性能、高可用性等等！因此，作为java开发者，多线程的知识是必不可少的。而也正因为多线程，才会出现一大堆问题（简称线程安全性问题），作为开发者，就应该写出不仅能实现功能的代码，还要是线程安全的代码。那么，学习并熟悉掌握新的线程安全的API就显得非常重要了！

没错，java8出的新的时间日期API都是线程安全的，并且性能更好，代码更简洁！
新时间日期API常用、重要对象介绍

• ZoneId: 时区ID，用来确定Instant和LocalDateTime互相转换的规则
• Instant: 用来表示时间线上的一个点（瞬时）
• LocalDate: 表示没有时区的日期, LocalDate是不可变并且线程安全的
• LocalTime: 表示没有时区的时间, LocalTime是不可变并且线程安全的
• LocalDateTime: 表示没有时区的日期时间, LocalDateTime是不可变并且线程安全的
• Clock: 用于访问当前时刻、日期、时间，用到时区
• Duration: 用秒和纳秒表示时间的数量（长短），用于计算两个日期的“时间”间隔
• Period: 用于计算两个“日期”间隔

其中，LocalDate、LocalTime、LocalDateTime是新API里的基础对象，绝大多数操作都是围绕这几个对象来进行的，有必要搞清楚：
LocalDate ： 只含年月日的日期对象
LocalTime ：只含时分秒的时间对象
LocalDateTime ： 同时含有年月日时分秒的日期对象

本文将以实例讲解日常开发中常用到的时间日期操作，如：

获取当前日期、时间
指定时间日期创建对应的对象
计算两个时间点的间隔
判断两个时间的前后
时间日期的格式化
获取时间戳
时间、日期相加减
获取给定时间点的年份、月份、周、星期等

新时间日期API详解与示例
获取当前时间
LocalDate localDate = LocalDate.now();
LocalTime localTime = LocalTime.now();
LocalDateTime localDateTime = LocalDateTime.now();
System.out.println(localDate);
System.out.println(localTime);
System.out.println(localDateTime);

运行结果：

根据指定日期/时间创建对象
LocalDate localDate = LocalDate.of(2018, 1, 13);
LocalTime localTime = LocalTime.of(9, 43, 20);
LocalDateTime localDateTime = LocalDateTime.of(2018, 1, 13, 9, 43, 20);
System.out.println(localDate);
System.out.println(localTime);
System.out.println(localDateTime);

结果：

日期时间的加减
对于LocalDate,只有精度大于或等于日的加减，如年、月、日；
对于LocalTime,只有精度小于或等于时的加减，如时、分、秒、纳秒；
对于LocalDateTime,则可以进行任意精度的时间相加减；

LocalDateTime localDateTime = LocalDateTime.now();
//以下方法的参数都是long型，返回值都是LocalDateTime
LocalDateTime plusYearsResult = localDateTime.plusYears(2L);
LocalDateTime plusMonthsResult = localDateTime.plusMonths(3L);
LocalDateTime plusDaysResult = localDateTime.plusDays(7L);
LocalDateTime plusHoursResult = localDateTime.plusHours(2L);
LocalDateTime plusMinutesResult = localDateTime.plusMinutes(10L);
LocalDateTime plusSecondsResult = localDateTime.plusSeconds(10L);
        
System.out.println("当前时间是 : " + localDateTime + "\n"
        + "当前时间加2年后为 : " + plusYearsResult + "\n"
        + "当前时间加3个月后为 : " + plusMonthsResult + "\n"
        + "当前时间加7日后为 : " + plusDaysResult + "\n"
        + "当前时间加2小时后为 : " + plusHoursResult + "\n"
        + "当前时间加10分钟后为 : " + plusMinutesResult + "\n"
        + "当前时间加10秒后为 : " + plusSecondsResult + "\n"
        );
    
//也可以以另一种方式来相加减日期，即plus(long amountToAdd, TemporalUnit unit)
//                  参数1 ： 相加的数量， 参数2 ： 相加的单位
LocalDateTime nextMonth = localDateTime.plus(1, ChronoUnit.MONTHS);
LocalDateTime nextYear = localDateTime.plus(1, ChronoUnit.YEARS);
LocalDateTime nextWeek = localDateTime.plus(1, ChronoUnit.WEEKS);
        
System.out.println("now : " + localDateTime + "\n"
        + "nextYear : " + nextYear + "\n"
        + "nextMonth : " + nextMonth + "\n"
        + "nextWeek :" + nextWeek + "\n"
        );
        
//日期的减法用法一样，在此不再举例

运行结果：
将年、月、日等修改为指定的值，并返回新的日期（时间）对象
析： 其效果与时间日期相加减差不多，如今天是2018-01-13，要想变为2018-01-20有两种方式
a. localDate.plusDays(20L) -> 相加指定的天数
b. localDate.withDayOfYear(20) -> 直接指定到哪一天

LocalDate localDate = LocalDate.now();
//当前时间基础上，指定本年当中的第几天，取值范围为1-365,366
LocalDate withDayOfYearResult = localDate.withDayOfYear(200);
//当前时间基础上，指定本月当中的第几天，取值范围为1-29,30,31
LocalDate withDayOfMonthResult = localDate.withDayOfMonth(5);
//当前时间基础上，直接指定年份
LocalDate withYearResult = localDate.withYear(2017);
//当前时间基础上，直接指定月份
LocalDate withMonthResult = localDate.withMonth(5);
System.out.println("当前时间是 : " + localDate + "\n"
        + "指定本年当中的第200天 : " + withDayOfYearResult + "\n"
        + "指定本月当中的第5天 : " + withDayOfMonthResult + "\n"
        + "直接指定年份为2017 : " + withYearResult + "\n"
        + "直接指定月份为5月 : " + withMonthResult + "\n"
        );

结果：

获取日期的年月日周时分秒
LocalDateTime localDateTime = LocalDateTime.now();
int dayOfYear = localDateTime.getDayOfYear();
int dayOfMonth = localDateTime.getDayOfMonth();
DayOfWeek dayOfWeek = localDateTime.getDayOfWeek();
System.out.println("今天是" + localDateTime + "\n"
        + "本年当中第" + dayOfYear + "天" + "\n"
        + "本月当中第" + dayOfMonth + "天" + "\n"
        + "本周中星期" + dayOfWeek.getValue() + "-即" + dayOfWeek + "\n");
        
//获取当天时间的年月日时分秒
int year = localDateTime.getYear();
Month month = localDateTime.getMonth();
int day = localDateTime.getDayOfMonth();
int hour = localDateTime.getHour();
int minute = localDateTime.getMinute();
int second = localDateTime.getSecond();
System.out.println("今天是" + localDateTime + "\n"
        + "年 ： " + year + "\n"
        + "月 ： " + month.getValue() + "-即 "+ month + "\n"
        + "日 ： " + day + "\n"
        + "时 ： " + hour + "\n"
        + "分 ： " + minute + "\n"
        + "秒 ： " + second + "\n"
        );

结果：

时间日期前后的比较与判断
//判断两个时间点的前后
LocalDate localDate1 = LocalDate.of(2017, 8, 8);
LocalDate localDate2 = LocalDate.of(2018, 8, 8);
boolean date1IsBeforeDate2 = localDate1.isBefore(localDate2);
System.out.println("date1IsBeforeDate2 : " + date1IsBeforeDate2);
// date1IsBeforeDate2 == true

判断是否为闰年
LocalDate now = LocalDate.now();
System.out.println("now : " + now + ", is leap year ? " + );

java8时钟 ： clock()
//返回当前时间，根据系统时间和UTC
Clock clock = Clock.systemUTC();
// 运行结果： SystemClock[Z]
System.out.println(clock);

时间戳
事实上Instant就是java8以前的Date，
可以使用以下两个类中的方法在这两个类型之间进行转换，
比如Date.from(Instant)就是用来把Instant转换成java.util.date的，
而new Date().toInstant()就是将Date转换成Instant的

Instant instant = Instant.now();
//2019-06-08T16:50:19.174Z
System.out.println(instant);
Date date = Date.from(instant);
Instant instant2 = date.toInstant();
//Sun Jun 09 00:50:19 CST 2019
System.out.println(date);
//2019-06-08T16:50:19.174Z
System.out.println(instant2);

计算时间、日期间隔
Duration:用于计算两个“时间”间隔
Period:用于计算两个“日期”间隔

//计算两个日期的日期间隔-年月日
LocalDate date1 = LocalDate.of(2018, 2, 13);
LocalDate date2 = LocalDate.of(2017, 3, 12);
//内部是用date2-date1，所以得到的结果是负数
Period period = Period.between(date1, date2);
System.out.println("相差年数 ： " + period.getYears());
System.out.println("相差月数 ： " + period.getMonths());
System.out.println("相差日数 ： " + period.getDays());
//还可以这样获取相差的年月日
System.out.println("-------------------------------");
long years = period.get(ChronoUnit.YEARS);
long months = period.get(ChronoUnit.MONTHS);
long days = period.get(ChronoUnit.DAYS);
System.out.println("相差的年月日分别为 ： " + years + "," + months + "," + days);
//注意，当获取两个日期的间隔时，并不是单纯的年月日对应的数字相加减，而是会先算出具体差多少天，在折算成相差几年几月几日的
        
//计算两个时间的间隔
System.out.println("-------------------------------");
LocalDateTime date3 = LocalDateTime.now();
LocalDateTime date4 = LocalDateTime.of(2018, 1, 13, 22, 30, 10);
Duration duration = Duration.between(date3, date4);
System.out.println(date3 + " 与 " + date4 + " 间隔  " + "\n"
        + " 天 :" + duration.toDays() + "\n"
        + " 时 :" + duration.toHours() + "\n"
        + " 分 :" + duration.toMinutes() + "\n"
        + " 毫秒 :" + duration.toMillis() + "\n"
        + " 纳秒 :" + duration.toNanos() + "\n"
        );
//注意，并没有获得秒差的，但既然可以获得毫秒，秒就可以自行获取了

结果：

当计算程序的运行时间时，应当使用时间戳Instant

Instant ins1 = Instant.now();
for (int i = 0; i < 10000000; i++) {
            //循环一百万次
}
Instant ins2 = Instant.now();
Duration duration = Duration.between(ins1, ins2);
System.out.println("程序运行耗时为 ： " + duration.toMillis() + "毫秒");

时间日期的格式化（格式化后返回的类型是String）
1. 使用jdk自身配置好的日期格式
//使用jdk自身配置好的日期格式
DateTimeFormatter formatter1 = DateTimeFormatter.ISO_DATE_TIME;
LocalDateTime date1 = LocalDateTime.now();
//反过来调用也可以 : date1.format(formatter1);
String date1Str = formatter1.format(date1);
System.out.println(date1Str);

结果：

2. 使用自定义格式
LocalDateTime date1 = LocalDateTime.now();
DateTimeFormatter formatter2 = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");
String date2Str = formatter2.format(date1);
System.out.println(date2Str);

结果：

注：自定义转化的格式一定要与日期类型对应

LocalDate只能设置仅含年月日的格式
LocalTime只能设置仅含时分秒的格式
LocalDateTime可以设置含年月日时分秒的格式
代码如下：

DateTimeFormatter formatter3 = DateTimeFormatter.ofPattern("yyyy-MM-dd");
System.out.println(formatter3.format(LocalDate.now()));
        
System.out.println("-------------------------------");
        
DateTimeFormatter formatter4 = DateTimeFormatter.ofPattern("HH:mm:ss");
System.out.println(formatter4.format(LocalTime.now()));

结果：

将时间字符串形式转化为日期对象

将时间字符串形式转化为日期对象
String datetime =  "2018-01-13 21:27:30";  
DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
LocalDateTime ldt = LocalDateTime.parse(datetime, dtf);  
System.out.println(ldt);  

结果：

注：格式的写法必须与字符串的形式一样
2018-01-13 21:27:30 对应 yyyy-MM-dd HH:mm:ss
20180113213328 对应 yyyyMMddHHmmss
否则会报运行时异常！

但要记住：得到的最终结果都是类似2018-01-13T21:27:30的格式

因为在输出LocalDateTime对象时，会调用其重写的toString方法。

@Override
    public String toString() {
        return date.toString() + 'T' + time.toString();
    }

将时间日期对象转为格式化后的时间日期对象

将时间日期对象转为格式化后的时间日期对象
//新的格式化API中，格式化后的结果都默认是String，有时我们也需要返回经过格式化的同类型对象
LocalDateTime ldt1 = LocalDateTime.now();
DateTimeFormatter dtf1 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String temp = dtf1.format(ldt1);
LocalDateTime formatedDateTime = LocalDateTime.parse(temp, dtf1);
System.out.println(formatedDateTime);

结果：

long毫秒值转换为日期

long毫秒值转换为日期
System.out.println("---------long毫秒值转换为日期---------");
DateTimeFormatter df= DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String longToDateTime = df.format(LocalDateTime.ofInstant(
   Instant.ofEpochMilli(System.currentTimeMillis()),ZoneId.of("Asia/Shanghai")));
System.out.println(longToDateTime);

结果：

借鉴：https://www.cnblogs.com/mark5/p/11865833.html

技术活，该赏
关注+一键三连（点赞，评论，收藏）再看，养成好习惯

hutool实战（带你掌握里面的各种工具）目录

万字博文教你搞懂java源码的日期和时间相关用法

---

用途：获取当前时间

使用场景

当前时间，当前时间戳获取的多种方式

项目引用

此博文的依据：hutool-5.6.5版本源码

        <dependency>
			<groupId>cn.hutool</groupId>
			<artifactId>hutool-core</artifactId>
			<version>5.6.5</version>
		</dependency>

方法摘要

方法	描述
cn.hutool.core.date.DateUtil.date()	当前时间，转换为{@link DateTime}对象
cn.hutool.core.date.DateUtil.dateSecond()	当前时间，转换为{@link DateTime}对象，忽略毫秒部分
cn.hutool.core.date.DateUtil.current()	当前时间的时间戳
cn.hutool.core.date.DateUtil.currentSeconds()	当前时间的时间戳（秒）
cn.hutool.core.date.DateUtil.now()	当前时间，格式 yyyy-MM-dd HH:mm:ss
cn.hutool.core.date.DateUtil.today()	当前日期，格式 yyyy-MM-dd

方法明细

方法名称:cn.hutool.core.date.DateUtil.date()

方法描述

当前时间，转换为{@link DateTime}对象

支持版本及以上

参数描述:

参数名	描述

返回值:

当前时间

参考案例:

		// 当前时间
		DateTime date = DateUtil.date();
		System.out.println(date);
		System.out.println(date.toString());
		Assert.assertNotNull(date);

源码解析：

要探索JDK的核心底层源码，那必须掌握native用法

1源码分析：DateUtil(时间工具类)-当前时间和当前时间戳

方法明细

方法名称:cn.hutool.core.date.DateUtil.dateSecond()

方法描述

当前时间，转换为{@link DateTime}对象，忽略毫秒部分

支持版本及以上

4.6.2

参数描述:

参数名	描述

返回值:

当前时间

参考案例:

		// 当前时间
		DateTime date = DateUtil.date();
		System.out.println("long时间："+date.getTime());

		//当前时间 忽略毫秒
		System.out.println("long时间忽略毫秒："+DateUtil.dateSecond().getTime());
		//当前时间 忽略毫秒部分
		Date date4 = DateUtil.dateSecond();
		Assert.assertNotNull(date4);

源码解析：

1源码分析：DateUtil(时间工具类)-当前时间和当前时间戳

方法明细

方法名称:cn.hutool.core.date.DateUtil.current()

方法描述

当前时间的时间戳

支持版本及以上

参数描述:

参数名	描述

返回值:

时间

参考案例:

        long current = DateUtil.current();
		String currentStr = String.valueOf(current);
		Assert.assertEquals(13, currentStr.length());

		long currentNano = DateUtil.current();
		String currentNanoStr = String.valueOf(currentNano);
		Assert.assertNotNull(currentNanoStr);

源码解析：

/**
	 * 当前时间的时间戳
	 *
	 * @return 时间
	 */
	public static long current() {
		return System.currentTimeMillis();
	}

方法明细

方法名称:cn.hutool.core.date.DateUtil.currentSeconds()

方法描述

当前时间的时间戳（秒）

支持版本及以上

4.0.0

参数描述:

参数名	描述

返回值:

当前时间秒数

参考案例:

		//当前时间的时间戳（秒）
		long dateSeconds = DateUtil.currentSeconds();
		System.out.println(dateSeconds);
		Assert.assertNotNull(dateSeconds);

源码解析：

/**
	 * 当前时间的时间戳（秒）
	 *
	 * @return 当前时间秒数
	 * @since 4.0.0
	 */
	public static long currentSeconds() {
		return System.currentTimeMillis() / 1000;
	}

方法明细

方法名称:cn.hutool.core.date.DateUtil.now()

方法描述

当前时间，格式 yyyy-MM-dd HH:mm:ss

支持版本及以上

参数描述:

参数名	描述

返回值:

当前时间的标准形式字符串

参考案例:

        // 当前日期字符串，格式：yyyy-MM-dd HH:mm:ss
		String now = DateUtil.now();
		Assert.assertNotNull(now);

源码解析：

1源码分析：DateUtil(时间工具类)-当前时间和当前时间戳

方法明细

方法名称:cn.hutool.core.date.DateUtil.today()

方法描述

当前日期，格式 yyyy-MM-dd

支持版本及以上

参数描述:

参数名	描述

返回值:

当前日期的标准形式字符串

参考案例:

		// 当前日期字符串，格式：yyyy-MM-dd
		String today = DateUtil.today();
		Assert.assertNotNull(today);

源码解析：

1源码分析：DateUtil(时间工具类)-当前时间和当前时间戳