Java 8 日期和时间的API

java.time包：

这是新的Java日期/时间API的基础包，所有的主要基础类都是这个包的一部分，如：LocalDate, LocalTime, LocalDateTime, Instant, Period, Duration等等。所有这些类都是不可变的和线程安全的，在绝大多数情况下，这些类能够有效地处理一些公共的需求。

• Instant——它代表的是时间戳

• LocalDate——不包含具体时间的日期，比如2014-01-14。它可以用来存储生日，周年纪念日，入职日期等。

• LocalTime——它代表的是不含日期的时间

• LocalDateTime——它包含了日期及时间，不过还是没有偏移信息或者说时区。

• ZonedDateTime——这是一个包含时区的完整的日期时间，偏移量是以UTC/格林威治时间为基准的。

java.time.chrono包：

这个包为非ISO的日历系统定义了一些泛化的API，我们可以扩展AbstractChronology类来创建自己的日历系统。

java.time.format包：

这个包包含能够格式化和解析日期时间对象的类，在绝大多数情况下，我们不应该直接使用它们，因为java.time包中相应的类已经提供了格式化和解析的方法。

java.time.temporal包：

这个包包含一些时态对象，我们可以用其找出关于日期/时间对象的某个特定日期或时间，比如说，可以找到某月的第一天或最后一天。你可以非常容易地认出这些方法，因为它们都具有“withXXX”的格式。

java.time.zone包：

这个包包含支持不同时区以及相关规则的类。

java8处理时间及日期

1.LocalDate

LocalDate是一个不可变的类，它表示默认格式(yyyy-MM-dd)的日期，我们可以使用now()方法得到当前时间，也可以提供输入年份、月份和日期的输入参数来创建一个LocalDate实例。该类为now()方法提供了重载方法，我们可以传入ZoneId来获得指定时区的日期。该类提供与java.sql.Date相同的功能，对于如何使用该类，我们来看一个简单的例子。

public class LocalDateExample {
 
    public static void main(String[] args) {
 
        //Current Date
        LocalDate today = LocalDate.now();
        System.out.println("Current Date="+today);
 
        //Creating LocalDate by providing input arguments
        LocalDate firstDay_2014 = LocalDate.of(2014, Month.JANUARY, 1);
        System.out.println("Specific Date="+firstDay_2014);

        //Current date in "Asia/Kolkata", you can get it from ZoneId javadoc
        LocalDate todayKolkata = LocalDate.now(ZoneId.of("Asia/Kolkata"));
        System.out.println("Current Date in IST="+todayKolkata);
 
        //java.time.zone.ZoneRulesException: Unknown time-zone ID: IST
        //LocalDate todayIST = LocalDate.now(ZoneId.of("IST"));
 
        //Getting date from the base date i.e 01/01/1970
        LocalDate dateFromBase = LocalDate.ofEpochDay(365);
        System.out.println("365th day from base date= "+dateFromBase);
 
        LocalDate hundredDay2014 = LocalDate.ofYearDay(2014, 100);
        System.out.println("100th day of 2014="+hundredDay2014);
    }
 
}

//输出
Current Date=2014-04-28
Specific Date=2014-01-01
Current Date in IST=2014-04-29
365th day from base date= 1971-01-01
100th day of 2014=2014-04-1

2.LocalTime

LocalTime是一个不可变的类，它的实例代表一个符合人类可读格式的时间，默认格式是hh:mm:ss.zzz。像LocalDate一样，该类也提供了时区支持，同时也可以传入小时、分钟和秒等输入参数创建实例，我们来看一个简单的程序，演示该类的使用方法。

public class LocalTimeExample {
 
    public static void main(String[] args) {
 
        //Current Time
        LocalTime time = LocalTime.now();
        System.out.println("Current Time="+time);
 
        //Creating LocalTime by providing input arguments
        LocalTime specificTime = LocalTime.of(12,20,25,40);
        System.out.println("Specific Time of Day="+specificTime);
 
        //Current date in "Asia/Kolkata", you can get it from ZoneId javadoc
        LocalTime timeKolkata = LocalTime.now(ZoneId.of("Asia/Kolkata"));
        System.out.println("Current Time in IST="+timeKolkata);
 
        //java.time.zone.ZoneRulesException: Unknown time-zone ID: IST
        //LocalTime todayIST = LocalTime.now(ZoneId.of("IST"));
 
        //Getting date from the base date i.e 01/01/1970
        LocalTime specificSecondTime = LocalTime.ofSecondOfDay(10000);
        System.out.println("10000th second time= "+specificSecondTime);
    }
}

//输出
Current Time=15:51:45.240
Specific Time of Day=12:20:25.000000040
Current Time in IST=04:21:45.276
10000th second time= 02:46:40

3.LocalDateTime

LocalDateTime是一个不可变的日期-时间对象，它表示一组日期-时间，默认格式是yyyy-MM-dd-HH-mm-ss.zzz。它提供了一个工厂方法，接收LocalDate和LocalTime输入参数，创建LocalDateTime实例。我们来看一个简单的例子。

