Java8におけるStreamの詳しい使い方まとめ

この記事では、Java に関する関連知識を提供します。主に Stream の詳細な使用法に関する関連問題を紹介します。バージョンの新しい Stream は、同じバージョンに表示される Lambda とともに、操作コレクション (コレクション) を提供します。とても便利ですので、以下で見ていきましょう。皆さんのお役に立てれば幸いです。

推奨学習: 「java ビデオ チュートリアル 」

1. 概要

Java 8 は非常に成功しています。新しいバージョンの Stream と、同じバージョンに含まれる Lambda を組み合わせることで、コレクションの操作が非常に便利になります。 Stream は JDK8 の新しいメンバーであり、宣言的な方法でデータ コレクションを処理できるようになり、データ コレクションを走査するための高度なイテレータとみなすことができます。ストリームは、Java 8 でコレクションを処理するための主要な抽象概念です。ストリームは、コレクションに対して実行する操作を指定でき、データの検索/フィルタリング/フィルタリング、並べ替え、集計、マッピングなどの非常に複雑な操作を実行できます。 Stream API を使用してコレクション データを操作することは、SQL を使用してデータベース クエリを実行することに似ています。 Stream API を使用して操作を並行して実行することもできます。つまり、Stream API は、データを処理するための効率的で使いやすい方法を提供します。

1. ストリームを使用する利点

コードは宣言的な方法で記述され、操作を完了する方法ではなく、何を達成したいかを記述します。
いくつかの基本操作を接続して、コードを明確で読みやすい状態に保ちながら、複雑なデータ処理パイプラインを表現できます。

2. ストリームとは何ですか?

データ処理操作をサポートするソースから要素のシーケンスを生成します。データ ソースはコレクション、配列、または IO です。リソース。

運用の観点から見ると、ストリームはコレクションとは異なります。ストリームはデータ値を保存しません。ストリームの目的はデータを処理することであり、アルゴリズムと計算に関するものです。

コレクションがストリームのデータ ソースとして使用されている場合、ストリームを作成してもデータは流れません。ストリームの終了操作に値が必要な場合、ストリームはコレクションから値を取得します。ストリームは 1 回だけ使用されます。

ストリームの中心的な考え方は計算を遅らせることであり、ストリームは必要になるまで値を計算しません。

ストリームは配列またはコレクションから作成できます。ストリームに対する操作は 2 つのタイプに分けられます:

中間操作は毎回新しいストリームを返します。複数のストリームが存在する場合もあります。

終了操作。各ストリームは終了操作を 1 つだけ実行できます。終了操作が完了すると、ストリームを再度使用することはできません。端末操作により、新しいコレクションまたは値が生成されます。

機能:

はデータ構造ではないため、データは保存されません。

元のデータ ソースは変更されません。操作されたデータは別のオブジェクトに保存されます。 (予約: 結局のところ、ピーク メソッドはストリーム内の要素を変更できます)

遅延評価、ストリームの中間処理中、操作は記録されるだけで、すぐには実行されません。待つ必要があります。終了操作が実行されるまでは、実際の計算が実行されません。

2. 分類

ステートレス: 前の要素の影響を受けない要素の処理を指します。

ステートフル: を指します。操作はすべての要素を取得した後にのみ続行できます。

非短絡操作: 最終結果を取得するにはすべての要素を処理する必要があることを意味します;

短絡操作: 特定の要素が条件を満たす場合に最終結果を取得できることを意味しますA || B などの条件が発生しました。A が true である限り、B の結果を判断する必要はありません。

3. ストリームの作成

ストリームはコレクション配列を通じて作成できます。

1. java.util.Collection.stream() メソッドを使用して、コレクションを持つストリームを作成します。

List<string> list = Arrays.asList("a", "b", "c");// 创建一个顺序流
Stream<string> stream = list.stream();// 创建一个并行流
Stream<string> parallelStream = list.parallelStream();</string></string></string>

2. java.util.Arrays.stream(T[]array を使用します) ) メソッドを使用して、配列 Stream

int[] array={1,3,5,6,8};IntStream stream = Arrays.stream(array);

3 を持つストリームを作成します。Stream の静的メソッドを使用します: of()、iterate()、generate()

Stream<integer> stream = Stream.of(1, 2, 3, 4, 5, 6);
 Stream<integer> stream2 = Stream.iterate(0, (x) -> x + 3).limit(4);stream2.forEach(System.out::println);
 Stream<double> stream3 = Stream.generate(Math::random).limit(3);stream3.forEach(System.out::println);</double></integer></integer>

出力結果:

0 3 6 90.67961569092719940.19143142088542830.8116932592396652

