java8流—ストリーム

普通はたった2つの言葉です：怠惰と怠惰;
成功はたった2つの言葉：苦難と勤勉;
卓越性はたった2つの言葉：あなたと私です。
私に従って、JAVA、春の家族のバケツ、Linuxの操作と保守の知識を0から学び、無知なティーンエイジャーから人生の頂点にあなたを連れて行き、Bai Fumeiと結婚してください！
WeChatパブリックアカウント[ ITは非常に信頼できる ]をフォローし、技術的な経験を毎日共有してください〜 

 

java8流—ストリーム

 

1java8の概要

      Java 8（jdk 1.8とも呼ばれます）は、Java言語開発のメジャーバージョンです。OracleCorporationは2014年3月18日にJava8をリリースしました。これは、機能プログラミング、新しいJavaScriptエンジン、新しい日付API、新しいストリームAPIなどをサポートします。Java8は、革新的で安定した完全に機能するバージョンです。

      現在、基本的にすべての企業が、企業のjavaシステムのコンパイルおよび実行環境としてjdk8バージョンを使用しています。jdk8に基づくと、次の特性または利点があります。

      （1）jdk8には完璧な機能があります。jdk8はほぼすべてのjavaプロジェクトの開発に対応できます。

      （2）無料：jdk8は無料で、jdk11などの後続バージョンは有料です。これは、多くの企業にとって非常に低コストのパフォーマンスです。

      （3）jdk8は、いくつかの新しいハイライトを追加しました：ストリーム（並列ストリーム）処理、lamda式、新しい日付API、およびオプション。

 

2 java8流：ストリーム

2.1テストデータを準備する

      後続のApiテストのためにユーザーユーザーオブジェクトのリストコレクションを返すメソッドgetUsers（）を定義します。

      User.javaクラスを定義します。

package com.hc.alltest.all.java8.stream;

import java.io.Serializable;
import java.util.List;
import java.util.Objects;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * 用户
 */
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class User implements Serializable, Comparable {

  /**
   * 用户名
   */
  private String name;

  /**
   * 年龄
   */
  private Integer age;

  /**
   * 兴趣爱好
   */
  private List<String> hobbies;

  @Override
  public boolean equals(Object o) {
    if (this == o) {
      return true;
    }
    if (o == null || getClass() != o.getClass()) {
      return false;
    }
    User user = (User) o;
    return Objects.equals(getName(), user.getName());
  }

  @Override
  public int hashCode() {

    return Objects.hash(getName());
  }

  /**
   * 默认排序：age升序
   */
  @Override
  public int compareTo(Object o) {
    User user = (User) o;
    return this.age - user.getAge();
  }
}

      ユーザーリストを取得するメソッド：getUsers（）

  /**
   * 获取用户列表
   */
  private static List<User> getUsers() {
    List<User> users = new ArrayList<>();
    users.add(User.builder().name("张三").age(10).hobbies(Arrays.asList("篮球", "乒乓球")).build());
    users.add(User.builder().name("李四").age(30).hobbies(Arrays.asList("游泳", "篮球")).build());
    users.add(User.builder().name("王五").age(20).hobbies(Arrays.asList("小说", "音乐")).build());
    users.add(User.builder().name("小六").age(15).hobbies(Arrays.asList("跑步", "篮球")).build());
    users.add(User.builder().name("李四").age(15).hobbies(Collections.emptyList()).build());
    return users;
  }

 

2.2フィルター

      コレクション内の20歳以上のユーザーを除外します。

  /**
   * 1.filter：筛选出年龄大于20岁的用户
   */
  private static void filterTest() {
    List<User> users = getUsers();
    users = users.stream()
        .filter(user -> user.getAge() > 20)
        .collect(Collectors.toList());
    log.info("筛选出年龄大于20岁的用户：{}", users);
  }

 