public class LocalDateTimeExample {
 
    public static void main(String[] args) {
 
        //Current Date
        LocalDateTime today = LocalDateTime.now();
        System.out.println("Current DateTime="+today);
 
        //Current Date using LocalDate and LocalTime
        today = LocalDateTime.of(LocalDate.now(), LocalTime.now());
        System.out.println("Current DateTime="+today);
 
        //Creating LocalDateTime by providing input arguments
        LocalDateTime specificDate = LocalDateTime.of(2014, Month.JANUARY, 1, 10, 10, 30);
        System.out.println("Specific Date="+specificDate);
 
        //Current date in "Asia/Kolkata", you can get it from ZoneId javadoc
        LocalDateTime todayKolkata = LocalDateTime.now(ZoneId.of("Asia/Kolkata"));
        System.out.println("Current Date in IST="+todayKolkata);
 
        //java.time.zone.ZoneRulesException: Unknown time-zone ID: IST
        //LocalDateTime todayIST = LocalDateTime.now(ZoneId.of("IST"));
 
        //Getting date from the base date i.e 01/01/1970
        LocalDateTime dateFromBase = LocalDateTime.ofEpochSecond(10000, 0, ZoneOffset.UTC);
        System.out.println("10000th second time from 01/01/1970= "+dateFromBase);
    }
}

//输出
Current DateTime=2014-04-28T16:00:49.455
Current DateTime=2014-04-28T16:00:49.493
Specific Date=2014-01-01T10:10:30
Current Date in IST=2014-04-29T04:30:49.493
10000th second time from 01/01/1970= 1970-01-01T02:46:40

4.Instant

Instant类是用在机器可读的时间格式上的，它以Unix时间戳的形式存储日期时间，我们来看一个简单的程序。

public class InstantExample {
 
    public static void main(String[] args) {
        //Current timestamp
        Instant timestamp = Instant.now();
        System.out.println("Current Timestamp = "+timestamp);
 
        //Instant from timestamp
        Instant specificTime = Instant.ofEpochMilli(timestamp.toEpochMilli());
        System.out.println("Specific Time = "+specificTime);
 
        //Duration example
        Duration thirtyDay = Duration.ofDays(30);
        System.out.println(thirtyDay);
    }
 
}
//输出
Current Timestamp = 2014-04-28T23:20:08.489Z
Specific Time = 2014-04-28T23:20:08.489Z
PT720H

5.日期API工具

我们早些时候提到过，大多数日期/时间API类都实现了一系列工具方法，如：加/减天数、周数、月份数，等等。还有其他的工具方法能够使用TemporalAdjuster调整日期，并计算两个日期间的周期。

public class DateAPIUtilities {
 
    public static void main(String[] args) {
 
        LocalDate today = LocalDate.now();
 
        //Get the Year, check if it's leap year
        System.out.println("Year "+today.getYear()+" is Leap Year? "+today.isLeapYear());
 
        //Compare two LocalDate for before and after
        System.out.println("Today is before 01/01/2015? "+today.isBefore(LocalDate.of(2015,1,1)));
 
        //Create LocalDateTime from LocalDate
        System.out.println("Current Time="+today.atTime(LocalTime.now()));
 
        //plus and minus operations
        System.out.println("10 days after today will be "+today.plusDays(10));
        System.out.println("3 weeks after today will be "+today.plusWeeks(3));
        System.out.println("20 months after today will be "+today.plusMonths(20));
 
        System.out.println("10 days before today will be "+today.minusDays(10));
        System.out.println("3 weeks before today will be "+today.minusWeeks(3));
        System.out.println("20 months before today will be "+today.minusMonths(20));
 
        //Temporal adjusters for adjusting the dates
        System.out.println("First date of this month= "+today.with(TemporalAdjusters.firstDayOfMonth()));
        LocalDate lastDayOfYear = today.with(TemporalAdjusters.lastDayOfYear());
        System.out.println("Last date of this year= "+lastDayOfYear);
 
        Period period = today.until(lastDayOfYear);
        System.out.println("Period Format= "+period);
        System.out.println("Months remaining in the year= "+period.getMonths());        
    }
}
//输出
Year 2014 is Leap Year? false
Today is before 01/01/2015? true
Current Time=2014-04-28T16:23:53.154
10 days after today will be 2014-05-08
3 weeks after today will be 2014-05-19
20 months after today will be 2015-12-28
10 days before today will be 2014-04-18
3 weeks before today will be 2014-04-07
20 months before today will be 2012-08-28
First date of this month= 2014-04-01
Last date of this year= 2014-12-31
Period Format= P8M3D
Months remaining in the year= 8

6.解析和格式化

public class GetDate {

    public final static String YYYYMMDD = "yyyy-MM-dd";
    public final static String YEAR_MONTH_DAY = "yyyy年MM月dd日";
    public final static String YYYYMMDDHHMMSS = "yyyy-MM-dd HH:mm:ss";
    public final static String YYYYMMDDHHMMSSSSS = "yyyyMMddHHmmssSSS";
    public final static String YYYYMMDDHHMMSS_NOSIGN = "yyyyMMddHHmmss";
    public final static String YYYYMMDD_1 = "yyyyMMdd";


