java8 時間使用

爲何須要新的時間API

文章來源：http://www.javashuo.com/article/p-gwqadnbt-kw.html
在Java 8以前的日期/時間API以前，現有的與日期和時間相關的類存在諸多問題，其中主要有：

1. Java的日期/時間類的定義並不一致，在java.util和java.sql的包中都有日期類，此外用於格式化和解析的類在java.text包中定義
2. java.util.Date同時包含日期和時間，而java.sql.Date僅包含日期，將其歸入java.sql包並不合理。另外這兩個類都有相同的名字，這自己就是一個很是糟糕的設計。
3. 對於時間、時間戳、格式化以及解析，並無一些明肯定義的類。對於格式化和解析的需求，咱們有java.text.DateFormat抽象類，但一般狀況下，SimpleDateFormat類被用於此類需求。
4. 全部的日期類都是可變的，所以他們都不是線程安全的，這是Java日期類最大的問題之一。
5. 日期類並不提供國際化，沒有時區支持，所以Java引入了java.util.Calendar和java.util.TimeZone類，但他們一樣存在上述全部的問題。
6. 在現有的日期和日曆類中定義的方法還存在一些其餘的問題，但以上問題已經很清晰地代表：Java須要一個健壯的日期/時間類。這也是爲何Joda Time在Java日期/時間需求中扮演了高質量替換的重要角色。
7. 使用java8以前的日期注意

使用Calendar類實現日期和時間字段之間轉換
   使用DateFormat類來格式化和分析日期字符串
   而Date只用來承載日期和時間信息

java8 概念

瞬時時間（Instant）,持續時間（duration），日期（date）,時間（time），時區（time-zone）以及時間段（Period）。Java 8仍然延用了ISO的日曆體系，而且與它的前輩們不一樣，java.time包中的類是不可變且線程安全的。新的時間及日期API位於java.time包中，下面是裏面的一些關鍵的類：

• Instant——它表明的是時間戳（由於它表明了一個肯定的時間點，即相對於1970年1月1日的偏移量；但與java.util.Date類不一樣的是其精確到了納秒級別。
• Duration：持續時間，時間差
• LocalDate——不包含具體時間的日期，好比2019-01-14。它能夠用來存儲生日，週年記念日，入職日期等。
• LocalTime——它表明的是不含日期的時間
• LocalDateTime——它包含了日期及時間，不過仍是沒有偏移信息或者說時區。
• Period：時間段
• ZoneOffset：時區偏移量，好比：+8:00
• ZonedDateTime——這是一個包含時區的完整的日期時間，偏移量是以UTC/格林威治時間爲基準的。
• Clock：時鐘，好比獲取目前美國紐約的時間

java8時間API特性

• 不變性：新的日期/時間API中，全部的類都是不可變的，這對多線程頗有好處。
• 關注點分離：借鑑了Joda庫的一些優勢，新的API將人可讀的日期時間和機器時間（unix timestamp）明確分離，它爲日期（Date）、時間（Time）、日期時間（DateTime）、時間戳（unix timestamp）以及時區定義了不一樣的類。
• 清晰：在全部的類中，方法都被明肯定義用以完成相同的行爲。例如要拿到當前實例咱們可使用now()方法，在全部的類中都定義了format()和parse()方法，而不是像之前那樣專門有一個獨立的類。爲了更好的處理問題，全部的類都使用了工廠模式和策略模式，一旦你使用了其中某個類的方法，與其餘類協同工做並不困難。
• 實用操做：全部新的日期/時間API類都實現了一系列方法用以完成通用的任務，如：加、減、格式化、解析、從日期/時間中提取單獨部分，等等。
• 可擴展性：新的日期/時間API是工做在ISO-8601日曆系統上的，但咱們也能夠將其應用在非IOS的日曆上。

java8日期/時間API包

