1.は、ストリームAPIとは何ですか
Java8は、データベースの操作と操作の同じセットにプログラマを可能にするストリームAPIを提供しました。ストリームAPI Javaプログラマが大幅に効率的で、きれいで、簡単なコードを書くために、プログラマの生産性を向上させることができます。それは、シリアル及びパラレルモードの両方で動作を凝集提供すると同時に、同時実行モデルは/フォークを用いて、マルチコアプロセッサの利点を取ることができるプロセスを加速するために並列に結合し、分割されたタスク。通常、並列コードを書く難しく、エラーが発生しやすいですが、マルチスレッドコードを一行も書かずにストリームAPIを使用して、簡単に高性能な並列プログラムを書くことができます。次のように使用するストリームAPIです。
+--------------------+ +------+ +------+ +---+ +-------+
| stream of elements +-----> |filter+-> |sorted+-> |map+-> |collect|
+--------------------+ +------+ +------+ +---+ +-------+簡単に言うとは、ストリームAPIは非常に効率的なデータ処理フレームワークです。
いくつかの機能の2ストリーム
- 要素は、キューが形成され、オブジェクトの特定のタイプです。Javaの流れの中や要素を格納しませんが、オンデマンド・コンピューティング。
- ソースデータソース。これはセット、アレイ、I / Oチャネル、発電機および発電機などIntStreamであってもよいです
- このようなフィルタ、マップ、削減見つけ、マッチ、ソートなどのSQL文の動作と同様の重合操作。
3.ストリームAPIの使用列子
3.1ストリームカテゴリ
これは、異なるソースからのデータのストリームを作成することができます。Javaのコレクションパッケージコレクション、リスト、これらの新しいクラスのセットがストリーム（）とparallelStream（）メソッド、順次ストリーム（シーケンシャルストリーム）またはこれらの方法による同時ストリーム（並列ストリーム）を作成するため。同時ストリーム（並列ストリーム）は、本明細書端における最初のストリームのシーケンス（シーケンシャルストリーム）を記述するマルチスレッド同時ストリーム（並列ストリーム）して説明するに使用するのに適しています
Arrays.asList("a1", "a2", "a3")
.stream()
.findFirst()
.ifPresent(System.out::println); // a1
1234Listオブジェクトのコールストリーム（）メソッドは、オブジェクトの定期的なストリームを返すことができます。次の例では、我々はまた、ストリームを使用することができますコレクションオブジェクトを作成する必要はありません。
Stream.of("a1", "a2", "a3")
.findFirst()
.ifPresent(System.out::println); // a1
123直接Stream.of（）メソッドは、オブジェクトのセットからのストリーム・オブジェクトを作成することができるであろう
ダブル、長い、int型：オブジェクトの定期的な流れ、8でJAVA IntStreamに加えて、LongStreamは、DoubleStreamこれらのストリームは、このような基本データ型として、処理することができます。例えば：IntStreamの使用範囲（）メソッドは、ループのための伝統的に置き換えることができます
IntStream.range(1, 4)
.forEach(System.out::println);
12など、いくつかの特別なラムダ式を使用することができ、基本的なタイプのストリームは、（プリミティブストリーム）は、主に同じ一般的なオブジェクトストリームタイプ（通常のオブジェクトストリーム）を使用しますが、基本的なタイプは、（プリミティブストリーム）をストリーム：代わりにIntPredicateをIntFunction機能を使用して、代わりに使用しますpredicateA、同時に基本类型流（primitive streams）中可以支持一些聚合方法等、：合計（）、平均（）などが挙げられます。
Arrays.stream(new int[] {1, 2, 3})
.map(n -> 2 * n + 1)
.average()
.ifPresent(System.out::println); // 5.0
1234mapToInt（）、mapToLong（）、mapToDouble（）ルーチンは、ストリームの一般的な目的とエレメンタリストリームタイプとの間のように完了するために）（で、mapToObjベースストリーム型オブジェクト（プリミティブストリーム）のオブジェクト（通常のオブジェクトストリーム）を通って流れることができます相互转换
IntStream.range(1, 4)
.mapToObj(i -> "a" + i)
.forEach(System.out::println);
123次の例では、ストリームが最初INTストリームにマッピングされ、その後、文字列オブジェクトのストリームにマッピングされ倍増します。
Stream.of(1.0, 2.0, 3.0)
.mapToInt(Double::intValue)
.mapToObj(i -> "a" + i)
.forEach(System.out::println);
// a1
// a2
// a3.2ストリームAPIの処理手順
私たちは、ストリームの処理シーケンスを導入するには、以下の列子を使用します。
Stream.of("d2", "a2", "b1", "b3", "c")
.filter(s -> {
System.out.println("filter: " + s);
return true;
});、列子の意志の出力の上に次のを想像してみて。
filter: d2
filter: a2
filter: b1
filter: b3
filter: c私たちは、このコードを実行する場合でも、コンソールは何も出力しません。以下の点では、この現象の理由は、次の発生します。我々は最初のストリーム2人の関連する概念を紹介し、この理由を話す前に、私たちはより良いストリームAPIを理解するのに役立ちます。
最終的な操作と中間操作
ストリームを含む
中间（intermediate operations）と最终（terminal operation）操作の二つの形式。中间操作（intermediate operations）的返回值还是一个stream、チェーンコールにより直列に中間体（中間体動作）を動作させることが可能です。最终操作（terminal operation）只能返回void或者一个非stream的结果。上記の例では：フィルタ、地図、中間操作をソートし、最終操作ますforeachです。その他の操作は、Javaのドキュメントを表示することができますストリームで利用可能です。上記の例はまた、鎖と呼ばれる動作パイプラインフローを呼び出します。方法の操作によってパラメータとしてラムダ式の何らかの形で最もストリーム動作は、インターフェイスの特定の動作を指定し、これらの方法のインタフェースの動作は、実質的に非干渉である（非干渉）とステートレス（ステートレス）。干渉のない（非干渉性）で定義された方法がある：方法は、上記の例のように、基礎となるデータ・ソース・ストリームを、変更されない：ラムダ式はます。myListの要素を追加または削除されていません。いいえ定義された状態（ステートレス）方法：操作を実行は、上記の例のように、ラムダ式は、実行時に発生する可能性があり、外部変数または状態の変化に依存しない、独立していません。
単純な表在これらの発言の上記の概要：戻り値は、操作または中間ストリーム動作のタイプであり、戻り値は、最終的な動作又は非ボイドストリーム型動作です。元のデータを変更しませんストリームAPI。
次のストリームインターフェースである、我々は、値が明らかに最終的な動作である中間動作であるかを決定することができる返します。我々は通常、ソート、フィルタ動作、マップ、別個として使用などの中間動作限界です。
public interface Stream<T> extends BaseStream<T, Stream<T>> {
Stream<T> filter(Predicate<? super T> predicate);
<R> Stream<R> map(Function<? super T, ? extends R> mapper);
IntStream mapToInt(ToIntFunction<? super T> mapper);
LongStream mapToLong(ToLongFunction<? super T> mapper);
DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper);
<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);
IntStream flatMapToInt(Function<? super T, ? extends IntStream> mapper);
LongStream flatMapToLong(Function<? super T, ? extends LongStream> mapper);
DoubleStream flatMapToDouble(Function<? super T, ? extends DoubleStream> mapper);
Stream<T> distinct();
Stream<T> sorted();
Stream<T> sorted(Comparator<? super T> comparator);
Stream<T> peek(Consumer<? super T> action);
Stream<T> limit(long maxSize);
Stream<T> skip(long n);
void forEach(Consumer<? super T> action);
void forEachOrdered(Consumer<? super T> action);
Object[] toArray();
<A> A[] toArray(IntFunction<A[]> generator);
T reduce(T identity, BinaryOperator<T> accumulator);
Optional<T> reduce(BinaryOperator<T> accumulator);
<U> U reduce(U identity,
BiFunction<U, ? super T, U> accumulator,
BinaryOperator<U> combiner);
<R> R collect(Supplier<R> supplier,
BiConsumer<R, ? super T> accumulator,
BiConsumer<R, R> combiner);
<R, A> R collect(Collector<? super T, A, R> collector);
Optional<T> min(Comparator<? super T> comparator);
Optional<T> max(Comparator<? super T> comparator);
long count();
boolean anyMatch(Predicate<? super T> predicate);
boolean allMatch(Predicate<? super T> predicate);
boolean noneMatch(Predicate<? super T> predicate);
Optional<T> findFirst();
Optional<T> findAny();
// Static factories
public static<T> Builder<T> builder() {
return new Streams.StreamBuilderImpl<>();
}
public static<T> Stream<T> empty() {
return StreamSupport.stream(Spliterators.<T>emptySpliterator(), false);
}
public static<T> Stream<T> of(T t) {
return StreamSupport.stream(new Streams.StreamBuilderImpl<>(t), false);
}
@SafeVarargs
@SuppressWarnings("varargs") // Creating a stream from an array is safe
public static<T> Stream<T> of(T... values) {
return Arrays.stream(values);
}
public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f) {
Objects.requireNonNull(f);
final Iterator<T> iterator = new Iterator<T>() {
@SuppressWarnings("unchecked")
T t = (T) Streams.NONE;
@Override
public boolean hasNext() {
return true;
}
@Override
public T next() {
return t = (t == Streams.NONE) ? seed : f.apply(t);
}
};
return StreamSupport.stream(Spliterators.spliteratorUnknownSize(
iterator,
Spliterator.ORDERED | Spliterator.IMMUTABLE), false);
}
public static<T> Stream<T> generate(Supplier<T> s) {
Objects.requireNonNull(s);
return StreamSupport.stream(
new StreamSpliterators.InfiniteSupplyingSpliterator.OfRef<>(Long.MAX_VALUE, s), false);
}
public static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b) {
Objects.requireNonNull(a);
Objects.requireNonNull(b);
@SuppressWarnings("unchecked")
Spliterator<T> split = new Streams.ConcatSpliterator.OfRef<>(
(Spliterator<T>) a.spliterator(), (Spliterator<T>) b.spliterator());
Stream<T> stream = StreamSupport.stream(split, a.isParallel() || b.isParallel());
return stream.onClose(Streams.composedClose(a, b));
}
public interface Builder<T> extends Consumer<T> {
@Override
void accept(T t);
default Builder<T> add(T t) {
accept(t);
return this;
}
Stream<T> build();
}
}上記のオペレーションセンターとベース最終的操作により、我々は、上記の動作列子列子を見て、操作の途中で見つけていないだけで、最終的な動作をします。ここでは、すでに答えを知っている可能性があります。操作中のストリームは、最終的なアクションを実行するためにトリガされます。
ここでは、最終的な操作を加えることの効果を見てです：
Stream.of("d2", "a2", "b1", "b3", "c")
.filter(s -> {
System.out.println("filter: " + s);
return true;
})
.forEach(s -> System.out.println("forEach: " + s));その結果、次の上記のコード出力：
filter: d2
forEach: d2
filter: a2
forEach: a2
filter: b1
forEach: b1
filter: b3
forEach: b3
filter: c
forEach: c私たちは、すぐにではなく、コレクション全体の完了を待って、その後の操作をフィルタリングよりも、次のステップの実行を入力します濾過要素の後にフィルタ操作があります。（地図の操作も同様の動作です）
3.3及び注文実行鎖stereamの効率の関係
Stream.of("d2", "a2", "b1", "b3", "c")
.map(s -> {
System.out.println("map: " + s);
return s.toUpperCase();
})
.filter(s -> {
System.out.println("filter: " + s);
return s.startsWith("A");
})
.forEach(s -> System.out.println("forEach: " + s));上記の調整のフィルタ地図と配列が大幅に効率を向上させるために、マップの実行回数を減らすことができます。
Stream.of("d2", "a2", "b1", "b3", "c")
.sorted((s1, s2) -> {
System.out.printf("sort: %s; %s\n", s1, s2);
return s1.compareTo(s2);
})
.filter(s -> {
System.out.println("filter: " + s);
return s.startsWith("a");
})
.map(s -> {
System.out.println("map: " + s);
return s.toUpperCase();
})
.forEach(s -> System.out.println("forEach: " + s));要素の状態を保存するソート処理のために必要な要素の集合で、特別な中間操作（中間体動作）さソーティング、従ってソートは、ステートフル操作（ステートフル動作）です。
まず、コレクションの入力要素間の多くの組み合わせが存在するので、全体の入力セットにソート操作（操作のセットのすなわち第1レベル）、操作上従ってソート例は8回行われます。
ストリームの効率を向上させる、チェーンの並べ替えの手段によって行うことができます。ソートされた要素の一組のみの入力操作を引き起こし、フィルタ演算のでシーケンシャルフィルタを行うチェーンを変更した後、大幅に大量のデータ場合の効率を向上させることができます。
3.4ストリームの多重化
ときストリームは、ある特性を持っています执行完任何一个最终操作（terminal operation）的时候流就被关闭了
Stream<String> stream =
Stream.of("d2", "a2", "b1", "b3", "c")
.filter(s -> s.startsWith("a"));
stream.anyMatch(s -> true); // ok
stream.noneMatch(s -> true); // exceptionnoneMatchの実施後anyMatchを実行中に同じ流れで次の例外がスローされます。
java.lang.IllegalStateException: stream has already been operated upon or closed
at java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:229)
at java.util.stream.ReferencePipeline.noneMatch(ReferencePipeline.java:459)
at com.winterbe.java8.Streams5.test7(Streams5.java:38)
at com.winterbe.java8.Streams5.main(Streams5.java:28)
12345上記の問題は、各ストリーム鎖最終操作（端末操作）、ストリームAPIはで提供されているために新しい方法を作成することによって再利用を解決することができるstream supplier中間操作ストリームがすでに存在している（中間演算）を構築するためのクラスに基づいて新しいストリーム。
Supplier<Stream<String>> streamSupplier =
() -> Stream.of("d2", "a2", "b1", "b3", "c")
.filter(s -> s.startsWith("a"));
streamSupplier.get().anyMatch(s -> true); // ok
streamSupplier.get().noneMatch(s -> true); // ok
streamSupplier的每个get()方法会构造一个新的stream，我们可以在这个stream上执行期望的最终操作（terminal operation）。いくつかの3.5応用操作
3.5.1収集（コレクション）の操作
リスト、セット、マップ、収集（コレクション）は、それのような、要素が別の形へストリーム変換することができ、最終的な動作が有用です。サプライヤー（初期コンストラクタ）、アキュムレータ（アキュムレータ）、結合器（コンバイナ）、フィニッシャ（ターミネーター）：コレクタが収集四つの異なるオペレーティングコレクタを備え、パラメータとして用います。それは複雑に聞こえるが、良いニュースは、そう、最も一般的な操作のために、複雑な操作のさまざまなを収集するなどのコレクターによって構築されたもののJava 8である、あなたはコレクタクラスを達成するために行く必要はありません。
使用コレクターを簡単にリスト、セット、およびマップオブジェクトを生成することができます。
List<Person> filtered =
persons
.stream()
.filter(p -> p.name.startsWith("P"))
.collect(Collectors.toList());上記のデモからわかるように、リストに変換されたストリームは、設定を変換したい場合は、単にそれにCollectors.toSet（）を使用し、非常に簡単です。
3.5.2 FlatMap操作
我々はすでに知っている：あなたはマップ・メソッドを介して、他のオブジェクトへのオブジェクトのいずれかのストリームに変換することができます。しかし、マップのシーンを使用した方法は一つだけ別の特定のオブジェクトの既存のオブジェクトをマッピング制限があります。オブジェクトは、オブジェクトのさまざまにマッピングすることができるかどうか、またはまだ存在しないオブジェクトにマッピング。これは、目的のflatMapメソッドが表示されています。
FlatMap方法は、ストリーム内の他の要素に別のオブジェクトへのストリームオブジェクトの各要素を変換し、ゼロ、1つまたは複数に、ストリーム内の各オブジェクトを変換することが可能です。ストリームは、変換が含ま後flatMap操作がオブジェクトを返します。"
A列子は以下の通り：
String[] words = new String[]{"Hello","World"};
List<String> a = Arrays.stream(words)
.map(word -> word.split(""))
.flatMap(Arrays::stream)
.distinct()
.collect(toList());
a.forEach(System.out::print);flatMapストリーム型パラメータを受信する方法は、その名前から分かるように、このメソッドの役割は、複数のストリームストリームにマージすることです（私たちの地図を生成し、その後付与されていません）。
3.5.3操作の削減
reduce操作可以将stream中所有元素组合起来得到一个元素、JAVA8は、3つの異なる方法をサポートして減らします。
- 比較ルールによって減らすこと
persons
.stream()
.reduce((p1, p2) -> p1.age > p2.age ? p1 : p2)
.ifPresent(System.out::println);- 受信された第2操作識別値やパラメータなどのバイナリ演算子ACCを減少させる、すべてのユーザーの名前と年齢の流れを減少させることができる。この方法は、新しいユーザを与えるために要約されています。
Person result =
persons
.stream()
.reduce(new Person("", 0), (p1, p2) -> {
p1.age += p2.age;
p1.name += p2.name;
return p1;
});
System.out.format("name=%s; age=%s", result.name, result.age);
// name=MaxPeterPamelaDavid; age=76
1234567891011- 指定された値（同一値）、バイナリ演算子アキュムレータ（BiFunctionアキュムレータ）、メソッドのバイナリ組み合わせ：第三の方法は、3つのパラメータを減少させます。識別子パラメータは厳密に人のタイプに限定されるものではないので、私たちは、ユーザの全体的な年齢を減らす取得するには、このメソッドを使用することができます。
Integer ageSum = persons
.stream()
.reduce(0, (sum, p) -> sum += p.age, (sum1, sum2) -> sum1 + sum2);
System.out.println(ageSum); // 76
12345計算の結果は、デバッグ出力を追加することによって、我々は実行エンジンを何が起こっているかを詳細に理解することができ、76です。
Integer ageSum = persons
.stream()
.reduce(0,
(sum, p) -> {
System.out.format("accumulator: sum=%s; person=%s\n", sum, p);
return sum += p.age;
},
(sum1, sum2) -> {
System.out.format("combiner: sum1=%s; sum2=%s\n", sum1, sum2);
return sum1 + sum2;
});
// accumulator: sum=0; person=Max
// accumulator: sum=18; person=Peter
// accumulator: sum=41; person=Pamela
// accumulator: sum=64; person=David
12345678910111213141516あなたはアキュムレータがすべての仕事をした、デバッグ出力から見ることができ、それは最初の値は、最後のステップでのサイズで、累積増加による次の3ステップ連続合計値で、0の値とユーザーマックスを示します要約年齢は76に増加しました。
上記のデバッグ出力コンバイナはないことに注意が並列上記同一のストリームによって行われます。
Integer ageSum = persons
.parallelStream()
.reduce(0,
(sum, p) -> {
System.out.format("accumulator: sum=%s; person=%s\n", sum, p);
return sum += p.age;
},
(sum1, sum2) -> {
System.out.format("combiner: sum1=%s; sum2=%s\n", sum1, sum2);
return sum1 + sum2;
});
// accumulator: sum=0; person=Pamela
// accumulator: sum=0; person=David
// accumulator: sum=0; person=Max
// accumulator: sum=0; person=Peter
// combiner: sum1=18; sum2=23
// combiner: sum1=23; sum2=12
// combiner: sum1=41; sum2=35
12345678910111213141516171819並列流によって実行以上の動作は、さらに完全に異なるアクションが実行されて得られます。合成方法は、並列ストリームで呼び出されます。アキュムレータが並列に呼び出され、したがって蓄積からの操作を加算合成するための必要性であるためです。
4.パラレルストリーム
多数の入力ストリームがリリースを使用して並列に実行することができる効率を向上させるために。并行流（Parallel Streams）通过ForkJoinPool.commonPool() 方法获取一个可用的ForkJoinPool。这个ForkJoinPool使用5个线程（实际上是由底层可用的物理cpu核数决定的）。
ForkJoinPool commonPool = ForkJoinPool.commonPool();
System.out.println(commonPool.getParallelism()); // 3
On my machine the common pool is initialized with a parallelism of 3 per default. This value can be decreased or increased by setting the following JVM parameter:
123公共のプール3並列の初期化、各デフォルトのための私のマシンでは、この値はJVMパラメータを調整することで変更できます。
-Djava.util.concurrent.ForkJoinPool.common.parallelism=5
1Collections中包含parallelStream()方法，通过这个方法能够为Collections中的元素创建并行流。另外也可以调用stream的parallel()方法将一个顺序流转变为一个并行流的拷贝。
並列ストリームの実装の動作を理解するために、以下の例では、現在の実行スレッドの情報を印刷します。
Arrays.asList("a1", "a2", "b1", "c2", "c1")
.parallelStream()
.filter(s -> {
System.out.format("filter: %s [%s]\n",
s, Thread.currentThread().getName());
return true;
})
.map(s -> {
System.out.format("map: %s [%s]\n",
s, Thread.currentThread().getName());
return s.toUpperCase();
})
.forEach(s -> System.out.format("forEach: %s [%s]\n",
s, Thread.currentThread().getName()));
1234567891011121314次のような結果の実装は以下のとおりです。
filter: b1 [main]
filter: a2 [ForkJoinPool.commonPool-worker-1]
map: a2 [ForkJoinPool.commonPool-worker-1]
filter: c2 [ForkJoinPool.commonPool-worker-3]
map: c2 [ForkJoinPool.commonPool-worker-3]
filter: c1 [ForkJoinPool.commonPool-worker-2]
map: c1 [ForkJoinPool.commonPool-worker-2]
forEach: C2 [ForkJoinPool.commonPool-worker-3]
forEach: A2 [ForkJoinPool.commonPool-worker-1]
map: b1 [main]
forEach: B1 [main]
filter: a1 [ForkJoinPool.commonPool-worker-3]
map: a1 [ForkJoinPool.commonPool-worker-3]
forEach: A1 [ForkJoinPool.commonPool-worker-3]
forEach: C1 [ForkJoinPool.commonPool-worker-2]
123456789101112131415デバッグ出力を分析することにより、私たちはより良い操作をストリーム何何のスレッドが実行を理解することができます。上記の出力から、我々は、並列ストリームはForkJoinPoolは、様々な操作が流れる実行するために提供されたすべての利用可能なスレッドを使用して見ることができます。並流内のどのスレッドどの行う操作を判断しないので、上記のコードが繰り返し実行されるので、印刷結果が異なることになります。
例えば上記拡張、追加ソート操作
Arrays.asList("a1", "a2", "b1", "c2", "c1")
.parallelStream()
.filter(s -> {
System.out.format("filter: %s [%s]\n",
s, Thread.currentThread().getName());
return true;
})
.map(s -> {
System.out.format("map: %s [%s]\n",
s, Thread.currentThread().getName());
return s.toUpperCase();
})
.sorted((s1, s2) -> {
System.out.format("sort: %s <> %s [%s]\n",
s1, s2, Thread.currentThread().getName());
return s1.compareTo(s2);
})
.forEach(s -> System.out.format("forEach: %s [%s]\n",
s, Thread.currentThread().getName()));
12345678910111213141516171819次のように実行結果は以下のとおりです。
filter: c2 [ForkJoinPool.commonPool-worker-3]
filter: c1 [ForkJoinPool.commonPool-worker-2]
map: c1 [ForkJoinPool.commonPool-worker-2]
filter: a2 [ForkJoinPool.commonPool-worker-1]
map: a2 [ForkJoinPool.commonPool-worker-1]
filter: b1 [main]
map: b1 [main]
filter: a1 [ForkJoinPool.commonPool-worker-2]
map: a1 [ForkJoinPool.commonPool-worker-2]
map: c2 [ForkJoinPool.commonPool-worker-3]
sort: A2 <> A1 [main]
sort: B1 <> A2 [main]
sort: C2 <> B1 [main]
sort: C1 <> C2 [main]
sort: C1 <> B1 [main]
sort: C1 <> C2 [main]
forEach: A1 [ForkJoinPool.commonPool-worker-1]
forEach: C2 [ForkJoinPool.commonPool-worker-3]
forEach: B1 [main]
forEach: A2 [ForkJoinPool.commonPool-worker-2]
forEach: C1 [ForkJoinPool.commonPool-worker-1]
123456789101112131415161718192021実装のルックスではなく奇妙なルックスのソート操作の結果は、ちょうどメインスレッドで順次実行します。実際、JAVA 8の新たな方法を用いて並列ストリーム内のソート操作：Arrays.parallelSort（）。JAVAドキュメントはArrays.parallelSort（）に記述される配列の長さは、順次又は並行して実行されるソート処理を決定するためにソートします。次のようにJavaのドキュメントを記述しました：
If the length of the specified array is less than the minimum granularity, then it is sorted using the appropriate Arrays.sort method.
1戻る前の章の例に、我々はすでに、合成方法のみ並列ストリームに呼び出すことができます知っている、実際に呼び出され、私たちはそれらのスレッドを見てみましょう：
List<Person> persons = Arrays.asList(
new Person("Max", 18),
new Person("Peter", 23),
new Person("Pamela", 23),
new Person("David", 12));
persons
.parallelStream()
.reduce(0,
(sum, p) -> {
System.out.format("accumulator: sum=%s; person=%s [%s]\n",
sum, p, Thread.currentThread().getName());
return sum += p.age;
},
(sum1, sum2) -> {
System.out.format("combiner: sum1=%s; sum2=%s [%s]\n",
sum1, sum2, Thread.currentThread().getName());
return sum1 + sum2;
});
12345678910111213141516171819次のように実行結果は以下のとおりです。
accumulator: sum=0; person=Pamela; [main]
accumulator: sum=0; person=Max; [ForkJoinPool.commonPool-worker-3]
accumulator: sum=0; person=David; [ForkJoinPool.commonPool-worker-2]
accumulator: sum=0; person=Peter; [ForkJoinPool.commonPool-worker-1]
combiner: sum1=18; sum2=23; [ForkJoinPool.commonPool-worker-1]
combiner: sum1=23; sum2=12; [ForkJoinPool.commonPool-worker-2]
combiner: sum1=41; sum2=35; [ForkJoinPool.commonPool-worker-2]
1234567コンソール出力コンバイナアキュムレータから見ることができ、操作が並列スレッドで実行されているが利用可能です。
要約すると：データ入力のときに大量に、パラレル・ストリームは、大きなパフォーマンスの向上をもたらすことができます。これは、しかし、等並列数、忘れてはならない：減らす、必要な収集追加の計算（合成動作）が、流れの順に、これらの動作の組み合わせが必要とされません。
加えて、我々はそれを知っている所有的parallel stream操作共享一个jvm范围内的ForkJoinPoolあなたは、並列ストリームの遅いストリーム操作の実装をブロックしないように注意しなければならないので、これらの操作は、アプリケーションの他の部分につながる可能性があるため、応答が遅いの操作になります並列ストリームに依存しています。
5.詳細な列子
package com.csx.demo.spring.boot.lambda;
import java.util.*;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.ForkJoinPool;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import static java.util.stream.Collectors.*;
public class LambdaStreamDemo {
public static void main(String[] args) {
List<Person> javaProgrammers = new ArrayList<Person>() {
{
add(new Person("Elsdon", "Jaycob", "Java programmer", "male", 43, 2000));
add(new Person("Tamsen", "Brittany", "Java programmer", "female", 23, 1500));
add(new Person("Floyd", "Donny", "Java programmer", "male", 33, 1800));
add(new Person("Sindy", "Jonie", "Java programmer", "female", 32, 1600));
add(new Person("Vere", "Hervey", "Java programmer", "male", 22, 1200));
add(new Person("Maude", "Jaimie", "Java programmer", "female", 27, 1900));
add(new Person("Shawn", "Randall", "Java programmer", "male", 30, 2300));
add(new Person("Jayden", "Corrina", "Java programmer", "female", 35, 1700));
add(new Person("Palmer", "Dene", "Java programmer", "male", 33, 2000));
add(new Person("Addison", "Pam", "Java programmer", "female", 34, 1300));
}
};
List<Person> phpProgrammers = new ArrayList<Person>() {
{
add(new Person("Jarrod", "Pace", "PHP programmer", "male", 34, 1550));
add(new Person("Clarette", "Cicely", "PHP programmer", "female", 23, 1200));
add(new Person("Victor", "Channing", "PHP programmer", "male", 32, 1600));
add(new Person("Tori", "Sheryl", "PHP programmer", "female", 21, 1000));
add(new Person("Osborne", "Shad", "PHP programmer", "male", 32, 1100));
add(new Person("Rosalind", "Layla", "PHP programmer", "female", 25, 1300));
add(new Person("Fraser", "Hewie", "PHP programmer", "male", 36, 1100));
add(new Person("Quinn", "Tamara", "PHP programmer", "female", 21, 1000));
add(new Person("Alvin", "Lance", "PHP programmer", "male", 38, 1600));
add(new Person("Evonne", "Shari", "PHP programmer", "female", 40, 1800));
}
};
//----------------------forEach使用----------------------
//所有程序员的姓名
//forEach方法接收一个Consumer参数，来遍历处理每个对象
System.out.println("---------------------forEach使用--------------------------");
System.out.println("java programmer:");
javaProgrammers.forEach((person) -> {
System.out.println(person.getFirstName() + "." + person.getLastName());
});
System.out.println("php programmer:");
phpProgrammers.forEach((person) -> {
System.out.println(person.getFirstName() + "." + person.getLastName());
});
//给所有程序员的薪水上涨5%
System.out.println("给程序员加薪 5% :");
Consumer<Person> giveRaise = e -> e.setSalary(e.getSalary() / 100 * 5 + e.getSalary());
javaProgrammers.forEach(giveRaise);
phpProgrammers.forEach(giveRaise);
//-----------------------filter使用---------------------
//过滤器的使用
//显示月薪超所1400美元的php程序员
System.out.println("---------------------filter使用--------------------------");
System.out.println("显示月薪超过1400的php程序员:");
phpProgrammers.stream()
.filter(p -> p.getSalary() > 1400)
.forEach(person -> System.out.println(person.getFirstName() + "." + person.getLastName()));
//定义filters,这些定义的Filter可以重用
Predicate<Person> ageFilter = (p) -> (p.getAge() > 25);
Predicate<Person> salaryFilter = (p) -> (p.getSalary() > 1400);
Predicate<Person> genderFilter = (p) -> ("female".equals(p.getGender()));
System.out.println("下面是年龄大于24岁且月薪在$1,400以上的女PHP程序员:");
phpProgrammers.stream()
.filter(ageFilter)
.filter(salaryFilter)
.filter(genderFilter)
.forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName()));
//重用filters
System.out.println("下面是年龄大于24岁的女性 Java programmers:");
javaProgrammers.stream()
.filter(ageFilter)
.filter(genderFilter)
.forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName()));
//-----------------------------map的使用---------------------------------
System.out.println("---------------------map的使用--------------------------");
System.out.println("将 PHP programmers 的 first name 拼接成字符串:");
String phpDevelopers = phpProgrammers
.stream()
.map(Person::getFirstName)
.collect(joining(" ; "));
System.out.println("将 Java programmers 的 first name 存放到 Set:");
Set<String> javaDevFirstName = javaProgrammers
.stream()
.map(Person::getFirstName)
.collect(toSet());
System.out.println("将 Java programmers 的 first name 存放到 TreeSet:");
TreeSet<String> javaDevLastName = javaProgrammers
.stream()
.map(Person::getLastName)
.collect(toCollection(TreeSet::new));
//------------------------------limit使用--------------------------------------
System.out.println("---------------------limit使用使用--------------------------");
System.out.println("最前面的3个Java programmers:");
javaProgrammers.stream()
.limit(3)
.forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName()));
System.out.println("最前面的3个女性 Java programmers:");
javaProgrammers.stream()
.filter(genderFilter)
.limit(3)
.forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName()));
//------------------------------sort排序使用---------------------------------------
System.out.println("---------------------sort排序使用--------------------------");
System.out.println("根据name排序,并显示前5个 Java programmers:");
List<Person> sortedJavaProgrammers = javaProgrammers
.stream()
.sorted(Comparator.comparing(Person::getFirstName))
.limit(5)
.collect(toList());
sortedJavaProgrammers.forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName()));
//------------------------------max和min方法的使用-------------------------------
System.out.println("---------------------max和min方法使用--------------------------");
System.out.println("工资最低的 Java programmer:");
Person pears = javaProgrammers
.stream()
.min(Comparator.comparingInt(Person::getSalary))
.get();
System.out.printf("Name: %s %s; Salary: $%,d.", pears.getFirstName(), pears.getLastName(), pears.getSalary());
System.out.println("工资最高的 Java programmer:");
Person person = javaProgrammers
.stream()
.max(Comparator.comparingInt(Person::getSalary))
.get();
System.out.printf("Name: %s %s; Salary: $%,d.", person.getFirstName(), person.getLastName(), person.getSalary());
//-------------------------Stream的一些高级用法------------------------
System.out.println("---------------------Stream的一些高级用法--------------------");
System.out.println("---------------------Collect的用法--------------------");
System.out.println("---------------------将Stream转为List--------------------");
List<Person> list = javaProgrammers.stream()
.filter(p -> p.getSalary() > 1000)
.collect(Collectors.toList());
System.out.println("---------------------将Stream转为Set--------------------");
Set<Person> set = javaProgrammers.stream()
.filter(p -> p.getSalary() > 1000)
.collect(Collectors.toSet());
System.out.println("---------------------将Stream转为(线程非安全)Map--------------------");
System.out.println("---------------------将Java程序员按照性别不同分组--------------------");
Map<String, List<Person>> listMap = javaProgrammers.stream()
.filter(p -> p.getSalary() > 1000)
.collect(groupingBy(Person::getGender));
System.out.println("---------------------将Stream转为(线程安全)Map--------------------");
System.out.println("---------------------将Java程序员按照性别不同分组--------------------");
ConcurrentMap<String, List<Person>> listConcurrentMap = javaProgrammers.stream()
.filter(p -> p.getSalary() > 1000)
.collect(groupingByConcurrent(Person::getGender));
//将一个stream转换为map，我们必须指定map的key和value如何映射。要注意的是key的值必须是唯一性的，
// 否则会抛出IllegalStateException，但是可以通过使用合并函数（可选）绕过这个IllegalStateException异常：
//将age作为key，firstName作为value，如果遇到age相同，则将两个age相同的Person的FirstName相加作为Value
Map<Integer, String> integerStringMap = javaProgrammers.stream()
.collect(toMap(
p -> p.getAge(),
p -> p.getFirstName(),
(value1, value2) -> value1 + value2
));
System.out.println("--------------------计算平均值--------------------");
Double avAge = javaProgrammers.stream()
.collect(averagingInt(p -> p.getAge()));
System.out.println("java程序员平均年龄:"+avAge);
System.out.println("--------------------获取Java程序员age的统计信息--------------------");
System.out.println("-------------包括年龄最大值，最小值和平均值等----------------");
IntSummaryStatistics collect = javaProgrammers.stream()
.collect(summarizingInt(p -> p.getAge()));
System.out.println("--------------------获取Java程序员的FirstName进行拼接--------------------");
String s = javaProgrammers.stream()
.map(p -> p.getFirstName())
.collect(joining("and", "preFix", "endFix"));
//也可以通过Collector.of()方法创建了一个自定义的collector，我们必须给这个collector提供四种功能：
// supplier, accumulator, combiner,finisher.
System.out.println("-------------------可以自定义collector--------------------");
//-------------------flatMap的使用----------------------
System.out.println("-------------------flatMap的使用----------------------");
String[] words = new String[]{"Hello","World"};
List<String> a = Arrays.stream(words)
.map(word -> word.split(""))
.flatMap(Arrays::stream)
.distinct()
.collect(toList());
a.forEach(System.out::print);
//------------------reduce的使用-----------------
System.out.println("-------------------reduce的使用----------------------");
javaProgrammers.stream()
.reduce((p1,p2)->p1.getAge()>p2.getAge()?p1:p2)
.ifPresent(System.out::println);
//这个方法直接返回的是Person,将所有Java程序员的年龄相加起来，在set到传进去的Person中
Person reduce = javaProgrammers.stream()
.reduce(new Person("", "", "", "", 10, 0), (p1, p2) -> {
p1.setAge(p1.getAge() + p2.getAge());
p1.setFirstName(p1.getFirstName() + p2.getFirstName());
return p1;
});
System.out.println(reduce);
//这个方法返回一个标量值,注意，这种方式中第三个参数是不会被执行的，只有当并行模式下，第三个参数才会被执行
Integer ageSum = javaProgrammers
.stream()
.reduce(0,
(sum, p) -> {
System.out.format("accumulator: sum=%s; person=%s\n", sum, p.getFirstName());
return sum += p.getAge();
},
(sum1, sum2) -> {
System.out.format("combiner: sum1=%s; sum2=%s\n", sum1, sum2);
return sum1 + sum2;
});
System.out.println(ageSum);
//--------------------------------Streams 还可以是并行的(parallel)-------------
ForkJoinPool commonPool = ForkJoinPool.commonPool();
System.out.println(commonPool.getParallelism());
}
}6. Aの簡単な概要
- 缶（リスト、セット、および地図など）は、ストリームストリームの方法になり、ストリームコレクションオブジェクトStream.of方法によって得ることができる、あなたはまた、IntStream.rangeストリーム方式によって得ることができます。
- ストリームは、APIオリジナルデータを変更しない、動作の中間および最終動作、中間操作戻りストリーム、ストリーム最終操作のみ最終の中間オペレーションをトリガする操作を実行するために、シャットダウンするにストリーム動作
- 適切な調整は、実行順序の効率を向上させることができます
- サプライヤーは、ストリームを多重化することができます。
7.参考
https://blog.csdn.net/m0_37556444/article/details/84975355
https://ifeve.com/stream/