ストリームとParallelStreamの簡単な区別: ストリームはシーケンシャルストリームであり、メインスレッドはストリームに対して順番に操作を実行しますが、ParallelStreamは並列ストリームであり、ストリームは内部でマルチスレッド並列実行方式で操作されます。ただし、ストリームでのデータ処理に順序の要件がないことが前提となります。たとえば、コレクション内の奇数をフィルター処理する場合、この 2 つの処理の違いは次のとおりです。

ストリーム内のデータ量が十分に大きい場合、並列ストリームは処理を高速化できます。

並列ストリームを直接作成することに加えて、Parallel() を介してシーケンシャル ストリームを並列ストリームに変換することもできます:

Optional<integer> findFirst = list.stream().parallel().filter(x->x>6).findFirst();</integer>

4. ストリーム API の概要

先贴上几个案例，水平高超的同学可以挑战一下：从员工集合中筛选出salary大于8000的员工，并放置到新的集合里。统计员工的最高薪资、平均薪资、薪资之和。将员工按薪资从高到低排序，同样薪资者年龄小者在前。将员工按性别分类，将员工按性别和地区分类，将员工按薪资是否高于8000分为两部分。用传统的迭代处理也不是很难，但代码就显得冗余了，跟Stream相比高下立判。

前提: 従業員クラス

static List<person> personList = new ArrayList<person>();private static void initPerson() {
    personList.add(new Person("张三", 8, 3000));
    personList.add(new Person("李四", 18, 5000));
    personList.add(new Person("王五", 28, 7000));
    personList.add(new Person("孙六", 38, 9000));}</person></person>

1. トラバーサル/マッチ (foreach/find/match)

ストリームも同様のコレクションをサポートします。要素を横断して照合しますが、ストリーム内の要素はオプションのタイプとして存在します。ストリームのトラバースとマッチングは非常に簡単です。

// import已省略，请自行添加，后面代码亦是
 
