[Java85の新機能] Java8の最も重要なアップグレードストリーム

その他 2021-01-12 10:04:44 訪問数: null

1. Java8ストリームの概要

Java 8は非常に成功したバージョンです。このバージョンの新しいストリームは、同じバージョンで登場したLambdaと組み合わせて、コレクションの操作に非常に便利です。

StreamはJDK8の新しいメンバーであり、データ収集を宣言的に処理できます。StreamStreamは、データ収集をトラバースするための高レベルの反復子と見なすことができます。

ストリームは、処理される要素のセットを一種のストリームと見なします。ストリーミングのプロセスでは、ストリーム内の要素は、 APIフィルタリング、並べ替え、集計など、ストリームの助けを借りて操作されます。

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

コードは宣言的な方法で書かれており、操作を実行する方法ではなく、実行したいことを説明しています。

いくつかの基本的な操作を接続して、コードを明確で読みやすく保ちながら、複雑なデータ処理パイプラインを表現できます。

2.フローとは？

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

運用の観点から、ストリームはセットとは異なります。ストリームはデータ値を格納しません。ストリームの目的はデータを処理することであり、アルゴリズムと計算に関するものです。

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

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

ストリームは配列またはコレクションから作成でき、ストリームには次の2種類の操作があります。

  1. 中間操作は毎回新しいストリームを返します。複数存在する場合があります。
  2. ターミナル操作の場合、各ストリームは1つのターミナル操作のみを実行でき、ターミナル操作後にストリームを再度使用することはできません。端末操作により、新しいセットまたは値が生成されます。

さらに、Streamにはいくつかの機能があります。

  1. Streamはデータを保存しませんが、特定のルールに従ってデータを計算し、通常は結果を出力します。
  2. ストリームはデータソースを変更しません。通常、新しいセットまたは値が生成されます。
  3. ストリームには遅延実行機能があり、中間操作は端末操作が呼び出されたときにのみ実行されます。

第二に、ストリームの作成

Streamコレクション配列で作成できます。

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

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

2.java.util.Arrays.stream(T[] array)アレイを使用してストリームを作成する方法

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);

出力結果：

0 3 6 9
0.6796156909271994
0.1914314208854283
0.8116932592396652

streamそして、parallelStream区別する簡単： stream操作を実行するためにメインスレッドによるシーケンスフロー対流、およびparallelStream並列ストリームは、複数のオペレーティング対流モードの並列実行を雌ねじが、唯一の任意の順序でフローデータ処理にされます。たとえば、コレクション内の奇数をフィルタリングします。2つの間の処理の違いは次のとおりです。

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

並列ストリームを直接作成するだけでなくparallel()、順次ストリームを並列ストリームに変換することもできます。

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

3. StreamAPIの概要 

最初にいくつかのケースを投稿しましょう。レベルの高いものは挑戦できます。

  1. 給与が8000を超える従業員を従業員セットから除外し、新しいセットに配置します。
  2. 最高給与、平均給与、従業員の給与の合計を数えます。
  3. 従業員を給与の高いものから低いものの順に並べ替えます。最初は若い支払人です。
  4. 従業員を性別で分類し、性別と地域で分類し、給与が8000を超えるかどうかに応じて従業員を2つの部分に分けます。

従来の反復処理を使用することは難しくありませんが、コードは冗長であるように見え、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));
}

1.トラバース/マッチ（foreach / find / match）

Stream同様のコレクションのトラバーサル要素とマッチング要素もサポートしますがStream、その中の要素はOptional型に存在します。Streamのトラバーサルとマッチングは非常に簡単です。

// 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 < 6);
        System.out.println("匹配第一个值：" + findFirst.get());
        System.out.println("匹配任意一个值：" + findAny.get());
        System.out.println("是否存在大于6的值：" + anyMatch);
    }
}

2.条件でフィルターを一致させる 

（1）18歳未満の従業員を選別し、新しいセットを作成します

/**
 * 筛选员工中未满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);
}

（2）カスタム条件マッチング

3.最大、最小、カウントを集計します

（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);
}

（2）整数セットの最大値を取得します 

//获取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);
}

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

（3）従業員の中で最年長の人を取得する 

（4）整数セットの10より大きい要素の数を計算します

4.マップとflatMap

map：関数をパラメーターとして受け取ります。関数は各要素に適用され、新しい要素にマップされます。

flatMap：関数をパラメーターとして受け取り、ストリーム内の各値を別のストリームに置き換えてから、すべてのストリームを1つのストリームに接続します。

（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);
}

（3）1人あたり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);
}

 （4）2つの文字配列を新しい文字配列に結合します

/**
 * 将两个字符数组合并成一个新的字符数组
 *
 */
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);
}

 （5）2つの文字配列を新しい文字配列に結合します

/**
 * 将两个字符数组合并成一个新的字符数组
 * @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);
}

5.法令の削減 

削減は、その名前が示すように、削減とも呼ばれ、ストリームを値に削減することです。これにより、セットの合計、積、および最大化の操作を実現できます。

（1）整数セットの要素の合計、積、および最大値を見つけます

/**
 * 求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);
}

（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);
}

6.コレクション（toList、toSet、toMap）

18歳以上の従業員を連れ出し、地図に変換する 

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

7、収集

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);
}

8.グループ化（partitioningBy / groupingBy）

  • 分割：Map従業員の給与が8000を超えるかどうかに応じて、従業員を2つの部分に分割するかどうかなど、条件に応じてストリームを2つの部分に分割します。
  • グループ化：従業員を性別でグループ化するなど、コレクションを複数のマップに分割します。シングルレベルのグループ化とマルチレベルのグループ化があります。

給与が8000を超えるかどうかに応じて、従業員を2つの部分に分け、従業員を性別と地域別にグループ化します。

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, List<Person>> part = personList.stream().collect(Collectors.partitioningBy(x -> x.getSalary() > 8000));
        // 将员工按性别分组
        Map<String, List<Person>> group = personList.stream().collect(Collectors.groupingBy(Person::getSex));
        // 将员工先按性别分组，再按地区分组
        Map<String, Map<String, List<Person>>> 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);
	}
}

9.参加する 

joiningストリーム内の要素は、特定のコネクタを使用して文字列に連結できます（または、そうでない場合は直接連結できます）。

10.ソート済み

従業員を給与の高いものから低いものへと並べ替えます（同じ給与は大きいものから若いものへ）

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);
}

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);
}

12.ファイルを読み取るためのストリーム操作

 

前：[Java8の新機能4]オプション

次の投稿：SpringCloudラーニングの概要

おすすめ

転載: blog.csdn.net/guorui_java/article/details/112336449
おすすめ
ランキング
Python 描画 3D 動的ヒストグラム コード チュートリアル
[vue3 共通エラー 5] Uncaught (in Promise) TypeError: xxx は関数ではありません
シンプルアップロードExcelファイルやデータベースにデータを追加
springboot における import アノテーションの役割
numpy 多维矩阵的维度交换
WMS システム - ウェーブ管理
Redis（7）マスター/スレーブレプリケーション
三北斗七星星座コアグローバルシステムの導入は完了です！グローバルネットワークを推進するために、
sql server语法——排序查询
続行することはできません立ち往生
アーカイブ
もっと
2024-05-16(24)
2024-05-15(5)
2024-05-14(9)
2024-05-13(8)
2024-05-12(27)
2024-05-11(31)
2024-05-10(33)
2024-05-09(30)
2024-05-08(18)
2024-05-07(34)

コードワールド

© 2018 codetd.com