• java.time包：這是新的Java日期/時間API的基礎包，全部的主要基礎類都是這個包的一部分，如：LocalDate, LocalTime, LocalDateTime, Instant, Period, Duration等等。全部這些類都是不可變的和線程安全的，在絕大多數狀況下，這些類可以有效地處理一些公共的需求。
• java.time.chrono包：這個包爲非ISO的日曆系統定義了一些泛化的API，咱們能夠擴展AbstractChronology類來建立本身的日曆系統。
• java.time.format包：這個包包含可以格式化和解析日期時間對象的類，在絕大多數狀況下，咱們不該該直接使用它們，由於java.time包中相應的類已經提供了格式化和解析的方法。
• java.time.temporal包：這個包包含一些時態對象，咱們能夠用其找出關於日期/時間對象的某個特定日期或時間，好比說，能夠找到某月的第一天或最後一天。你能夠很是容易地認出這些方法，由於它們都具備「withXXX」的格式。
• java.time.zone包：這個包包含支持不一樣時區以及相關規則的類。

java8 API介紹和使用

LocalDate

LocalDate 依然是一個不可變類，它關注時間中年月日部分

初始化實例
public static LocalDate now()：截斷當前系統時間的年月日信息並初始化一個實例對象
public static LocalDate of(int year, int month, int dayOfMonth)：顯式指定年月日信息
public static LocalDate ofYearDay(int year, int dayOfYear)：根據 dayOfYear 能夠推出 month 和 dayOfMonth
public static LocalDate ofEpochDay(long epochDay)：相對於格林零時區時間的日偏移量
…………

示例

// 取當前日期：
LocalDate today = LocalDate.now(); // -> 2019-01-31
// 根據年月日取日期，12月就是12：
LocalDate crischristmas = LocalDate.of(2018, 12, 25); // -> 2018-12-25
// 根據字符串取：
LocalDate endOfFeb = LocalDate.parse("2018-12-25"); // 嚴格按照ISO yyyy-MM-dd驗證，02寫成2都不行，固然也有一個重載方法容許本身定義格式

// 如何獲取1周後的日期
LocalDate oneToday = today.plus(1, ChronoUnit.WEEKS); // ->2019-02-07
//一年前的日期
LocalDate previousYear = today.minus(1, ChronoUnit.YEARS);
// 取本月第1天：
LocalDate firstDayOfThisMonth = today.with(TemporalAdjusters.firstDayOfMonth()); // 2019-01-01
// 取本月第2天：
LocalDate secondDayOfThisMonth = today.withDayOfMonth(2); // 2019-01-02
// 取本月最後一天，不再用計算是28，29，30仍是31：
LocalDate lastDayOfThisMonth = today.with(TemporalAdjusters.lastDayOfMonth()); // 2019-01-31
// 取下一天：
LocalDate firstDay = lastDayOfThisMonth.plusDays(1); // 變成了2019-02-01
// 取2019年1月第一個週一
LocalDate firstMonday = LocalDate.parse("2019-01-01").with(TemporalAdjusters.firstInMonth(DayOfWeek.MONDAY)); // 2019-01-07

在java8中，可使用MonthDay，該類不包含年份信息，固然還有一個類是YearMonth

LocalDate birthday = LocalDate.of(1990, 10, 12);
MonthDay birthdayMd = MonthDay.of(birthday.getMonth(), birthday.getDayOfMonth());
MonthDay today = MonthDay.from(LocalDate.of(2019, 10, 12)); 
System.out.println(today.equals(birthdayMd));
//結果
true

TemporalAdjuster

可是有些時候咱們要面臨更復雜的時間操做，好比將時間調到下一個工做日，或者是下個月的最後一天，這時候咱們可使用with()方法的另外一個重載方法，它接收一個TemporalAdjuster參數，可使咱們更加靈活的調整日期：

LocalDate date7 = date.with(nextOrSame(DayOfWeek.SUNDAY));      // 返回下一個距離當前時間最近的星期日
LocalDate date9 = date.with(lastInMonth(DayOfWeek.SATURDAY));   // 返回本月最後一個星期六

若是自己API不知足你的需求，你還能夠建立自定義的TemporalAdjuster接口的實現

LocalTime

相似於 LocalDate，LocalTime 專一於時間的處理，它提供小時，分鐘，秒，毫微秒的各類處理