public class StreamTest {
  public static void main(String[] args) {
        List<integer> list = Arrays.asList(7, 6, 9, 3, 8, 2, 1);
 
        // 遍历输出符合条件的元素
        list.stream().filter(x -> x > 6).forEach(System.out::println);
        // 匹配第一个
        Optional<integer> findFirst = list.stream().filter(x -> x > 6).findFirst();
        // 匹配任意（适用于并行流）
        Optional<integer> findAny = list.parallelStream().filter(x -> x > 6).findAny();
        // 是否包含符合特定条件的元素
        boolean anyMatch = list.stream().anyMatch(x -> x <h3 id="按条件匹配filter">2、按条件匹配filter</h3>
<p><img src="/static/imghw/default1.png" data-src="https://img.php.cn/upload/article/000/000/067/c32799257ddfee7ae65dfaf7bce4b27c-5.png" class="lazy" alt="在这里插入Java8におけるStreamの詳しい使い方まとめ描述"></p>
<p><strong>（1）筛选员工中已满18周岁的人，并形成新的集合</strong></p>
<pre class="brush:php;toolbar:false">/**
 * 筛选员工中已满18周岁的人，并形成新的集合
 * @思路
 * List<person> list = new ArrayList<person>();
 * for(Person person : personList) {
 *     if(person.getAge() >= 18) {
 *          list.add(person);
 *     }
 * }
 */
private static void filter01() {
    initPerson();
    List<person> collect = personList.stream().filter(x -> x.getAge()>=18).collect(Collectors.toList());
    System.out.println(collect);}</person></person></person>

（2）自定义条件匹配

3、聚合max、min、count

（1）获取String集合中最长的元素

/**
 * 获取String集合中最长的元素
 * @思路
 * List<string> list = Arrays.asList("zhangsan", "lisi", "wangwu", "sunliu");
 * String max = "";
 * int length = 0;
 * int tempLength = 0;
 * for(String str : list) {
 *     tempLength = str.length();
 *     if(tempLength > length) {
 *         length  = str.length();
 *         max = str;
 *      }
 * }
 * @return zhangsan
 */
private static void test02() {
    List<string> list = Arrays.asList("zhangsan", "lisi", "wangwu", "sunliu");
    Comparator super String> comparator = Comparator.comparing(String::length);
    Optional<string> max = list.stream().max(comparator);
    System.out.println(max);}</string></string></string>

（2）获取Integer集合中的最大值

//获取Integer集合中的最大值
private static void test05() {
    List<integer> list = Arrays.asList(1, 17, 27, 7);
    Optional<integer> max = list.stream().max(Integer::compareTo);
    // 自定义排序
    Optional<integer> max2 = list.stream().max(new Comparator<integer>() {
        @Override
        public int compare(Integer o1, Integer o2) {
            return o1.compareTo(o2);
        }
    });
    System.out.println(max2);}</integer></integer></integer></integer>

//获取员工中年龄最大的人
private static void test06() {
    initPerson();
    Comparator super Person> comparator = Comparator.comparingInt(Person::getAge);
    Optional<person> max = personList.stream().max(comparator);
    System.out.println(max);}</person>

（3）获取员工中年龄最大的人

（4）计算integer集合中大于10的元素的个数

4、map与flatMap

map：接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。

flatMap：接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。

（1）字符串大写

（2）整数数组每个元素+3

/**
 * 整数数组每个元素+3
 * @思路
 * List<integer> list = Arrays.asList(1, 17, 27, 7);
   List<integer> list2 = new ArrayList<integer>();
   for(Integer num : list) {
      list2.add(num + 3);
   }
   @return [4, 20, 30, 10]
 */
private static void test09() {
    List<integer> list = Arrays.asList(1, 17, 27, 7);
    List<integer> collect = list.stream().map(x -> x + 3).collect(Collectors.toList());
    System.out.println(collect);}</integer></integer></integer></integer></integer>

（3）公司效益好，每人涨2000

/**
 * 公司效益好，每人涨2000
 *
 */
private static void test10() {
    initPerson();
    List<person> collect = personList.stream().map(x -> {
        x.setAge(x.getSalary()+2000);
        return x;
    }).collect(Collectors.toList());
    System.out.println(collect);}</person>

（4）将两个字符数组合并成一个新的字符数组

/**
 * 将两个字符数组合并成一个新的字符数组
 *
 */
private static void test11() {
    String[] arr = {"z, h, a, n, g", "s, a, n"};
    List<string> list = Arrays.asList(arr);
    System.out.println(list);
    List<string> collect = list.stream().flatMap(x -> {
        String[] array = x.split(",");
        Stream<string> stream = Arrays.stream(array);
        return stream;
    }).collect(Collectors.toList());
    System.out.println(collect);}</string></string></string>

（5）将两个字符数组合并成一个新的字符数组

/**
 * 将两个字符数组合并成一个新的字符数组
 * @return [z,  h,  a,  n,  g, s,  a,  n]
 */
private static void test11() {
    String[] arr = {"z, h, a, n, g", "s, a, n"};
    List<string> list = Arrays.asList(arr);
    List<string> collect = list.stream().flatMap(x -> {
        String[] array = x.split(",");
        Stream<string> stream = Arrays.stream(array);
        return stream;
    }).collect(Collectors.toList());
    System.out.println(collect);}</string></string></string>

5、规约reduce

归约，也称缩减，顾名思义，是把一个流缩减成一个值，能实现对集合求和、求乘积和求最值操作。

（1）求Integer集合的元素之和、乘积和最大值

/**
 * 求Integer集合的元素之和、乘积和最大值
 *
 */
private static void test13() {
    List<integer> list = Arrays.asList(1, 2, 3, 4);
    //求和
    Optional<integer> reduce = list.stream().reduce((x,y) -> x+ y);
    System.out.println("求和:"+reduce);
    //求积
    Optional<integer> reduce2 = list.stream().reduce((x,y) -> x * y);
    System.out.println("求积:"+reduce2);
    //求最大值
    Optional<integer> reduce3 = list.stream().reduce((x,y) -> x>y?x:y);
    System.out.println("求最大值:"+reduce3);}</integer></integer></integer></integer>

（2）求所有员工的工资之和和最高工资

/*
 * 求所有员工的工资之和和最高工资
 */
private static void test14() {
    initPerson();
    Optional<integer> reduce = personList.stream().map(Person :: getSalary).reduce(Integer::sum);
    Optional<integer> reduce2 = personList.stream().map(Person :: getSalary).reduce(Integer::max);
    System.out.println("工资之和:"+reduce);
    System.out.println("最高工资:"+reduce2);}</integer></integer>

6、收集（toList、toSet、toMap）

取出大于18岁的员工转为map

/**
 * 取出大于18岁的员工转为map
 *
 */
private static void test15() {
    initPerson();
    Map<string> collect = personList.stream().filter(x -> x.getAge() > 18).collect(Collectors.toMap(Person::getName, y -> y));
    System.out.println(collect);}</string>

7、collect

Collectors提供了一系列用于数据统计的静态方法：

计数： count

平均值： averagingInt、 averagingLong、 averagingDouble

最值： maxBy、 minBy

求和： summingInt、 summingLong、 summingDouble

统计以上所有： summarizingInt、 summarizingLong、 summarizingDouble

/**
 * 统计员工人数、平均工资、工资总额、最高工资
 */
private static void test01(){
    //统计员工人数
    Long count = personList.stream().collect(Collectors.counting());
    //求平均工资
    Double average = personList.stream().collect(Collectors.averagingDouble(Person::getSalary));
    //求最高工资
    Optional<integer> max = personList.stream().map(Person::getSalary).collect(Collectors.maxBy(Integer::compare));
    //求工资之和
    Integer sum = personList.stream().collect(Collectors.summingInt(Person::getSalary));
    //一次性统计所有信息
    DoubleSummaryStatistics collect = personList.stream().collect(Collectors.summarizingDouble(Person::getSalary));
    System.out.println("统计员工人数:"+count);
    System.out.println("求平均工资:"+average);
    System.out.println("求最高工资:"+max);
    System.out.println("求工资之和:"+sum);
    System.out.println("一次性统计所有信息:"+collect);}</integer>

8、分组(partitioningBy/groupingBy)

分区：将stream按条件分为两个 Map，比如员工按薪资是否高于8000分为两部分。

分组：将集合分为多个Map，比如员工按性别分组。有单级分组和多级分组。

将员工按薪资是否高于8000分为两部分；将员工按性别和地区分组

public class StreamTest {
  public static void main(String[] args) {
    personList.add(new Person("zhangsan",25, 3000, "male", "tieling"));
        personList.add(new Person("lisi",27, 5000, "male", "tieling"));
        personList.add(new Person("wangwu",29, 7000, "female", "tieling"));
        personList.add(new Person("sunliu",26, 3000, "female", "dalian"));
        personList.add(new Person("yinqi",27, 5000, "male", "dalian"));
        personList.add(new Person("guba",21, 7000, "female", "dalian"));
 
    // 将员工按薪资是否高于8000分组
        Map<boolean>> part = personList.stream().collect(Collectors.partitioningBy(x -> x.getSalary() > 8000));
        // 将员工按性别分组
        Map<string>> group = personList.stream().collect(Collectors.groupingBy(Person::getSex));
        // 将员工先按性别分组，再按地区分组
        Map<string>>> group2 = personList.stream().collect(Collectors.groupingBy(Person::getSex, Collectors.groupingBy(Person::getArea)));
        System.out.println("员工按薪资是否大于8000分组情况：" + part);
        System.out.println("员工按性别分组情况：" + group);
        System.out.println("员工按性别、地区：" + group2);
  }}</string></string></boolean>

9、连接joining

joining可以将stream中的元素用特定的连接符（没有的话，则直接连接）连接成一个字符串。

10、排序sorted

将员工按工资由高到低（工资一样则按年龄由大到小）排序

private static void test04(){
    // 按工资升序排序（自然排序）
    List<string> newList = personList.stream().sorted(Comparator.comparing(Person::getSalary)).map(Person::getName)
            .collect(Collectors.toList());
    // 按工资倒序排序
    List<string> newList2 = personList.stream().sorted(Comparator.comparing(Person::getSalary).reversed())
            .map(Person::getName).collect(Collectors.toList());
    // 先按工资再按年龄升序排序
    List<string> newList3 = personList.stream()
            .sorted(Comparator.comparing(Person::getSalary).thenComparing(Person::getAge)).map(Person::getName)
            .collect(Collectors.toList());
    // 先按工资再按年龄自定义排序（降序）
    List<string> newList4 = personList.stream().sorted((p1, p2) -> {
        if (p1.getSalary() == p2.getSalary()) {
            return p2.getAge() - p1.getAge();
        } else {
            return p2.getSalary() - p1.getSalary();
        }
    }).map(Person::getName).collect(Collectors.toList());
 
    System.out.println("按工资升序排序：" + newList);
    System.out.println("按工资降序排序：" + newList2);
    System.out.println("先按工资再按年龄升序排序：" + newList3);
    System.out.println("先按工资再按年龄自定义降序排序：" + newList4);}</string></string></string></string>

11、提取/组合

流也可以进行合并、去重、限制、跳过等操作。

private static void test05(){
    String[] arr1 = { "a", "b", "c", "d" };
    String[] arr2 = { "d", "e", "f", "g" };
    Stream<string> stream1 = Stream.of(arr1);
    Stream<string> stream2 = Stream.of(arr2);
    // concat:合并两个流 distinct：去重
    List<string> newList = Stream.concat(stream1, stream2).distinct().collect(Collectors.toList());
    // limit：限制从流中获得前n个数据
    List<integer> collect = Stream.iterate(1, x -> x + 2).limit(10).collect(Collectors.toList());
    // skip：跳过前n个数据
    List<integer> collect2 = Stream.iterate(1, x -> x + 2).skip(1).limit(5).collect(Collectors.toList());
 
    System.out.println("流合并：" + newList);
    System.out.println("limit：" + collect);
    System.out.println("skip：" + collect2);}</integer></integer></string></string></string>

12、读取文件的流操作

13、计算两个list中的差集

//计算两个list中的差集
List<string> reduce1 = allList.stream().filter(item -> !wList.contains(item)).collect(Collectors.toList());</string>

推荐学习：《java视频教程》

以上がJava8におけるStreamの詳しい使い方まとめの詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。