2.3明確な重複排除

      重複排除（同じ名前は同じユーザーと見なされます）。User.javaクラスのequals（）メソッドとhashCode（）メソッドをオーバーライドする必要があります。

  /**
   * 2.distinct：去重（name相同认为是同一用户）
   */
  private static void distinctTest() {
    //users集合里面有两个name为“李四”的用户
    List<User> users = getUsers();
    users = users.stream()
        .distinct()
        .collect(Collectors.toList());
    log.info("去重（name相同认为是同一用户）：{}", users);
  }

 

2.4カウント

      コレクション要素の数を数えます。

  /**
   * 3.count：统计集合元素个数
   */
  private static void countTest() {
    List<User> users = getUsers();
    long count = users.stream()
        .count();
    log.info("集合元素个数：{}", count);
  }

 

2.5forEachトラバーサル

      コレクションのすべての要素を処理するトラバース（ループ）。

  /**
   * 4.forEach：遍历（循环）处理集合所有元素
   */
  private static void forEachTest() {
    List<User> users = getUsers();
    users.stream()
        .forEach(user -> {
          //业务处理
          log.info("遍历当前元素为：{}", user);
        });
  }

 

2.6ソートされたデフォルトのソート

      コレクション要素はデフォルトで並べ替えられます（年齢の昇順で並べ替えられます）。User.javaクラスは、Comparableインターフェイスを実装し、インターフェイス抽象メソッドint compareTo（Object o）を実装する必要があります。

  /**
   * 5.sorted：集合元素默认排序（按age升序排序）
   */
  private static void defaultSortedTest() {
    List<User> users = getUsers();
    users = users.stream()
        .sorted()
        .collect(Collectors.toList());
    log.info("默认排序后：{}", users);
  }

 

2.7ソートされた指定された順序ソート

      セット要素はソートされます（年齢の昇順でソートされます）。

  /**
   * 6.sorted：集合元素指定排序（按age升序排序）
   */
  private static void specifySortedTest() {
    List<User> users = getUsers();
    users = users.stream()
        //.sorted((u1, u2) -> u1.getAge() - u2.getAge())
        .sorted(Comparator.comparingInt(User::getAge))
        .collect(Collectors.toList());
    log.info("指定排序后：{}", users);
  }

 

2.8逆順

      設定された要素は並べ替えられ（年齢の昇順で並べ替えられます）、逆になります。

  /**
   * 7.reversed：集合元素指定排序（按age升序排序）,并取反序
   */
  private static void reverseTest() {
    List<User> users = getUsers();
    users = users.stream()
//        .sorted((u1, u2) -> u2.getAge() - u1.getAge())
        .sorted(Comparator.comparingInt(User::getAge).reversed())
        .collect(Collectors.toList());
    log.info("指定排序,并取反序：{}", users);
  }

 

2.9最初の要素を取得するためのfindFirst

      セットの最初の要素を取ります。

  /**
   * 8.findFirst：取集合中第一个元素
   */
  private static void findFirstTest() {
    List<User> users = getUsers();
    User firstUser = users.stream()
        .findFirst()
        .orElse(null);
    log.info("集合中第一个元素为：{}", firstUser);
  }

 

2.10findAnyはセット内の任意の要素を取得します

      セット内の任意の要素を取ります。

  /**
   * 9.findAny：取集合中任意一个元素
   */
  private static void findAnyTest() {
    List<User> users = getUsers();
    User anyUser = users.stream()
        .findAny()
        .orElse(null);
    log.info("集合中任意一个元素为：{}", anyUser);
  }

 

最小2.11分

     セットの中で最も若い要素を取ります...

  /**
   * 10.min：取集合中年龄最小的元素
   */
  private static void minTest() {
    List<User> users = getUsers();
    User anyUser = users.stream()
        //.min((u1, u2) -> u1.getAge() - u2.getAge())
        .min(Comparator.comparingInt(User::getAge))
        .orElse(null);
    log.info("集合中年龄最小的元素为：{}", anyUser);
  }

 

