Java8新機能 - ストリームAPI

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

ストリームとは何ですか

生成された要素のシーケンスのデータ・チャネル、動作のためのデータソース（等セット、アレイ、）されている
データ・ストリームの話セットは、応力を計算することです

PS：

• 自体は保存されていないストリーム要素
• ストリームは、ソースオブジェクトを変更しません逆に、彼らは新しいストリームを保持した結果を返します。
• ストリーム動作は、彼らが唯一の実装の結果まで待つ必要がありますを意味し、遅れて実行されます

次のグラフは、より直感的なプロセスを反映することができます。

• ストリームが作成
  ストリームを取得、データソース（アレイ、コレクション、等）
• 中間作動
  鎖中間操作、データソースのデータ処理
• 操作（操作端末）終了
  終了操作、中間操作鎖を実行し、結果を生み出します

ストリームを作成します

コレクションシリーズコレクション（）またはparallelStreamが提供するストリーム（）

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

• デフォルトのストリーム ストリームは、（）：順次ストリームを返します。
• デフォルトのストリーム parallelStream（）：パラレルストリームを返します

サンプルコード：

List<Integer> list = new ArrayList<>();
Stream<Integer> stream1 = list.stream();
Stream<Integer> stream2 = list.parallelStream();

ストリームの配列によって作成されました

データ・ストリームを取得するための配列ストリームJava8（の静的メソッド）

• 静的 ストリーム ストリーム（T []配列は）：ストリームを返し

サンプルコード：

Integer[] integers = new Integer[10];
Stream<Integer> stream = Arrays.stream(integers);

バリューストリームによって作成されました

（）の、ディスプレイを介して流量値を作成し、それがストリームクラス静的メソッドによって受信されたパラメータの任意の数とすることができます

• パブリック静的 ストリーム （T ...値）：ストリームを返します。

サンプルコード：

Stream<Integer> stream = Stream.of(1, 2, 3);

無制限のストリームを作成します。

静的メソッドStream.iterate（）とStream.generate（）を使用し、無制限のストリームを作成します

• イテレーションます。public static ストリーム 反復（最終T種子、最終UnaryOperator F）
• 世代ます。public static ストリーム 生成（サプライヤー S）

サンプルコード：

// 迭代
Stream stream1 = Stream.iterate(0, (x) ->  x + 2);
// 生成
Stream stream2 = Stream.generate(() -> Math.random());

中級操作

複数の中間操作が形成するように接合することができるパイプラインをパイプライン動作が終了トリガしない限り、または中間の操作は、任意の処理を行いません！で一斉に「遅延評価」と呼ばれる演算処理を、停止します。

スクリーニングとスライスしました

• フィルタ：検索結合ラムダ、フロー要素から除外
• 限界：エレメントが所定の数を超えないように、ストリーム切り詰め
• （n）はスキップ：エレメントをスキップは、リターン流が最初のn個の要素を除去し; nはフロー要素、空のストリームよりも小さい場合、限界に相補的な（N）
• 異なる：スクリーニング、要素（によって生成されたハッシュコードストリーム）とequals（）要素の重複排除

サンプルコード：

public class TestStreamApi {
    private static List<Demo> demoList = Arrays.asList(
            new Demo(1, "哈哈哈"),
            new Demo(2, "嘿嘿嘿嘿"),
            new Demo(3, "呵呵呵"),
            new Demo(4, "恩恩恩恩"),
            new Demo(5, "哼哼哼"),
            new Demo(6, "啧啧啧"),
            new Demo(5, "哼哼哼"),
            new Demo(8, "哼")
    );

    public static void main(String[] args) {
        // 中间操作不会执行任何操作
        Stream<Demo> demoStream = demoList.stream()
                .filter((x) -> x.getRemark().length() == 3)
                .limit(4)
                .skip(1)
                .distinct();

        // 终止操作一次性执行全部内容
        // 内部迭代：迭代操作由Stream API完成
        demoStream.forEach(System.out::println);
    }
}

実行結果：
3 -オハイオ州オハイオ州
、5-ハムハム
5,6ちぇちぇ

注： DISTINCTハッシュコードを生成したエレメンタリストリーム（）とequalsをスクリーニングすることによって（）重複排除要素は、デモのhashCode（）とequals（）メソッドを書き換える必要があります。

マッピング

• マップ：、ラムダ情報受信または他の形を抽出する変換素子、パラメータとして受信機能、機能は、各要素に適用され、新しい要素にそれをマップします
• flatMap：パラメータとして受信機能、各ストリームの値を別のストリームに置き換えられ、その後、すべてが1つのストリーム接続にストリーム

