序文
この記事では、主にLambda、Stream、LocalDateの日付の使用について、JavaでのJDK1.8のいくつかの新しい構文機能の使用について説明します。
ラムダ
ラムダ入門
ラムダ式は無名関数です。ラムダ式は数学のλ微積分に基づいて名前が付けられ、ラムダ計算に直接対応します。無名関数、つまり関数名のない関数です。
ラムダ式の構造
ラムダ式は0個以上のパラメーターを持つことができます
パラメータのタイプは、明示的に宣言することも、コンテキストから推測することもできます。例：（int a）は（a）と同じ効果があります
すべてのパラメーターは、コンマで区切って括弧で囲む必要があります。例：（a、b）または（int a、int b）または（String a、int b、float c）
空の括弧は、パラメータセットが空であることを示します。例：（）-> 42
パラメータが1つだけで、そのタイプを推測できる場合は、括弧（）を省略できます。例：a-> return a * a
ラムダ式の本体には、0個以上のステートメントを含めることができます
Lambda式の本体にステートメントが1つしかない場合は、中括弧{}を省略できます。無名関数の戻り値の型はbody式と一致しています
Lambda式の本体に複数のステートメントが含まれている場合、式は中括弧{}で囲む必要があります（コードブロックを形成するため）。無名関数の戻り値の型はコードブロックの戻り値の型と同じです。戻り値がない場合は空です。
ラムダ式の使用
まず、簡単な例を使用して、ラムダの効果を確認しましょう。
たとえば、マップをトラバースする従来の方法は次のとおりです。
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<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
forループトラバーサルで使用されることに加えて、Lambdaは匿名内部クラスを置き換えることもできます。たとえば、次の例のスレッドの作成：
//使用普通的方式创建
Runnable r1 = new Runnable() {
@Override
public void run() {
System.out.println("普通方式创建!");
}
};
//使用拉姆达方式创建
Runnable r2 = ()-> System.out.println("拉姆达方式创建!");
注：この例でLambda式を使用すると、コンパイラーは自動的に次のように推測します。スレッドクラスRunnable r {}のコンストラクター署名に従って、Lambda式をRunnableインターフェースに割り当てます。
Lambda式と匿名クラスの違い匿名クラスとLambda式の使用の大きな違いの1つは、キーワードの使用です。匿名クラスの場合、キーワードthisは匿名クラスとして解釈されますが、Lambda式の場合、キーワードthisはLambdaとして記述された外部クラスとして解釈されます。
ラムダ式を使用する際の注意事項
Lambdaはコードの記述を単純化しますが、読みやすさも低下させます。
ストリーム
ストリーム紹介
Streamは、SQLステートメントを使用してデータベースからデータをクエリするのと同様の直感的な方法を使用して、Javaセットの操作と式の高レベルの抽象化を提供します。Stream APIは、Javaプログラマーの生産性を大幅に向上させ、プログラマーが効率的でクリーンで簡潔なコードを記述できるようにします。このスタイルでは、処理される要素のコレクションを一種のフローと見なします。フローはパイプラインで送信され、フィルタリング、並べ替え、集計など、パイプラインのノードで処理できます。
ストリーム機能：
データ構造ではありません。内部ストレージはなく、操作パイプラインを使用してソース（データ構造、配列、ジェネレーター関数、IOチャネル）からデータをフェッチするだけです。カプセル化する基になるデータ構造のデータを変更することはありません。たとえば、Streamのフィルター操作は、ソースからそれらの要素を削除する代わりに、フィルターされた要素を含まない新しいStreamを生成します。
インデックスアクセスはサポートされていませんが、配列またはリストを生成するのは簡単です。
怠惰：多くのストリーム操作は、最終的に必要なデータ量がわかるまで後方に遅延されます。中間操作は常に怠惰です。
並列能力。ストリームが並列化されている場合、マルチスレッドコードを記述する必要はなく、ストリームに対するすべての操作は自動的に並列で実行されます。
コレクションのサイズは固定されていますが、Streamは固定されていません。limit（n）やfindFirst（）などの短絡操作は、無制限のストリームで操作を実行し、それらを迅速に完了することができます。
注：すべてのStream操作は、ラムダ式をパラメーターとして受け取る必要があります。
ストリーム操作タイプ：
中間：ストリームの後に、0個以上の中間操作を続けることができます。主な目的は、ストリームを開き、ある程度のデータマッピング/フィルタリングを実行してから、次の操作で使用する新しいストリームを返すことです。このタイプの操作は怠惰です。つまり、このタイプのメソッドを呼び出すだけでは、ストリームのトラバーサルは実際には開始されません。
ターミナル：ストリームは1つのターミナル操作のみを持つことができます。この操作が実行されると、ストリームは「ライト」として使用され、操作できなくなります。したがって、これがストリームの最後の操作である必要があります。ターミナル操作を実行すると、実際にストリームのトラバーサルが開始され、結果または副作用が生成されます。
ストリームの使用
ここでも、簡単な例を使用して見ていきます。開発では、一部のデータをフィルタリングする必要がある場合があります。従来の方法では、このデータのバッチをトラバースしてフィルタリングする必要があるため、より面倒です。スチームストリーミング方式を使用すると、簡単に処理できます。
通常の方法による最初のフィルター：
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を使用する方法は他にもあり、フィルターはその1つにすぎません。したがって、ここでは、これらの使用法を理解する方法を学びます。
1.ストリームを構築する方法
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.ストリームストリーム間の変換
注：ストリームは1回しか使用できません。簡潔にするために、このコードは数回再利用されるため、ストリームは既に操作されているか、例外が閉じられています。
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.ストリームのマップ使用
mapメソッドは、各要素を対応する結果に1対1でマップするために使用されます。
例1：大文字に変換する
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]
例2：データ型を変換する
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]
例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.ストリームフローフィルターの使用法
フィルタ方式は、設定された条件で要素を除外するために使用されます。
例2：if / elseの値を取得してfindAny
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:找不到!
例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.ストリームにflatMapを使用する
flatMapメソッドは、各要素を対応する結果に1対多でマップするために使用されます。
例：文から単語を取得する
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.ストリーム制限の使用
limitメソッドは、指定された数のストリームを取得するために使用されます。
例1：最初のn個のデータを取得する
Random rd = new Random();
System.out.println("取到的前三条数据:");
rd.ints().limit(3).forEach(System.out::println);
// 取到的前三条数据:
// 1167267754
// -1164558977
// 1977868798
例2：スキップを使用して必要なデータを取得する
スキップとは、最初の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.ストリームの使用を並べ替える
ソートされたメソッドは、ストリームを昇順でソートするために使用されます。
例1：ランダムな値の並べ替え
Random rd2 = new Random();
System.out.println("取到的前三条数据然后进行排序:");
rd2.ints().limit(3).sorted().forEach(System.out::println);
// 取到的前三条数据然后进行排序:
// -2043456377
// -1778595703
// 1013369565
例2：並べ替えを最適化する
ヒント：最初に入手すると、並べ替えの効率が高くなります。
//普通的排序取值
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.ストリームピークの使用
peekは各要素に対して操作を実行し、新しいストリームを返します
例：二重操作
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.ストリームの並列使用
parallelStreamは、ストリーム並列処理プログラムの代替手段です。
例：空の文字列の数を取得する
List<String> strings = Arrays.asList("a", "", "c", "", "e","", " ");
// 获取空字符串的数量
long count = strings.parallelStream().filter(string -> string.isEmpty()).count();
System.out.println("空字符串的个数:"+count);
10.ストリームの最大/最小/個別使用
例1：最大値と最小値を取得する
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
例2：重複排除後にデータを取得する
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.ストリームへの一致の使用
allMatch：ストリーム内のすべての要素が一致する場合にtrueを返します。
anyMatch：Stream内の1つの要素が一致する限り、trueを返します。
noneMatch：ストリーム内のどの要素も一致しない場合に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.ストリームによる使用量の削減
reduceの主な機能は、Stream要素を組み合わせて操作を実行することです。
例1：文字列の連結
String concat = Stream.of("A", "B", "C", "D").reduce("", String::concat);
System.out.println("字符串拼接:" + concat);
例2：最小値を取得する
double minValue = Stream.of(-4.0, 1.0, 3.0, -2.0).reduce(Double.MAX_VALUE, Double::min);
System.out.println("最小值:" + minValue);
//最小值:-4.0
例3：合計
// 求和, 无起始值
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
例4：フィルタリングとスプライシング
concat = Stream.of("a", "B", "c", "D", "e", "F").filter(x -> x.compareTo("Z") > 0).reduce("", String::concat);
System.out.println("过滤和字符串连接:" + concat);
//过滤和字符串连接:ace
13.ストリームの反復使用
Iterateはreduce操作に似ており、シード値とUnaryOperator（たとえば、f）を受け入れます。次に、シード値がストリームの最初の要素になり、f（seed）が2番目になり、f（f（seed））が3番目になります。繰り返しますが、パイプラインには、ストリームのサイズを制限するための制限などの操作が必要です。
例：算術キューを生成する
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.サプライヤーによるストリームの使用
サプライヤクラスのメソッドを実装することにより、フロー計算ルールをカスタマイズできます。
例：2つのユーザー情報をランダムに取得する
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, pancm8
class 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：パーティションの並べ替え。
例1：グループで並べ替え
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));
}
}
例2：パーティションの並べ替え
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.ストリームのsummaryStatisticsの使用
IntSummaryStatisticsは、統計（カウント、最小、最大、合計、平均など）ステータスオブジェクトを収集するために使用されます。
例：最大、最小、合計、平均を取得します。
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は新しい日付と時刻のAPIも追加しました。JDK1.8より前は、Javaが日付、カレンダー、時刻を処理する方法はコミュニティから批判されていました。変数タイプとしてのjava.util.Dateの設定と、SimpleDateFormatの非スレッドセーフにより、アプリケーションは非常に制限されています。そのため、java.timeパッケージが起動されました。このパッケージのすべてのクラスは不変であり、スレッドセーフです。
キーカテゴリー
瞬間：瞬間時間。
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.現在の年、月、日、時、分、秒を取得します
時刻を取得したら、年、月、日、時、分、秒を直接取得します。
//获取当前的时间，包括毫秒
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.時差比較
年、月、日、時、分、秒を比較します。
例1：差異の特定の年、月、日
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年を満たさず、日数は1か月を満たしません。ここでの実際の違いは1月19日、つまり49日です。
例2：合計時間差
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は、時間、分、秒の差を計算することもできます。
例3：精度の時差
期間このクラスは、時間の量または量を秒およびナノ秒でモデル化します。
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
例4：時間サイズの比較
LocalDateTime ldt4 = LocalDateTime.now();
LocalDateTime ldt5 = ldt4.plusMinutes(10);
System.out.println("当前时间是否大于:"+ldt4.isAfter(ldt5));
System.out.println("当前时间是否小于"+ldt4.isBefore(ldt5));
// false
// true
7.タイムゾーンの時間計算
他のタイムゾーンで時間を取得します。
例1：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
例2：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は不変でスレッドセーフですが、既存の日付とカレンダーのAPIjava.util.DateとSimpleDateFormatはスレッドセーフではありません。
メインパッケージはjava.timeであり、日付、時刻、および時間間隔を表すいくつかのクラスが含まれています。フォーマット用のjava.time.formatと下位レベルの操作用のjava.time.temporalの2つのサブパッケージがあります。
タイムゾーンは、地球上の特定の地域で一般的に使用される標準時間を表します。各タイムゾーンにはコードがあり、形式は通常、地域/都市（アジア/東京）に加えて、グリニッジまたはUTCとの時差で構成されます。例：東京の時差は+09：00です。
OffsetDateTimeクラスは、実際にはLocalDateTimeクラスとZoneOffsetクラスを組み合わせたものです。グリニッジまたはUTCとの時差を含む、完全な日付（年、月、日）および時間（時、分、秒、ナノ秒）の情報を表すために使用されます。
DateTimeFormatterクラスは、時間をフォーマットおよび解析するために使用されます。SimpleDateFormatとは異なり、このクラスは不変でスレッドセーフであり、必要に応じて静的定数を割り当てることができます。DateTimeFormatterクラスには、多くの組み込みの書式設定ツールが用意されていますが、カスタマイズすることもできます。変換に関しては、文字列を日付に解析するためのparse（）も提供されています。解析エラーが発生すると、DateTimeParseExceptionがスローされます。DateTimeFormatterクラスには、日付をフォーマットするためのformat（）もあります。エラーが発生すると、DateTimeExceptionがスローされます。
もう1つ、日付形式「MMMdyyyy」と「MMMddyyyy」には微妙な違いがあります。最初の形式は「2014年1月2日」と「2014年1月14日」を解析でき、2番目の形式は「2014年1月2日」を解析できます。 2番目の形式では日が2桁である必要があるため、例外がスローされます。修正する場合は、1桁しかない日付の前にゼロを追加する必要があります。つまり、「2014年1月2日」は「2014年1月2日」と書く必要があります。
その他
参考記事：
http://blog.oneapm.com/apm-tech/226.html https://www.ibm.com/developerworks/cn/java/j-lo-java8streamapi/ http://www.importnew.com/15637 .html
END
喜欢本文的朋友们，欢迎长按下图关注订阅号成猿之路，收看更多精彩内容！
推荐阅读：
《SpringBoot技术栈搭建个人博客》《推荐几个不错的黑科技网站》《一份从0到1的Java项目实践清单，看这篇就对了！》《2020前端面试：第一波面试题总结(你可能被问过)》《教你如何使用GitHub精准搜索开源项目？》
我知道你 “在看”