    // ---------------------------- Formatter ---------------------------

    /**
     * 2018-05-31
     */
    public final static DateTimeFormatter FORMATTER_LOCAL = DateTimeFormatter.ISO_LOCAL_DATE;

    /**
     * 2018年05月31日
     */
    public final static DateTimeFormatter FORMATTER_YEAR_MONTH_DAY = DateTimeFormatter.ofPattern(YEAR_MONTH_DAY);

    /**
     * 2018-05-31 11:12:42
     */
    public final static DateTimeFormatter FORMATTER_YYYYMMDDHHMMSS = DateTimeFormatter.ofPattern(YYYYMMDDHHMMSS);

    /**
     * 20180531110806694
     */
    public final static DateTimeFormatter FORMATTER_YYYYMMDDHHMMSSSSS = DateTimeFormatter.ofPattern(YYYYMMDDHHMMSSSSS);

    /**
     * 20180629173455
     */
    public final static DateTimeFormatter FORMATTER_YYYYMMDDHHMMSS_NOSIGN = DateTimeFormatter.ofPattern(YYYYMMDDHHMMSS_NOSIGN);

    /**
     * 2018-05-31
     */
    public final static DateTimeFormatter FORMATTER_YYYYMMDD = DateTimeFormatter.ofPattern(YYYYMMDD);

    public final static DateTimeFormatter FORMATTER_YYYYMMDD_1 = DateTimeFormatter.ofPattern(YYYYMMDD_1);

    /**
     * 获取当前时间，并格式化成给定格式
     *
     * @param formatter
     * @return
     */
    public static String getNowTimeString(DateTimeFormatter formatter) {
        LocalDateTime now = LocalDateTime.now();
        return now.format(formatter);
    }

    /**
     * 获取当前时间Unix格式 (10位int)
     *
     * @return
     */
    public static Integer getNowTimeUnix() {
        LocalDateTime now = LocalDateTime.now();
        return (int) now.toEpochSecond(ZoneOffset.of("+8"));
    }

    /**
     * Unix时间戳格式化成String
     *
     * @param unixTime
     * @param formatter
     * @return
     */
    public static String unixToString(int unixTime, DateTimeFormatter formatter) {
        Instant instant = Instant.ofEpochSecond(unixTime);
        LocalDateTime localDateTime = LocalDateTime.ofInstant(instant, ZoneOffset.of("+8"));
        return localDateTime.format(formatter);
    }

    /**
     * String格式时间转换成Unix时间戳
     *
     * @param timeStr   "yyyy-MM-dd HH:mm:ss" 这种格式
     * @param formatter
     * @return
     */
    public static int stringToUnix(String timeStr) {
        if (timeStr.length() == 10) {
            timeStr = timeStr + " 00:00:00";
        }
        LocalDateTime localDateTime = LocalDateTime.parse(timeStr, FORMATTER_YYYYMMDDHHMMSS);
        return (int) localDateTime.toEpochSecond(ZoneOffset.of("+8"));
    }

    /**
     * String格式时间转换成Unix时间戳
     *
     * @param timeStr   "yyyy-MM-dd" 这种格式
     * @param formatter
     * @return
     */
    public static int stringToUnix(String timeStr, DateTimeFormatter formatter) {
        if (timeStr.length() == 10) {
            timeStr = timeStr + " 00:00:00";
        }
        LocalDateTime localDateTime = LocalDateTime.parse(timeStr, FORMATTER_YYYYMMDDHHMMSS);
        return (int) localDateTime.toEpochSecond(ZoneOffset.of("+8"));
    }

    /**
     * 获得时间开始 例：传入 2015-12-03 返回 2015-12-03 00:00:00
     *
     * @param curDate
     * @return
     */
    public static String getDayStart(String curDate) {
        return curDate + " 00:00:00";
    }

    /**
     * 获得时间结束 例：传入 2015-12-03 返回 2015-12-03 23:59:59
     *
     * @param curDate
     * @return
     */
    public static String getDayEnd(String curDate) {
        return curDate + " 23:59:59";
    }

    /**
     * 获取秒值
     *
     * @return
     */
    public static Integer getMyTimeInMillis() {
        // 当前时间
        long milliseconds = LocalDateTime.now().toInstant(ZoneOffset.of("+8")).toEpochMilli() / 1000;
        return (int) milliseconds;
    }


    /**
     *  时间戳 去掉时分秒
     * @param unixTime
     * @return
     */
   public static Integer getYYYYMMDDUnix(Integer unixTime){
       Instant instant = Instant.ofEpochSecond(unixTime);
       LocalDateTime localDateTime = LocalDateTime.ofInstant(instant, ZoneOffset.of("+8"));
        return GetDate.stringToUnix(localDateTime.format(GetDate.FORMATTER_YYYYMMDD));
    }
}