サンプルコード：

public class TestStreamApi {
    private static List<Demo> demoList = Arrays.asList(
            new Demo(1, "哈哈哈"),
            new Demo(2, "嘿嘿嘿嘿")
    );

    public static void main(String[] args) {
        demoList.stream()
                .map(Demo::getRemark)
                .flatMap(TestStreamApi :: filterCharacter)
                .forEach(System.out::println);
    }

    public static Stream<Character> filterCharacter(String str) {
        List<Character> list = new ArrayList<>();
        for (Character c : str.toCharArray()) {
            list.add(c);
        }
        return list.stream();
    }
}

結果：
ハ
ヘクタール
ヘクタール
ちょっと
ちょっと
ちょっと
ちょっと

シーケンス

• （）ソート：自然順序付け
• ソート（コンパレータC）：カスタムソート

サンプルコード：

public class TestStreamApi {
    private static List<Demo> demoList = Arrays.asList(
            new Demo(5, "哈哈哈"),
            new Demo(2, "嘿嘿嘿嘿"),
            new Demo(3, "呵呵呵"),
            new Demo(2, "哼哼哼"),
            new Demo(5, "啧啧啧")
    );

    public static void main(String[] args) {
        List<String> list = Arrays.asList("aaa", "bbb", "ccc");
        list.stream()
                .sorted()
                .forEach(System.out::println);
        System.out.println("----------");
        demoList.stream()
                .sorted((x, y) -> {
                    if (x.getNum().equals(y.getNum())) {
                        return x.getRemark().compareTo(y.getRemark());
                    } else {
                        return x.getNum().compareTo(y.getNum());
                    }
                })
                .forEach(System.out::println);
    }
}

実行結果：
AAA
BBBの
CCC
----------
2 -ハムハム
2 -ねえねえ
、3-オハイオ州オハイオ州
5ヘクタール
の5-ちぇちぇ

操作の終了

マッチを探します

• allMatch：すべての要素が一致していることを確認してください
• anyMatch：すべての要素が一致していることを確認してください
• noneMatch：すべての要素の一致がないか確認してください
• この関数は、FindFirst：最初の要素を返します。
• findAny：任意の要素への電流の流れを返します。
• カウント：流れの中での要素の合計数を返します。
• 最大：リターン・フローの最大値
• 分：最小流量を返します。

サンプルコード：

public class TestStreamApi2 {
        private static List<Demo> demoList = Arrays.asList(
            new Demo("张三", 18, 6666.66, Demo.Status.BUSY),
            new Demo("李四", 38, 3333.33, Demo.Status.FREE),
            new Demo("王五", 28, 5555.55, Demo.Status.FREE),
            new Demo("赵六", 48, 7777.77, Demo.Status.BUSY),
            new Demo("王二麻子", 58, 8888.88, Demo.Status.VOCATION)

    );

    public static void main(String[] args) {
        // 是不是所有的对象都处于BUSY状态
        System.out.println(demoList.stream()
                .allMatch((d) -> d.getStatus().equals(Demo.Status.BUSY)));
        // 是否有对象处于BUSY状态
        System.out.println(demoList.stream()
                .anyMatch((d) -> d.getStatus().equals(Demo.Status.BUSY)));
        // 是否没有对象处于BUSY状态
        System.out.println(demoList.stream()
                .noneMatch((d) -> d.getStatus().equals(Demo.Status.BUSY)));
        // 获取工资最高的
        Optional<Demo> optionalDemo1 = demoList.stream()
                .sorted((x, y) -> -Double.compare(x.getSalary(), y.getSalary()))
                .findFirst();
        System.out.println(optionalDemo1.get());
        // 获取随机一个空闲的
        Optional<Demo> optionalDemo2 = demoList.stream()
                .filter((e) -> e.getStatus().equals(Demo.Status.FREE))
                .findAny();
        System.out.println(optionalDemo2.get());
        // 总数
        System.out.println(demoList.stream().count());
        // 工资最高的
        Optional<Demo> optionalDemo3 = demoList.stream()
                .max((x, y) -> Double.compare(x.getSalary(), y.getSalary()));
        System.out.println(optionalDemo3.get());
        // 最小的工资
        Optional<Double> optionalDemo4 = demoList.stream()
                .map(Demo::getSalary)
                .max(Double::compare);
        System.out.println(optionalDemo4.get());
    }
}

