ストリーム流API

Java8で最も重要な変更点のうちの2つを持っています。最初は、ラムダ式であり、他は、ストリームAPIです。

ストリームAPI（java.util.stream）Javaへの導入リアル関数型プログラミングのスタイル。ストリームAPI Javaプログラマが大幅に効率的で、きれいで、簡単なコードを書くために、プログラマの生産性を向上させることができますので、これは、Javaクラスライブラリをはるかに最高の補数です。

ストリーム処理がJava8コレクション抽象化の鍵である、あなたはそれが一連​​の操作は、非常に複雑な検索を行ってフィルタリングし、マッピングデータやその他の操作が可能になりたいことを指定することができます。使用ストリームAPIは、SQLデータベースクエリの実行を使用するのと同様のデータ収集を、操作します。ストリームAPIは、並行して操作を実行するために使用することができます。簡単に言うとは、ストリームAPIは、データの処理を効率的かつ簡単に使用する方法を提供します。

ストリームは、データチャネル、生成されたデータ・ソース（セット、アレイ、等）の動作のための要素のシーケンスです。「データを格納するための責任データの収集、について話す、ストリームフロー計算が話している、データを処理するための責任があります！」

注意：

彼は要素を格納しません①Stream。

②Streamは、ソースオブジェクトを変更しません。たびに新しい処理は、ストリームが結果を保持して返します。

③Stream操作は実行を遅らせています。これは、彼らが結果が実行されなければならないまで待つ必要があることを意味します。

④各ストリームオブジェクトは一度だけ使用することができます

ストリーム操作三つのステップ：

ストリームを得る：（コレクション、アレイのような）データソースによって：ストリームを作成し、1-

2-中間動作は中間動作は、n回データソースプロセスのデータ操作の鎖であるが、動作の終了前に、実際に実行されません。

3-終了操作：終了操作が実行されると、操作は最終結果を生成するために、中間鎖を実行し、ストリームを終了します。

 

ストリームを作成します

ストリームの方法を作成します。1.コレクションを

Java8 Collectionインタフェースは、2つのストリームを得る方法を提供するように拡張されます。

• 公共デフォルトストリーム<E>ストリームは、（）：順次ストリームを返します。

• 公共デフォルトストリーム<E> parallelStreamは（）：パラレルストリームを返します。

ストリームの道を作成します。2.：アレイを介し

静的メソッドのアレイはJava8（）はストリームの配列があってもよい取得ストリーム：

• パブリック静的<T>ストリーム<T>ストリーム（T []配列）：戻りストリーム

基本的なタイプに対応する配列を扱うことができるオーバーロード：

• パブリック静的IntStreamストリーム（INT []配列）：返す整数データ・ストリーム

• パブリック静的LongStreamストリーム（長い[]配列）：長いデータストリームを返します

• パブリック静的DoubleStreamストリーム（ダブル[]配列）：戻る浮動小数点データ・ストリーム

3.ストリーム三つの方法を作成します。ストリームの（の経由）

ストリームクラスストリームの値を表示することにより作成した（）の静的メソッドを呼び出すことができます。これは、任意の数のパラメータを受け取ることができます。

• パブリック静的<T>ストリーム<T>（T ...値）の戻り値：順次ストリーム

ストリームつの方法を作成します。4.：無制限のストリームを作成します。

あなたは、静的メソッドStream.iterateを（使用）とStream.generate（）、無限のストリームを作成することができます。

• パブリック静的<T>ストリーム<T>の反復（最終T種子、最終UnaryOperator <T> F）：戻り無限ストリーム

• パブリック静的<T>ストリーム<T>を生成（サプライヤー<T> sが）：無限のストリームを返します。

import java.util.Arrays;
import java.util.List;
import java.util.stream.IntStream;
import java.util.stream.Stream;

import org.junit.Test;

public class Test07StreamCreate {
	@Test
	public void test06(){
		/*
		 * Stream<T> iterate(T seed, UnaryOperator<T> f)  
		 * UnaryOperator接口，SAM接口，抽象方法：
		 * 
		 * UnaryOperator<T> extends Function<T,T>
		 * 		T apply(T t)
		 */
		Stream<Integer> stream = Stream.iterate(1, num -> num+=2);
//		stream = stream.limit(10);
		stream.forEach(System.out::println);
	}
	
	@Test
	public void test05(){
		Stream<Double> stream = Stream.generate(Math::random);
		stream.forEach(System.out::println);
	}
	
	@Test
	public void test04(){
		Stream<Integer> stream = Stream.of(1,2,3,4,5);
		stream.forEach(System.out::println);
	}
	