初始化LocalTime實例
public static LocalTime now()：根據系統當前時刻獲取其中的時間部份內容
public static LocalTime of(int hour, int minute)：顯式傳入小時和分鐘來構建一個實例對象
public static LocalTime of(int hour, int minute, int second)：經過傳入時分秒構造實例
public static LocalTime of(int hour, int minute, int second, int nanoOfSecond)：傳入時分秒和毫微秒構建一個實例
public static LocalTime ofSecondOfDay(long secondOfDay)：傳入一個長整型數值表明當前日已通過去的秒數
public static LocalTime ofNanoOfDay(long nanoOfDay)：傳入一個長整型表明當前日已通過去的毫微秒數

示例

//包含毫秒
LocalTime now = LocalTime.now(); // 11:09:09.240
//不包含毫秒  
LocalTime now = LocalTime.now().withNano(0)); // 11:09:09
//構造時間  
LocalTime zero = LocalTime.of(0, 0, 0); // 00:00:00
LocalTime mid = LocalTime.parse("12:00:00"); // 12:00:00
LocalTime twoHour = now.plusHours(2);

LocalDateTime

LocalDateTime類是LocalDate和LocalTime的結合體，能夠經過of()方法直接建立，也能夠調用LocalDate的atTime()方法或LocalTime的atDate()方法將LocalDate或LocalTime合併成一個LocalDateTime

LocalDateTime ldt1 = LocalDateTime.of(2017, Month.JANUARY, 4, 17, 23, 52);

LocalDate localDate = LocalDate.of(2017, Month.JANUARY, 4);
LocalTime localTime = LocalTime.of(17, 23, 52);
LocalDateTime ldt2 = localDate.atTime(localTime);

LocalDateTime也提供用於向LocalDate和LocalTime的轉化：

LocalDate date = ldt1.toLocalDate();
LocalTime time = ldt1.toLocalTime();

Instant

Instant用於表示一個時間戳，它與咱們常使用的System.currentTimeMillis()有些相似，不過Instant能夠精確到納秒（Nano-Second），System.currentTimeMillis()方法只精確到毫秒（Milli-Second）。若是查看Instant源碼，發現它的內部使用了兩個常量，seconds表示從1970-01-01 00:00:00開始到如今的秒數，nanos表示納秒部分（nanos的值不會超過999,999,999）。Instant除了使用now()方法建立外，還能夠經過ofEpochSecond方法建立：

Instant instant = Instant.ofEpochSecond(120, 100000);

時間差

關於時間差的計算，主要涉及到兩個類，年月日的日期間差值的計算使用 Period 類足以，而時分秒毫秒的時間的差值計算則須要使用Duration類。

• Duration：處理兩個時間之間的差值
  • Duration的內部實現與Instant相似，也是包含兩部分：seconds表示秒，nanos表示納秒。二者的區別是Instant用於表示一個時間戳（或者說是一個時間點），而Duration表示一個時間段，因此Duration類中不包含now()靜態方法。能夠經過Duration.between()方法建立

  LocalDateTime from = LocalDateTime.of(2019, Month.JANUARY, 5, 10, 7, 0);    // 2019-01-05 10:07:00
  LocalDateTime to = LocalDateTime.of(2019, Month.FEBRUARY, 5, 10, 7, 0);     // 2019-02-05 10:07:00
  Duration duration = Duration.between(from, to);     // 表示從 2019-01-05 10:07:00 到 2019-02-05 10:07:00 這段時間
  
  long days = duration.toDays();              // 這段時間的總天數
  long hours = duration.toHours();            // 這段時間的小時數
  long minutes = duration.toMinutes();        // 這段時間的分鐘數
  long seconds = duration.getSeconds();       // 這段時間的秒數
  long milliSeconds = duration.toMillis();    // 這段時間的毫秒數
  long nanoSeconds = duration.toNanos();      // 這段時間的納秒數

  Duration對象還能夠經過of()方法建立，該方法接受一個時間段長度，和一個時間單位做爲參數：

  Duration duration1 = Duration.of(5, ChronoUnit.DAYS);       // 5天
  Duration duration2 = Duration.of(1000, ChronoUnit.MILLIS);  // 1000毫秒