class Demo{
    // 姓名
    String name;
    // 年龄
    Integer age;
    // 工资
    Double salary;
    // 状态
    Status status;

    public Demo() {}

    public Demo(String name, Integer age, Double salary, Status status) {
        this.name = name;
        this.age = age;
        this.salary = salary;
        this.status = status;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Double getSalary() {
        return salary;
    }

    public void setSalary(Double salary) {
        this.salary = salary;
    }

    public Status getStatus() {
        return status;
    }

    public void setStatus(Status status) {
        this.status = status;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Demo demo = (Demo) o;
        return name.equals(demo.name) &&
                age.equals(demo.age) &&
                salary.equals(demo.salary) &&
                status == demo.status;
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age, salary, status);
    }

    @Override
    public String toString() {
        return "Demo{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", salary=" + salary +
                ", status=" + status +
                '}';
    }

    public enum Status{
        FREE,
        BUSY,
        VOCATION
    }
}

実行結果：
falseに
trueに
falseに
デモ{名前は= 'キングあばた'、年齢= 58、給与= 8888.88、ステータス=職業}
デモ{名= 'ジョン・ドウ'、= 38年齢は給与= 3333.33、ステータス= FREE、ある}
5。
デモ{名= 'キングあばた'、年齢= 58、給与= 8888.88、職業}ステータス=
8888.88

削減

• 低減（T、BinaryOperatorを識別する）/（BinaryOperator）を低減：ストリームは、要素が値を与えるために組み合わせる繰り返すことができます

サンプルコード：

public class TestStreamApi3 {
    private static List<Demo> demoList = Arrays.asList(
            new Demo("张三", 18, 6666.66, Demo.Status.BUSY),
            new Demo("李四", 38, 3333.33, Demo.Status.FREE),
            new Demo("王五", 28, 5555.55, Demo.Status.FREE),
            new Demo("赵六", 48, 7777.77, Demo.Status.BUSY),
            new Demo("王二麻子", 58, 8888.88, Demo.Status.VOCATION)
    );

    public static void main(String[] args) {
        Optional<Double> optional = demoList.stream()
                .map(Demo::getSalary)
                .reduce(Double::sum);
        System.out.println(optional.get());
    }
}

結果：
32222.190000000002

集まります

• 収集：ストリームは、他の形式に変換されます。要素がための概要をストリーミングするために、プロセスを実装するためのインタフェースを受け取るコレクション

実装方法コレクターズ・インタフェースは、対流が（例えばコレクト一覧など、セット、マップ）の収集を行う方法を決定します。

• ToListメソッド：リストを収集するためのフロー要素
• toSet：フロー要素収集の設定
• toCollection：コレクションを作成するには、コレクションの要素のストリーム
• カウント：ストリーム内の要素の数を数えます
• 要約すると、整数属性の対流要素：summingInt
• averagingInt：平均計算ストリーム属性要素整数
• summarizingInt：整数プロパティの統計収集の流れ
• jioning：各文字列の接続の流れ
• maxBy：最大値が選択され、コンパレータ
• minBy：最小値が選択されているコンパレータ
• 還元性：初期値のような1つのアキュムレータから始め、そしてBinaryOperatorを使用してエレメンタリストリームは、個別に単一の値の法令への結合
• collectingAndThen：さらにアキュムレータ、その伝達関数の結果をラップ
• groupingBy：属性対流パケット属性の値がKであり、結果はVであります
• partitioningBy：真に基づいてパーティション、偽

サンプルコード：

public class TestStreamApi4 {
    private static List<Demo> demoList = Arrays.asList(
            new Demo("张三", 18, 6666.66, Demo.Status.BUSY),
            new Demo("李四", 38, 3333.33, Demo.Status.FREE),
            new Demo("王五", 28, 5555.55, Demo.Status.FREE),
            new Demo("赵六", 48, 7777.77, Demo.Status.BUSY),
            new Demo("王二麻子", 58, 8888.88, Demo.Status.VOCATION)
    );

    public static void main(String[] args) {
        HashSet<String> set = demoList.stream()
                .map(Demo::getName)
                .collect(Collectors.toCollection(HashSet::new));
        set.forEach(System.out::println);
        // 总数
        System.out.println(demoList.stream()
                .collect(Collectors.counting()));

        // 工资平均值
        System.out.println(demoList.stream()
                .collect(Collectors.averagingDouble(Demo::getSalary)));
    }
}

結果：
ジョン・ドウ
ジョン・ドウの
王、ポック
王呉
趙6
5
6444.438