	@Test
	public void test03(){
		String[] arr = {"hello","world"};
		Stream<String> stream = Arrays.stream(arr);
	}
	
	@Test
	public void test02(){
		int[] arr = {1,2,3,4,5};
		IntStream stream = Arrays.stream(arr);
	}
	
	@Test
	public void test01(){
		List<Integer> list = Arrays.asList(1,2,3,4,5);
		
		//JDK1.8中，Collection系列集合增加了方法
		Stream<Integer> stream = list.stream();
	}
}

 

中級操作

そうでなければ操作は、任意の処理を実行しないように、中間の操作複数のパイプライン動作は、終了トリガしない限り、パイプラインを形成するように接合されてもよいです！すべてを一度と呼ばれる終了処理操作、「遅延評価。」

方法	描 述
フィルタ（述語P）	ラムダを受け、ストリームから特定の要素を除外
別個の（）	スクリーニング、要素によって発生した流れに等しい（）要素の重複排除
リミット（ロングmaxSizeの）	流れはそうそれ以上の要素の所定数よりも、切断しません
（長いn）をスキップ	要素をスキップし、戻り流は、最初のn個の要素を投げます。フローは、要素の数n、空ストリーム未満である場合。相補の限界（N）
PEEK（消費者 行動）	ラムダを受信し、各データは、対流操作部材ラムダで行われます
ソート（）	新しいストリームを生成し、前記自然順ソート
ソート（コンパレータCOM）	コンパレータが順序を並べ替えており、新しいフローを生成します
マップ（関数f）	パラメータとして受信機能、関数は、各要素に適用され、新しい要素にそれをマップします。
mapToDouble（ToDoubleFunctionのF）	パラメータとして受信機能、機能は新しいDoubleStreamを生成するために、各要素に適用されます。
mapToInt（ToIntFunctionのF）	パラメータとして受信機能、機能は新しいIntStreamを生成するために、各要素に適用されます。
mapToLong（ToLongFunctionのF）	パラメータとして受信機能、機能は新しいLongStreamを生成するために、各要素に適用されます。
flatMap（関数f）	パラメータとして受信機能、各ストリームの値を別のストリームに置き換えられ、その後、全て一つのストリームに接続されたフロー

 

mport java.util.Arrays;
import java.util.stream.Stream;

import org.junit.Test;

public class Test08StreamMiddle {
	
	@Test
	public void test12(){
		String[] arr = {"hello","world","java"};
		Arrays.stream(arr)
			.flatMap(t -> Stream.of(t.split("|")))//Function<T,R>接口抽象方法 R apply(T t)  现在的R是一个Stream
			.forEach(System.out::println);
	}
	
	
	@Test
	public void test11(){
		String[] arr = {"hello","world","java"};
		
		Arrays.stream(arr)
			.map(t->t.toUpperCase())
			.forEach(System.out::println);
	}
	
	@Test
	public void test10(){
		Stream.of(1,2,3,4,5)
			.map(t -> t+=1)//Function<T,R>接口抽象方法 R apply(T t)
			.forEach(System.out::println);
	}
	
	@Test
	public void test09(){
		//希望能够找出前三个最大值，前三名最大的，不重复
		Stream.of(11,2,39,4,54,6,2,22,3,3,4,54,54)
			.distinct()
			.sorted((t1,t2) -> -Integer.compare(t1, t2))//Comparator接口  int compare(T t1, T t2)
			.limit(3)
			.forEach(System.out::println);
	}
	
	@Test
	public void test08(){
		long count = Stream.of(1,2,3,4,5,6,2,2,3,3,4,4,5)
			.distinct()
			.peek(System.out::println)  //Consumer接口的抽象方法  void accept(T t)
			.count();
		System.out.println("count="+count);
	}
	
	
	@Test
	public void test07(){
		Stream.of(1,2,3,4,5,6,2,2,3,3,4,4,5)
			.skip(5)
			.distinct()
			.filter(t -> t%3==0)
			.forEach(System.out::println);
	}

	@Test
	public void test06(){
		Stream.of(1,2,3,4,5,6,2,2,3,3,4,4,5)
			.skip(5)
			.forEach(System.out::println);
	}
	
	@Test
	public void test05(){
		Stream.of(1,2,2,3,3,4,4,5,2,3,4,5,6,7)
			.distinct()  //(1,2,3,4,5,6,7)
			.filter(t -> t%2!=0) //(1,3,5,7)
			.limit(3)
			.forEach(System.out::println);
	}
	
	
	@Test
	public void test04(){
		Stream.of(1,2,3,4,5,6,2,2,3,3,4,4,5)
			.limit(3)
			.forEach(System.out::println);
	}
	
	
	@Test
	public void test03(){
		Stream.of(1,2,3,4,5,6,2,2,3,3,4,4,5)
			.distinct()
			.forEach(System.out::println);
	}
	
	
	@Test
	public void test02(){
		Stream.of(1,2,3,4,5,6)
			.filter(t -> t%2==0)
			.forEach(System.out::println);
	}
	