• Period：處理兩個日期之間的差值

  • Period在概念上和Duration相似，區別在於Period是以年月日來衡量一個時間段，好比2年3個月6天

    Period period = Period.of(2, 3, 6);

• Period對象也能夠經過between()方法建立，值得注意的是，因爲Period是以年月日衡量時間段，因此between()方法只能接收LocalDate類型的參數：

  Period period = Period.between(
              LocalDate.of(2019, 1, 5),
              LocalDate.of(2019, 2, 5));

• 示例

LocalDate date = LocalDate.of(2019,01,22);
    LocalDate date1 = LocalDate.now();
    Period period = Period.between(date,date1);
    System.out.println(period.getYears() + "年" +
            period.getMonths() + "月" +
            period.getDays() + "天");

    LocalTime time = LocalTime.of(20,30);
    LocalTime time1 = LocalTime.of(23,59);
    Duration duration = Duration.between(time,time1);
    System.out.println(duration.toMinutes() + "分鐘");

ZonedDateTime

不管是咱們的 LocalDate，或是 LocalTime，甚至是 LocalDateTime，它們基本是時區無關的，內部並無存儲時區屬性，而基本用的系統默認時區。每每有些場景之下，缺少必定的靈活性。

ZonedDateTime 能夠被理解爲 LocalDateTime 的外層封裝，它的內部存儲了一個 LocalDateTime 的實例，專門用於普通的日期時間處理。此外，它還定義了 ZoneId 和 ZoneOffset 來描述時區的概念。

ZonedDateTime 和 LocalDateTime 的一個很大的不一樣點在於，後者內部並無存儲時區，因此對於系統的依賴性很強，每每換一個時區可能就會致使程序中的日期時間不一致。
然後者則能夠經過傳入時區的名稱，使用 ZoneId 進行匹配存儲，也能夠經過傳入與零時區的偏移量，使用 ZoneOffset 存儲時區信息。

初始化實例
public static ZonedDateTime now()：系統將以默認時區計算並存儲日期時間信息
public static ZonedDateTime now(ZoneId zone)：指定時區
public static ZonedDateTime of(LocalDate date, LocalTime time, ZoneId zone)：指定日期時間和時區
public static ZonedDateTime of(LocalDateTime localDateTime, ZoneId zone)
public static ZonedDateTime ofInstant(Instant instant, ZoneId zone)：經過時刻和時區構建實例對象
等等

示例

ZonedDateTime zonedDateTime = ZonedDateTime.now();
    System.out.println(zonedDateTime); 
    //->2019-01-31T16:27:23.179+08:00[Asia/Shanghai]

    LocalDateTime localDateTime = LocalDateTime.now();
    ZoneId zoneId = ZoneId.of("America/Los_Angeles");
    ZonedDateTime zonedDateTime1 = ZonedDateTime.of(localDateTime,zoneId);
    System.out.println(zonedDateTime1);
    // ->2019-01-31T16:27:23.179-08:00[America/Los_Angeles]


    Instant instant = Instant.now();
    ZoneId zoneId1 = ZoneId.of("GMT");
    ZonedDateTime zonedDateTime2 = ZonedDateTime.ofInstant(instant,zoneId1);
    System.out.println(zonedDateTime2);
    // ->2019-01-31T08:27:23.183Z[GMT]

• 第一個輸出應使用了當前系統日期和時間以及默認的時區。

• 第二個小例子，LocalDateTime 實例保存了時區無關的當前日期時間信息，也就是這裏的年月日時分秒，接着構建一個 ZonedDateTime 實例並傳入一個美國時區（西七區）。你會發現輸出的日期時間爲西七區的 16 點 27 分。

  像這種關聯了時區的日期時間就很可以解決那種，換時區致使程序中時間錯亂的問題。由於我關聯了時區，不管你程序換到什麼地方運行了，日期+時區 本就已經惟一肯定了某個時刻，就至關於我在存儲某個時刻的時候，說明了這是某某時區的某某時間，即使你換了一個地區，也不至於把這個時間按本身當前的時區進行解析並直接使用。

