Java進階篇之十五 ----- JDK1.8的Lambda、Stre
前言
本篇主要講述是Java中JDK1.8的一些新語法特性使用，主要是Lambda、Stream和LocalDate日期的一些使用講解。
Lambda
Lambda介紹
Lambda 表示式(lambda expression)是一個匿名函式，Lambda表示式基於數學中的λ演算得名，直接對應於其中的lambda抽象(lambda abstraction)，是一個匿名函式，即沒有函式名的函式。
Lambda表示式的結構
一個 Lambda 表示式可以有零個或多個引數
引數的型別既可以明確宣告，也可以根據上下文來推斷。例如：(int a)與(a)效果相同
所有引數需包含在圓括號內，引數之間用逗號相隔。例如：(a, b) 或 (int a, int b) 或 (String a, int b, float c)
空圓括號代表引數集為空。例如：() -> 42
當只有一個引數，且其型別可推導時，圓括號（）可省略。例如：a -> return a*a
Lambda 表示式的主體可包含零條或多條語句
如果 Lambda 表示式的主體只有一條語句，花括號{}可省略。匿名函式的返回型別與該主體表示式一致
如果 Lambda 表示式的主體包含一條以上語句，則表示式必須包含在花括號{}中（形成程式碼塊）。匿名函式的返回型別與程式碼塊的返回型別一致，若沒有返回則為空
Lambda 表示式的使用
下面我們先使用一個簡單的例子來看看Lambda的效果吧。
比如我們對Map 的遍歷
傳統方式遍歷如下:
Map<String, String> map = new HashMap<>(); map.put("a", "a"); map.put("b", "b"); map.put("c", "c"); map.put("d", "d");
System.out.println("map普通方式遍歷:"); for (String key : map.keySet()) {
System.out.println("k=" + key + "，v=" + map.get(key));
}
使用Lambda進行遍歷:
System.out.println("map拉姆達表示式遍歷:"); map.forEach((k, v) -> {
System.out.println("k=" + k + "，v=" + v);
});
List也同理，不過List還可以透過雙冒號運算子遍歷:
List<String> list = new ArrayList<String>(); list.add("a"); list.add("bb"); list.add("ccc"); list.add("dddd");
System.out.println("list拉姆達表示式遍歷:"); list.forEach(v -> {
System.out.println(v);
});
System.out.println("list雙冒號運算子遍歷:"); list.forEach(System.out::println);
輸出結果:
map普通方式遍歷: k=a，v=a k=b，v=b k=c，v=c k=d，v=d map拉姆達表示式遍歷: k=a，v=a k=b，v=b k=c，v=c k=d，v=d list拉姆達表示式遍歷: a bb ccc dddd list雙冒號運算子遍歷: a bb ccc dddd
Lambda除了在for迴圈遍歷中使用外，它還可以代替匿名的內部類。
比如下面這個例子的執行緒建立:
//使用普通的方式建立
Runnable r1 = new Runnable() {
@Override public void run() {
System.out.println("普通方式建立!");
}
};
//使用拉姆達方式建立
Runnable r2 = ()-> System.out.println("拉姆達方式建立!");
注: 這個例子中使用Lambda表示式的時候，編譯器會自動推斷：根據執行緒類的建構函式簽名 Runnable r { }，將該 Lambda 表示式賦Runnable 介面。
Lambda 表示式與匿名類的區別
使用匿名類與 Lambda 表示式的一大區別在於關鍵詞的使用。對於匿名類，關鍵詞 this 解讀為匿名類，而對於 Lambda 表示式，關鍵詞 this 解讀為寫就 Lambda 的外部類。
Lambda表示式使用注意事項
Lambda雖然簡化了程式碼的編寫，但同時也減少了可讀性。
Stream
Stream介紹
Stream 使用一種類似用 SQL 語句從資料庫查詢資料的直觀方式來提供一種對 Java 集合運算和表達的高階抽象。Stream API可以極大提高Java程式設計師的生產力，讓程式設計師寫出高效率、乾淨、簡潔的程式碼。這種風格將要處理的元素集合看作一種流， 流在管道中傳輸， 並且可以在管道的節點上進行處理， 比如篩選， 排序，聚合等。
Stream特性：
不是資料結構： 它沒有內部儲存，它只是用操作管道從 source（資料結構、陣列、generator function、IO channel）抓取資料。它也絕不修改自己所封裝的底層資料結構的資料。例如 Stream 的 filter 操作會產生一個不包含被過濾元素的新 Stream，而不是從 source 刪除那些元素。
不支援索引訪問： 但是很容易生成陣列或者 List 。
惰性化：很多 Stream 操作是向後延遲的，一直到它弄清楚了最後需要多少資料才會開始。Intermediate 操作永遠是惰性化的。
並行能力。當一個 Stream 是並行化的，就不需要再寫多執行緒程式碼，所有對它的操作會自動並行進行的。
可以是無限的：集合有固定大小，Stream 則不必。limit(n) 和 findFirst() 這類的 short-circuiting 操作可以對無限的 Stream 進行運算並很快完成。
注意事項：所有 Stream 的操作必須以 lambda 表示式為引數。
Stream 流操作型別：
Intermediate：一個流可以後面跟隨零個或多個 intermediate 操作。其目的主要是開啟流，做出某種程度的資料對映/過濾，然後返回一個新的流，交給下一個操作使用。 這類操作都是惰性化的（lazy），就是說，僅僅呼叫到這類方法，並沒有真正開始流的遍歷。
Terminal：一個流只能有一個 terminal 操作，當這個操作執行後，流就被使用“光”了，無法再被操作。 所以這必定是流的最後一個操作。 Terminal操作的執行，才會真正開始流的遍歷，並且會生成一個結果，或者一個 side effect。
Stream使用
這裡我們依舊使用一個簡單示例來看看吧。
在開發中，我們有時需要對一些資料進行過濾，如果是傳統的方式，我們需要對這批資料進行遍歷過濾，會顯得比較繁瑣，如果使用steam流方式的話，那麼可以很方便的進行處理。
首先透過普通的方式進行過濾:
List<String> list = Arrays.asList("張三", "李四", "王五", "xuwujing");
System.out.println("過濾之前:" + list); List<String> result = new ArrayList<>(); for (String str : list) { if (!"李四".equals(str)) {
result.add(str);
}
}
System.out.println("過濾之後:" + result);
使用Steam方式進行過濾：
List<String> result2 = list.stream().filter(str -> !"李四".equals(str)).collect(Collectors.toList());
System.out.println("stream 過濾之後:" + result2);
輸出結果:
過濾之前:[張三, 李四, 王五, xuwujing]過濾之後:[張三, 王五, xuwujing]stream 過濾之後:[張三, 王五, xuwujing]
是不是很簡潔和方便呢。
其實Stream流還有更多的使用方法，filter只是其中的一角而已。那麼在這裡我們就來學習瞭解下這些用法吧。
1.構造Stream流的方式
Stream stream = Stream.of("a", "b", "c"); String[] strArray = new String[] { "a", "b", "c" };
stream = Stream.of(strArray);
stream = Arrays.stream(strArray); List<String> list = Arrays.asList(strArray);
stream = list.stream();
2.Stream流的之間的轉換
注意:一個Stream流只可以使用一次，這段程式碼為了簡潔而重複使用了數次，因此會丟擲 stream has already been operated upon or closed 異常。
try {
Stream<String> stream2 = Stream.of("a", "b", "c"); // 轉換成 Array
String[] strArray1 = stream2.toArray(String[]::new); // 轉換成 Collection
List<String> list1 = stream2.collect(Collectors.toList()); List<String> list2 = stream2.collect(Collectors.toCollection(ArrayList::new));
Set set1 = stream2.collect(Collectors.toSet());
Stack stack1 = stream2.collect(Collectors.toCollection(Stack::new)); // 轉換成 String
String str = stream.collect(Collectors.joining()).toString();
} catch (Exception e) {
e.printStackTrace();
}
3.Stream流的map使用
map方法用於對映每個元素到對應的結果，一對一。
示例一：轉換大寫
List<String> list3 = Arrays.asList("zhangSan", "liSi", "wangWu");
System.out.println("轉換之前的資料:" + list3); List<String> list4 = list3.stream().map(String::toUpperCase).collect(Collectors.toList());
System.out.println("轉換之後的資料:" + list4);
// 轉換之後的資料:[ZHANGSAN, LISI,WANGWU]
示例二：轉換資料型別
List<String> list31 = Arrays.asList("1", "2", "3");
System.out.println("轉換之前的資料:" + list31);
List<Integer> list41 = list31.stream().map(Integer::valueOf).collect(Collectors.toList());
System.out.println("轉換之後的資料:" + list41);
// [1, 2, 3]
示例三：獲取平方
List<Integer> list5 = Arrays.asList(new Integer[] { 1, 2, 3, 4, 5 });
List<Integer> list6 = list5.stream().map(n -> n * n).collect(Collectors.toList());
System.out.println("平方的資料:" + list6); // [1, 4, 9, 16, 25]
4.Stream流的filter使用
filter方法用於透過設定的條件過濾出元素。
示例二：透過與 findAny 得到 if/else 的值
List<String> list = Arrays.asList("張三", "李四", "王五", "xuwujing");String result3 = list.stream().filter(str -> "李四".equals(str)).findAny().orElse("找不到!");String result4 = list.stream().filter(str -> "李二".equals(str)).findAny().orElse("找不到!");
System.out.println("stream 過濾之後 2:" + result3);
System.out.println("stream 過濾之後 3:" + result4);//stream 過濾之後 2:李四//stream 過濾之後 3:找不到!
示例三：透過與 mapToInt 計算和
List<User> lists = new ArrayList<User>();
lists.add(new User(6, "張三"));
lists.add(new User(2, "李四"));
lists.add(new User(3, "王五"));
lists.add(new User(1, "張三")); // 計算這個list中出現 "張三" id的值
int sum = lists.stream().filter(u -> "張三".equals(u.getName())).mapToInt(u -> u.getId()).sum();
System.out.println("計算結果:" + sum);
// 7
5.Stream流的flatMap使用
flatMap 方法用於對映每個元素到對應的結果，一對多。
示例:從句子中得到單詞
String worlds = "The way of the future"; List<String> list7 = new ArrayList<>();
list7.add(worlds); List<String> list8 = list7.stream().flatMap(str -> Stream.of(str.split(" ")))
.filter(world -> world.length() > 0).collect(Collectors.toList());
System.out.println("單詞:");
list8.forEach(System.out::println); // 單詞:
// The
// way
// of
// the
// future
6.Stream流的limit使用
limit 方法用於獲取指定數量的流。
示例一：獲取前n條數的資料
Random rd = new Random();
System.out.println("取到的前三條資料:");
rd.ints().limit(3).forEach(System.out::println); // 取到的前三條資料:
// 1167267754
// -1164558977
// 1977868798
示例二：結合skip使用得到需要的資料
skip表示的是扔掉前n個元素。
List<User> list9 = new ArrayList<User>(); for (int i = 1; i < 4; i++) {
User user = new User(i, "pancm" + i);
list9.add(user);
}
System.out.println("擷取之前的資料:"); // 取前3條資料，但是扔掉了前面的2條，可以理解為拿到的資料為 2<=i<3 (i 是數值下標)
List<String> list10 = list9.stream().map(User::getName).limit(3).skip(2).collect(Collectors.toList());
System.out.println("擷取之後的資料:" + list10); // 擷取之前的資料:
// 姓名:pancm1
// 姓名:pancm2
// 姓名:pancm3
// 擷取之後的資料:[pancm3]
注:User實體類中 getName 方法會列印姓名。
7.Stream流的sort使用
sorted方法用於對流進行升序排序。
示例一：隨機取值排序
Random rd2 = new Random();
System.out.println("取到的前三條資料然後進行排序:");
rd2.ints().limit(3).sorted().forEach(System.out::println); // 取到的前三條資料然後進行排序:
// -2043456377
// -1778595703
// 1013369565
示例二：最佳化排序
tips:先獲取在排序效率會更高!
//普通的排序取值
List<User> list11 = list9.stream().sorted((u1, u2) -> u1.getName().compareTo(u2.getName())).limit(3)
.collect(Collectors.toList());
System.out.println("排序之後的資料:" + list11); //最佳化排序取值
List<User> list12 = list9.stream().limit(3).sorted((u1, u2) -> u1.getName().compareTo(u2.getName()))
.collect(Collectors.toList());
System.out.println("最佳化排序之後的資料:" + list12); //排序之後的資料:[{"id":1,"name":"pancm1"}, {"id":2,"name":"pancm2"}, {"id":3,"name":"pancm3"}] //最佳化排序之後的資料:[{"id":1,"name":"pancm1"}, {"id":2,"name":"pancm2"}, {"id":3,"name":"pancm3"}]
8.Stream流的peek使用
peek對每個元素執行操作並返回一個新的Stream
示例:雙重操作
System.out.println("peek使用:"); Stream.of("one", "two", "three", "four").filter(e -> e.length() > 3).peek(e -> System.out.println("轉換之前: " + e)) .map(String::toUpperCase).peek(e -> System.out.println("轉換之後: " + e)).collect(Collectors.toList());
// 轉換之前: three
// 轉換之後: THREE
// 轉換之前: four
// 轉換之後: FOUR
9.Stream流的parallel使用
parallelStream 是流並行處理程式的代替方法。
示例:獲取空字串的數量
List<String> strings = Arrays.asList("a", "", "c", "", "e","", " "); // 獲取空字串的數量
long count = strings.parallelStream().filter(string -> string.isEmpty()).count(); System.out.println("空字串的個數:"+count);
10.Stream流的max/min/distinct使用
示例一：得到最大最小值
List<String> list13 = Arrays.asList("zhangsan","lisi","wangwu","xuwujing"); int maxLines = list13.stream().mapToInt(String::length).max().getAsInt(); int minLines = list13.stream().mapToInt(String::length).min().getAsInt();
System.out.println("最長字元的長度:" + maxLines+",最短字元的長度:"+minLines); //最長字元的長度:8,最短字元的長度:4
示例二：得到去重之後的資料
String lines = "good good study day day up";
List<String> list14 = new ArrayList<String>();
list14.add(lines);
List<String> words = list14.stream().flatMap(line -> Stream.of(line.split(" "))).filter(word -> word.length() > 0)
.map(String::toLowerCase).distinct().sorted().collect(Collectors.toList());
System.out.println("去重複之後:" + words);
//去重複之後:[day, good, study, up]
11.Stream流的Match使用
allMatch：Stream 中全部元素符合則返回 true ;
anyMatch：Stream 中只要有一個元素符合則返回 true;
noneMatch：Stream 中沒有一個元素符合則返回 true。
示例:資料是否符合
boolean all = lists.stream().allMatch(u -> u.getId() > 3);
System.out.println("是否都大於3:" + all); boolean any = lists.stream().anyMatch(u -> u.getId() > 3);
System.out.println("是否有一個大於3:" + any); boolean none = lists.stream().noneMatch(u -> u.getId() > 3);
System.out.println("是否沒有一個大於3的:" + none);
// 是否都大於3:false
// 是否有一個大於3:true
// 是否沒有一個大於3的:false
12.Stream流的reduce使用
reduce 主要作用是把 Stream 元素組合起來進行操作。
示例一：字串連線
String concat = Stream.of("A", "B", "C", "D").reduce("", String::concat);
System.out.println("字串拼接:" + concat);
示例二：得到最小值
double minValue = Stream.of(-4.0, 1.0, 3.0, -2.0).reduce(Double.MAX_VALUE, Double::min); System.out.println("最小值:" + minValue); //最小值:-4.0
示例三：求和
// 求和, 無起始值
int sumValue = Stream.of(1, 2, 3, 4).reduce(Integer::sum).get(); System.out.println("有無起始值求和:" + sumValue); // 求和, 有起始值
sumValue = Stream.of(1, 2, 3, 4).reduce(1, Integer::sum); System.out.println("有起始值求和:" + sumValue); // 有無起始值求和:10
// 有起始值求和:11
示例四：過濾拼接
concat = Stream.of("a", "B", "c", "D", "e", "F").filter(x -> x.compareTo("Z") > 0).reduce("", String::concat);System.out.println("過濾和字串連線:" + concat); //過濾和字串連線:ace
13.Stream流的iterate使用
iterate 跟 reduce 操作很像，接受一個種子值，和一個UnaryOperator（例如 f）。 然後種子值成為 Stream 的第一個元素，f(seed) 為第二個，f(f(seed)) 第三個，以此類推。 在 iterate 時候管道必須有 limit 這樣的操作來限制 Stream 大小。
示例:生成一個等差佇列
System.out.println("從2開始生成一個等差佇列:"); Stream.iterate(2, n -> n + 2).limit(5).forEach(x -> System.out.print(x + " ")); // 從2開始生成一個等差佇列:
// 2 4 6 8 10
14.Stream流的Supplier使用
透過實現Supplier類的方法可以自定義流計算規則。
示例：隨機獲取兩條使用者資訊
System.out.println("自定義一個流進行計算輸出:");
Stream.generate(new UserSupplier()).limit(2).forEach(u -> System.out.println(u.getId() + ", " + u.getName()));
//第一次:
//自定義一個流進行計算輸出:
//10, pancm7
//11, pancm6
//第二次:
//自定義一個流進行計算輸出:
//10, pancm4
//11, pancm2
//第三次:
//自定義一個流進行計算輸出:
//10, pancm4
//11, pancm8class UserSupplier implements Supplier<User> { private int index = 10; private Random random = new Random(); @Override
public User get() { return new User(index++, "pancm" + random.nextInt(10));
}
}
15.Stream流的groupingBy/partitioningBy使用
groupingBy：分組排序；
partitioningBy：分割槽排序。
示例一：分組排序
System.out.println("透過id進行分組排序:");
Map<Integer, List<User>> personGroups = Stream.generate(new UserSupplier2()).limit(5)
.collect(Collectors.groupingBy(User::getId));
Iterator it = personGroups.entrySet().iterator(); while (it.hasNext()) {
Map.Entry<Integer, List<User>> persons = (Map.Entry) it.next();
System.out.println("id " + persons.getKey() + " = " + persons.getValue());
}
// 透過id進行分組排序: // id 10 = [{"id":10,"name":"pancm1"}]
// id 11 = [{"id":11,"name":"pancm3"}, {"id":11,"name":"pancm6"}, {"id":11,"name":"pancm4"}, {"id":11,"name":"pancm7"}]
class UserSupplier2 implements Supplier<User> {
private int index = 10;
private Random random = new Random();
@Override
public User get() { return new User(index % 2 == 0 ? index++ : index, "pancm" + random.nextInt(10));
}
}
示例二：分割槽排序
System.out.println("透過年齡進行分割槽排序:");
Map<Boolean, List<User>> children = Stream.generate(new UserSupplier3()).limit(5)
.collect(Collectors.partitioningBy(p -> p.getId() < 18));
System.out.println("小孩: " + children.get(true));
System.out.println("成年人: " + children.get(false));
// 透過年齡進行分割槽排序: // 小孩: [{"id":16,"name":"pancm7"}, {"id":17,"name":"pancm2"}] // 成年人: [{"id":18,"name":"pancm4"}, {"id":19,"name":"pancm9"}, {"id":20,"name":"pancm6"}] class UserSupplier3 implements Supplier<User> {
private int index = 16;
private Random random = new Random();
@Override
public User get() { return new User(index++, "pancm" + random.nextInt(10));
}
}
16.Stream流的summaryStatistics使用
IntSummaryStatistics 用於收集統計資訊(如count、min、max、sum和average)的狀態物件。
示例:得到最大、最小、之和以及平均數。
List<Integer> numbers = Arrays.asList(1, 5, 7, 3, 9);
IntSummaryStatistics stats = numbers.stream().mapToInt((x) -> x).summaryStatistics();
System.out.println("列表中最大的數 : " + stats.getMax());
System.out.println("列表中最小的數 : " + stats.getMin());
System.out.println("所有數之和 : " + stats.getSum());
System.out.println("平均數 : " + stats.getAverage());
// 列表中最大的數 : 9
// 列表中最小的數 : 1
// 所有數之和 : 25
// 平均數 : 5.0
Stream 介紹就到這裡了，JDK1.8中的Stream流其實還有很多很多用法，更多的用法則需要大家去檢視JDK1.8的API文件了。
LocalDateTime
介紹
JDK1.8除了新增了lambda表示式、stream流之外，它還新增了全新的日期時間API。在JDK1.8之前，Java處理日期、日曆和時間的方式一直為社群所詬病，將 java.util.Date設定為可變型別，以及SimpleDateFormat的非執行緒安全使其應用非常受限。因此推出了java.time包，該包下的所有類都是不可變型別而且執行緒安全。
關鍵類
Instant：瞬時時間。
LocalDate：本地日期，不包含具體時間, 格式 yyyy-MM-dd。
LocalTime：本地時間，不包含日期. 格式 yyyy-MM-dd HH:mm:ss.SSS 。
LocalDateTime：組合了日期和時間，但不包含時差和時區資訊。
ZonedDateTime：最完整的日期時間，包含時區和相對UTC或格林威治的時差。
使用
1.獲取當前的日期時間
透過靜態工廠方法now()來獲取當前時間。
//本地日期,不包括時分秒
LocalDate nowDate = LocalDate.now(); //本地日期,包括時分秒
LocalDateTime nowDateTime = LocalDateTime.now();
System.out.println("當前時間:"+nowDate);
System.out.println("當前時間:"+nowDateTime); // 當前時間:2018-12-19
// 當前時間:2018-12-19T15:24:35.822
2.獲取當前的年月日時分秒
獲取時間之後，直接get獲取年月日時分秒。
//獲取當前的時間，包括毫秒
LocalDateTime ldt = LocalDateTime.now(); System.out.println("當前年:"+ldt.getYear()); //2018
System.out.println("當前年份天數:"+ldt.getDayOfYear());//172
System.out.println("當前月:"+ldt.getMonthValue()); System.out.println("當前時:"+ldt.getHour()); System.out.println("當前分:"+ldt.getMinute()); System.out.println("當前時間:"+ldt.toString()); // 當前年:2018
// 當前年份天數:353
// 當前月:12
// 當前時:15
// 當前分:24
// 當前時間:2018-12-19T15:24:35.833
3.格式化時間
格式時間格式需要用到DateTimeFormatter類。
LocalDateTime ldt = LocalDateTime.now();
System.out.println("格式化時間: "+ ldt.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS")));//格式化時間:2018-12-19 15:37:47.119
4.時間增減
在指定的時間進行增加/減少年月日時分秒。
LocalDateTime ldt = LocalDateTime.now();
System.out.println("後5天時間:"+ldt.plusDays(5));
System.out.println("前5天時間並格式化:"+ldt.minusDays(5).format(DateTimeFormatter.ofPattern("yyyy-MM-dd"))); //2018-06-16
System.out.println("前一個月的時間:"+ldt2.minusMonths(1).format(DateTimeFormatter.ofPattern("yyyyMM"))); //2018-06-16
System.out.println("後一個月的時間:"+ldt2.plusMonths(1)); //2018-06-16
System.out.println("指定2099年的當前時間:"+ldt.withYear(2099)); //2099-06-21T15:07:39.506
// 後5天時間:2018-12-24T15:50:37.508
// 前5天時間並格式化:2018-12-14
// 前一個月的時間:201712
// 後一個月的時間:2018-02-04T09:19:29.499
// 指定2099年的當前時間:2099-12-19T15:50:37.508
5.建立指定時間
透過指定年月日來建立。
LocalDate ld3=LocalDate.of(2017, Month.NOVEMBER, 17); LocalDate ld4=LocalDate.of(2018, 02, 11);
6.時間相差比較
比較相差的年月日時分秒。
示例一: 具體相差的年月日
LocalDate ld=LocalDate.parse("2017-11-17");
LocalDate ld2=LocalDate.parse("2018-01-05");
Period p=Period.between(ld, ld2);
System.out.println("相差年: "+p.getYears()+" 相差月 :"+p.getMonths() +" 相差天:"+p.getDays()); // 相差年: 0 相差月 :1 相差天:19
注:這裡的月份是不滿足一年，天數是不滿足一個月的。這裡實際相差的是1月19天，也就是49天。
示例二：相差總數的時間
ChronoUnit 日期週期單位的標準集合。
LocalDate startDate = LocalDate.of(2017, 11, 17);
LocalDate endDate = LocalDate.of(2018, 01, 05);
System.out.println("相差月份:"+ChronoUnit.MONTHS.between(startDate, endDate));
System.out.println("兩月之間的相差的天數 : " + ChronoUnit.DAYS.between(startDate, endDate));
// 相差月份:1
// 兩天之間的差在天數 : 49
注:ChronoUnit也可以計算相差時分秒。
示例三：精度時間相差
Duration 這個類以秒和納秒為單位建模時間的數量或數量。
Instant inst1 = Instant.now();
System.out.println("當前時間戳 : " + inst1);
Instant inst2 = inst1.plus(Duration.ofSeconds(10));
System.out.println("增加之後的時間 : " + inst2);
System.out.println("相差毫秒 : " + Duration.between(inst1, inst2).toMillis());
System.out.println("相毫秒 : " + Duration.between(inst1, inst2).getSeconds()); // 當前時間戳 : 2018-12-19T08:14:21.675Z
// 增加之後的時間 : 2018-12-19T08:14:31.675Z
// 相差毫秒 : 10000
// 相毫秒 : 10
示例四：時間大小比較
LocalDateTime ldt4 = LocalDateTime.now();
LocalDateTime ldt5 = ldt4.plusMinutes(10);
System.out.println("當前時間是否大於:"+ldt4.isAfter(ldt5));
System.out.println("當前時間是否小於"+ldt4.isBefore(ldt5)); // false
// true
7.時區時間計算
得到其他時區的時間。
示例一:透過Clock時鐘類獲取計算
Clock時鐘類用於獲取當時的時間戳，或當前時區下的日期時間資訊。
Clock clock = Clock.systemUTC();
System.out.println("當前時間戳 : " + clock.millis());
Clock clock2 = Clock.system(ZoneId.of("Asia/Shanghai"));
System.out.println("亞洲上海此時的時間戳:"+clock2.millis());
Clock clock3 = Clock.system(ZoneId.of("America/New_York"));
System.out.println("美國紐約此時的時間戳:"+clock3.millis()); // 當前時間戳 : 1545209277657
// 亞洲上海此時的時間戳:1545209277657
// 美國紐約此時的時間戳:1545209277658
示例二:透過ZonedDateTime類和ZoneId
ZoneId zoneId= ZoneId.of("America/New_York");
ZonedDateTime dateTime=ZonedDateTime.now(zoneId);
System.out.println("美國紐約此時的時間 : " + dateTime.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS")));
System.out.println("美國紐約此時的時間 和時區: " + dateTime); // 美國紐約此時的時間 : 2018-12-19 03:52:22.494
// 美國紐約此時的時間 和時區: 2018-12-19T03:52:22.494-05:00[America/New_York]
Java 8日期時間API總結:
提供了javax.time.ZoneId 獲取時區。
提供了LocalDate和LocalTime類。
Java 8 的所有日期和時間API都是不可變類並且執行緒安全，而現有的Date和Calendar API中的java.util.Date和SimpleDateFormat是非執行緒安全的。
主包是 java.time,包含了表示日期、時間、時間間隔的一些類。裡面有兩個子包java.time.format用於格式化， java.time.temporal用於更底層的操作。
時區代表了地球上某個區域內普遍使用的標準時間。每個時區都有一個代號，格式通常由區域/城市構成（Asia/Tokyo），在加上與格林威治或 UTC的時差。例如：東京的時差是+09:00。
OffsetDateTime類實際上組合了LocalDateTime類和ZoneOffset類。用來表示包含和格林威治或UTC時差的完整日期（年、月、日）和時間（時、分、秒、納秒）資訊。
DateTimeFormatter 類用來格式化和解析時間。與SimpleDateFormat不同，這個類不可變並且執行緒安全，需要時可以給靜態常量賦值。 DateTimeFormatter類提供了大量的內建格式化工具，同時也允許你自定義。在轉換方面也提供了parse()將字串解析成日期，如果解析出錯會丟擲DateTimeParseException。DateTimeFormatter類同時還有format()用來格式化日期，如果出錯會丟擲DateTimeException異常。
再補充一點，日期格式“MMM d yyyy”和“MMM dd yyyy”有一些微妙的不同，第一個格式可以解析“Jan 2 2014”和“Jan 14 2014”，而第二個在解析“Jan 2 2014”就會拋異常，因為第二個格式裡要求日必須是兩位的。如果想修正，你必須在日期只有個位數時在前面補零，就是說“Jan 2 2014”應該寫成 “Jan 02 2014”。
其它
參考:
http://blog.oneapm.com/apm-tech/226.html
https://www.ibm.com/developerworks/cn/java/j-lo-java8streamapi/
來自 “ ITPUB部落格 ” ，連結：http://blog.itpub.net/2318/viewspace-2818930/，如需轉載，請註明出處，否則將追究法律責任。
相關文章
- Java進階篇之十五 ----- JDK1.8的Lambda、Stream和日期的使用詳解(很詳細)JavaJDK
- Linq之Lambda進階
- JDK1.8之lambda表示式JDK
- JDK1.8 之Lambda表示式JDK
- JDK1.8的新特性之Lambda表示式JDK
- Java多執行緒之進階篇Java執行緒
- JDK1.8新特性之Lambda表示式JDK
- JDK1.8新特性之Lambda表示式()->JDK
- jdk1.8 新特性之 lambda表示式JDK
- Java進階篇 設計模式之十四 ----- 總結篇Java設計模式
- JDK1.8之Lambda解析與表示式的使用JDK
- C#進階之全面解析Lambda表示式C#
- Java 從入門到進階之路（二十五）Java
- jdk1.8 新特性之 如何寫lambda表示式JDK
- JDK1.8及以上的Lambda表示式JDK
- JDK1.8 Lambda 表示式的學習JDK
- 長沙Java培訓：Java基礎通往高階進階篇Java
- JDK1.8中Lambda表示式的應用JDK
- JDK1.8新特性--Lambda表示式JDK
- jdk1.8新特性：Lambda表示式JDK
- jdk1.8 lambda表示式入門JDK
- Java進階之詳談ExceptionJavaException
- Android高手進階教程(二十五)之---Android 中的AIDL!!!AndroidAI
- Java之lambda表示式Java
- Membership三步曲之進階篇
- Java進階篇設計模式之七 —– 享元模式和代理模式Java設計模式
- Java進階篇設計模式之七 ----- 享元模式和代理模式Java設計模式
- Java中Lambda表示式的進化之路Java
- JAVA進階之IO模型深入解析Java模型
- Android自我進階——JAVA之JVMAndroidJavaJVM
- java進階之自定義註解Java
- Java進階篇設計模式之十三 ---- 觀察者模式和空物件模式Java設計模式物件
- Java進階篇設計模式之八 ----- 責任鏈模式和命令模式Java設計模式
- Linux ACL 許可權之進階篇Linux
- Asp.Net MVC 系列--進階篇之FilterASP.NETMVCFilter
- [Java學習筆記]JDK1.8新特性學習（一）Lambda表示式Java筆記JDK
- Kotlin——高階篇（一）：Lambda表示式詳解Kotlin
- JDK1.8最新特性--Lambda表示式（重點）JDK