Java：Stream流

1. Stream流的来源

• 单列集合：如List、Set，可以通过集合对象.stream()创建流。

• 双列集合：如Map，需要先通过entrySet()、keySet()或values()转换为单列集合，再创建流。

• 数组：通过Arrays.stream(数组)创建流。

• 零散数据：通过Stream.of(数据1, 数据2, ...)创建流。

 2. Stream流的常用方法

(1) filter方法

• 作用：过滤流中的元素，保留满足条件的元素。

• 特点：

  • 原来的流只能使用一次，操作后生成新的流。

  • 原数据不会被修改。

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> result = list.stream()
                           .filter(num -> num > 3)
                           .collect(Collectors.toList());
// result: [4, 5]

(2) skip方法

• 作用：跳过前N个元素。

• 示例：

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> result = list.stream()
                           .skip(2)
                           .collect(Collectors.toList());
// result: [3, 4, 5]

(3) limit方法

• 作用：截取前N个元素

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> result = list.stream()
                           .limit(3)
                           .collect(Collectors.toList());
// result: [1, 2, 3]

 (4) distinct方法

• 作用：去重，底层使用HashSet实现。

• 示例：

  List<Integer> list = Arrays.asList(1, 2, 2, 3, 3, 4);
  List<Integer> result = list.stream()
                             .distinct()
                             .collect(Collectors.toList());
  // result: [1, 2, 3, 4]

  (5) concat方法

• 作用：合并两个流。

• 示例：

Stream<Integer> stream1 = Stream.of(1, 2, 3);
Stream<Integer> stream2 = Stream.of(4, 5, 6);
Stream<Integer> result = Stream.concat(stream1, stream2);
result.forEach(System.out::println); // 输出: 1 2 3 4 5 6

(6) map方法

• 作用：将流中的元素映射为另一种类型。

• 重要：常用于数据转换，如将字符串分割为数组。

• 示例：

List<String> list = Arrays.asList("apple", "banana", "cherry");
List<Integer> result = list.stream()
                           .map(String::length)
                           .collect(Collectors.toList());
// result: [5, 6, 6]

(7) forEach方法

• 作用：遍历流中的每个元素。

• 示例：

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
list.stream().forEach(System.out::println); // 输出: 1 2 3 4 5

(8) count方法

• 作用：统计流中元素的数量。

• 示例：

  List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
  long count = list.stream().count();
  System.out.println(count); // 输出: 5

(9) toArray方法

• 作用：将流中的元素收集到数组中。

• 示例：

  List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
  Integer[] array = list.stream().toArray(Integer[]::new);
  System.out.println(Arrays.toString(array)); // 输出: [1, 2, 3, 4, 5]

(10) collect方法

• 作用：将流中的元素收集到集合中。

• 常用：

  • Collectors.toList()：收集到List。

  • Collectors.toSet()：收集到Set。

  • Collectors.toMap()：收集到Map（重点）。

• 示例：

  List<String> list = Arrays.asList("apple", "banana", "cherry");
  Map<String, Integer> map = list.stream()
                                 .collect(Collectors.toMap(
                                     s -> s, // Key
                                     String::length // Value
                                 ));
  System.out.println(map); // 输出: {apple=5, banana=6, cherry=6}

  public class Test2 {
      public static void main(String[] args) {
          ArrayList<String> list = new ArrayList<>();
          Collections.addAll(list, "zjamhsan,23", "lisi,24", "wangwu,25");
          list.stream().
                  filter(s -> Integer.parseInt(s.split(",")[1]) >= 24).
                  collect(Collectors.toMap(new Function<String, String>() {
                      @Override
                      public String apply(String s) {
                          return s.split(",")[0];
                      }
                  }, new Function<String, Integer>() {
                      @Override
                      public Integer apply(String s) {
                          return Integer.parseInt(s.split(",")[1]);
                      }
                  }));
      }
  }

 3.Trips

• Stream流是一次性的，操作后不能重复使用。

• Stream流的操作是惰性的，只有调用终结方法（如collect、forEach）时才会执行。

• 流操作不会修改原数据，而是生成新的流或结果。