• 第三個小例子，構建 ZonedDateTime實例的時候，給定一個時刻和一個時區，而這個時刻值就是相對於給定時區的標準時間所通過的毫秒數。

  有關 ZonedDateTime 的其餘日期時間的處理方法和 LocalDateTime 是同樣的，由於 ZonedDateTime 是直接封裝了一個 LocalDateTime 實例對象，因此全部相關日期時間的操做都會間接的調用 LocalDateTime 實例的方法，咱們再也不贅述。

格式化日期時間

Java 8 的新式日期時間 API 中，DateTimeFormatter 做爲格式化日期時間的主要類，它與以前的 DateFormat 類最大的不一樣就在於它是線程安全的,若是須要的話，能夠賦值給一個靜態變量。

DateTimeFormatter類提供了許多預約義的格式器，你也能夠自定義本身想要的格式。固然根據約定，它還有一個parse()方法是用於將字符串轉換成日期的，若是轉換期間出現任何錯誤，它會拋出DateTimeParseException異常。相似的，DateFormatter類也有一個用於格式化日期的format()方法，它出錯的話則會拋出DateTimeException異常

再說一句，「MMM d yyyy」與「MMm dd yyyy」這兩個日期格式也略有不一樣，前者能識別出"Jan 2 2018"與"Jan 14 2018"這兩個串，然後者若是傳進來的是"Jan 2 2018"則會報錯，由於它指望月份處傳進來的是兩個字符。爲了解決這個問題，在天爲個位數的狀況下，你得在前面補0，好比"Jan 2 2018"應該改成"Jan 02 2018"。

public static void main(String[] a){
    DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");
    LocalDateTime localDateTime = LocalDateTime.now();
    System.out.println(formatter.format(localDateTime));

    String str = "2008年08月23日 23:59:59";
    DateTimeFormatter formatter2 = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");
    LocalDateTime localDateTime2 = LocalDateTime.parse(str,formatter2);
    System.out.println(localDateTime2);

}

java8 時間與老版本時間轉換

由於java8以前Date是包含日期和時間的，而LocalDate只包含日期，LocalTime只包含時間，因此與Date在互轉中，勢必會丟失日期或者時間，或者會使用起始時間。若是轉LocalDateTime，那麼就不存在信息偏差。

/Date與Instant的相互轉化
Instant instant  = Instant.now();
Date date = Date.from(instant);
Instant instant2 = date.toInstant();
        
//Date轉爲LocalDateTime
Date date2 = new Date();
LocalDateTime localDateTime2 = LocalDateTime.ofInstant(date2.toInstant(), ZoneId.systemDefault());
        
//LocalDateTime轉Date
LocalDateTime localDateTime3 = LocalDateTime.now();
Instant instant3 = localDateTime3.atZone(ZoneId.systemDefault()).toInstant();
Date date3 = Date.from(instant);

//LocalDate轉Date
//由於LocalDate不包含時間，因此轉Date時，會默認轉爲當天的起始時間，00:00:00
LocalDate localDate4 = LocalDate.now();
Instant instant4 = localDate4.atStartOfDay().atZone(ZoneId.systemDefault()).toInstant();
Date date4 = Date.from(instant);


// Calendar to Instant
Instant time = Calendar.getInstance().toInstant();
System.out.println(time);

// TimeZone to ZoneId
ZoneId defaultZone = TimeZone.getDefault().toZoneId();
System.out.println(defaultZone);
 
// ZonedDateTime from specific Calendar
ZonedDateTime gregorianCalendarDateTime = new GregorianCalendar().toZonedDateTime();
System.out.println(gregorianCalendarDateTime);
 
 
GregorianCalendar gc = GregorianCalendar.from(gregorianCalendarDateTime);
System.out.println(gc);

來源：http://www.javashuo.com/article/p-gwqadnbt-kw.html