	@Test
	public void test01(){
		//1、创建Stream
		Stream<Integer> stream = Stream.of(1,2,3,4,5,6);
		
		//2、加工处理
		//过滤：filter(Predicate p)
		//把里面的偶数拿出来
		/*
		 * filter(Predicate p)
		 * Predicate是函数式接口，抽象方法：boolean test(T t)
		 */
		stream = stream.filter(t -> t%2==0);
		
		//3、终结操作：例如：遍历
		stream.forEach(System.out::println);
	}
}

操作の終了

ターミナルは、パイプラインの流れからの結果を生成します。結果は、任意の値にすることができ、たとえば、ストリームではない：リスト、整数、あるいは無効。動作フローの終了後、再度使用することはありません。

方法	説明
ブール allMatch（述語p）	すべての要素が一致していることを確認します
ブール anyMatch（述語p）	試合に少なくとも1つの元素をチェック
ブール noneMatch（述語p）	すべての要素の一致がないか確認してください
オプション<T> のFindFirst（）	最初の要素を返します。
オプション<T> findAny（）	電流の流れ内の任意の要素を返します。
長い 数（）	ストリーム内の要素の合計数を返します。
オプション<T> MAX（コンパレータC）	最大フローを返します
オプションの<T> 分（比較器C）	最小の流れを返します。
空 のforEach（消費者C）	イテレーション
Tは （T iDENは、BinaryOperator B）を減少させます	ストリームは、要素を組み合わせた値を得るために繰り返すことができます。戻り値T
Uは （BinaryOperator B）を減少させます	ストリームは、要素を組み合わせた値を得るために繰り返すことができます。戻るオプション<T>
R 収集（コレクタC）	ストリームは、他の形式に変換されます。コレクターはのための要素ストリームの概要を作成するプロセスを実装するためのインタフェースを受け取ります

コレクター実装するインターフェイスのメソッドは、（リスト、セット、地図を集めるよう）対流が収集方法を実行するアクションを決定します。また、コレクターのユーティリティクラスを使用すると、簡単に共通コレクタのインスタンスを作成することができ、多くの静的メソッドを提供します。

public class Test09StreamEnding {
	
	@Test
	public void test14(){
		List<Integer> list = Stream.of(1,2,4,5,7,8)
				.filter(t -> t%2==0)
				.collect(Collectors.toList());
		
		System.out.println(list);
	}
	
	
	@Test
	public void test13(){
		Optional<Integer> max = Stream.of(1,2,4,5,7,8)
			 .reduce((t1,t2) -> t1>t2?t1:t2);//BinaryOperator接口   T apply(T t1, T t2)
		System.out.println(max);
	}
	
	@Test
	public void test12(){
		Integer reduce = Stream.of(1,2,4,5,7,8)
			 .reduce(0, (t1,t2) -> t1+t2);//BinaryOperator接口   T apply(T t1, T t2)
		System.out.println(reduce);
	}
	
	@Test
	public void test11(){
		Optional<Integer> max = Stream.of(1,2,4,5,7,8)
				.max((t1,t2) -> Integer.compare(t1, t2));
		System.out.println(max);
	}
	
	@Test
	public void test10(){
		Optional<Integer> opt = Stream.of(1,2,4,5,7,8)
				.filter(t -> t%3==0)
				.findFirst();
		System.out.println(opt);
	}
	
	@Test
	public void test09(){
		Optional<Integer> opt = Stream.of(1,2,3,4,5,7,9)
				.filter(t -> t%3==0)
				.findFirst();
		System.out.println(opt);
	}
	
	@Test
	public void test08(){
		Optional<Integer> opt = Stream.of(1,3,5,7,9).findFirst();
		System.out.println(opt);
	}
	
	@Test
	public void test04(){
		boolean result = Stream.of(1,3,5,7,9)
			.anyMatch(t -> t%2==0);
		System.out.println(result);
	}
	
	
	@Test
	public void test03(){
		boolean result = Stream.of(1,3,5,7,9)
			.allMatch(t -> t%2!=0);
		System.out.println(result);
	}
	
	@Test
	public void test02(){
		long count = Stream.of(1,2,3,4,5)
				.count();
		System.out.println("count = " + count);
	}
	
	@Test
	public void test01(){
		Stream.of(1,2,3,4,5)
				.forEach(System.out::println);
	}
}