最大2.12

      セット内の最も古い要素を取得します。

  /**
   * 11.max：取集合中年龄最大的元素
   */
  private static void maxTest() {
    List<User> users = getUsers();
    User anyUser = users.stream()
        //.max((u1, u2) -> u1.getAge() - u2.getAge())
        .max(Comparator.comparingInt(User::getAge))
        .orElse(null);
    log.info("集合中年龄最大的元素为：{}", anyUser);
  }

 

2.13anyMatch任意の要素の一致

      セット内のいずれかの要素が条件を満たす場合はtrueを返し、そうでない場合はfalseを返します。

  /**
   * 12.anyMatch：集合中任意一个元素满足条件，返回true；反之，返回false
   */
  private static void anyMatchTest() {
    List<User> users = getUsers();
    boolean matchFlag = users.stream()
        .anyMatch(user -> Objects.equals(user.getName(), "李四"));
    log.info("集合中是否存在名为'李四'的元素：{}", matchFlag);
  }

 

2.14allMatchすべての要素が一致する

      コレクション内のすべての要素が条件を満たす場合はtrueを返し、そうでない場合はfalseを返します。

  /**
   * 13.allMatch：集合中所有元素满足条件，返回true；反之，返回false
   */
  private static void allMatchTest() {
    List<User> users = getUsers();
    boolean matchFlag = users.stream()
        .allMatch(user -> user.getAge() > 20);
    log.info("集合中所有元素的年龄是否都大于20岁：{}", matchFlag);
  }

 

2.15noneMatchすべての要素が一致しない

      コレクション内のすべての要素が条件を満たさない場合はtrueを返し、そうでない場合はfalseを返します。

  /**
   * 14.noneMatch：集合中所有元素都不满足条件，返回true；反之，返回false
   */
  private static void noneMatchTest() {
    List<User> users = getUsers();
    boolean matchFlag = users.stream()
        .noneMatch(user -> user.getAge() <= 20);
    log.info("集合中是否所有元素的年龄都不小于等于20岁：{}", matchFlag);
  }

 

2.16マップ設定値のマッピング

       値のマッピングを設定します。

  /**
   * 15.map：集合值映射
   */
  private static void mapTest() {
    List<User> users = getUsers();
    List<String> names = users.stream()
//        .map(user -> user.getName())
        .map(User::getName)
        .collect(Collectors.toList());
    log.info("集合中所有对象的名称集合为：{}", names);
  }

 

2.17flatMap設定値フラットマッピング

      設定値のフラットマッピング。

  /**
   * 16.flatMap：集合值扁平映射
   */
  private static void flatMapTest() {
    List<User> users = getUsers();
    List<String> allHobbies = users.stream()
        .flatMap(user -> user.getHobbies().stream())
        .collect(Collectors.toList());
    log.info("集合中所有用户的所有兴趣爱好列表：{}", allHobbies);
  }

 

2.18 map + reduce集計評価

      総合評価。

  /**
   * 17.map+reduce：聚合求值
   */
  private static void mapReduceTest() {
    List<User> users = getUsers();
    int ageSum = users.stream()
//        .map(user -> user.getAge())
        .map(User::getAge)
        .reduce(0, (age1, age2) -> age1 + age2);
    log.info("集合中所有用户年龄总和：{}", ageSum);
  }

 

2.19並列並列ストリーム

      並列ストリーム処理。

  /**
   * 18.parallel：并行流处理
   */
  private static void parallelStreamTest() {
    List<User> users = getUsers();
    //下面两种方式等效
    users.stream()
        .parallel()
        .forEach(user -> {
          //业务处理
          log.info(".stream.parallel并行遍历当前元素为：{}", user);
        });
    users.parallelStream()
        .parallel()
        .forEach(user -> {
          //业务处理
          log.info(".parallelStream并行遍历当前元素为：{}", user);
        });
  }

      WeChatパブリックアカウントをフォローし、「ソースコードをストリーミングしたい」と返信して、このチュートリアルのデモソースコード、Java、および関連するビデオチュートリアルを無料で入手してください〜