Java8实战 流处理stream

目录

      • 基本流
        • 中间操作与终端操作
        • 一些常见的终端操作
      • 进阶流
        • 筛选各异的元素
        • 截断
        • 跳过元素
      • 映射流
        • map
        • flatMap
        • 匹配
        • 全匹配与非全匹配
      • Optional
        • findAny
        • findFirst
      • 归约
        • 求和
        • 归约相关阐发
      • 数值流
        • boxed
        • range
      • 构建流
        • 创建流的三种方式


基本流

foreach 实现了外部迭代,它是建立于集合的基础上;
stream 流实现的是内部迭代


中间操作与终端操作

对任意集合使用 stream() 方法来使用流操作来对其进行内部迭代;

中间操作:流水线上的中间操作,他会返回一个 stream

终端操作:一般位于流水线末尾,输出一个非 stream 类型的值

这是下方代码的完整运行过程:

  1. 首先使用 stream 方法使用流来处理集合 names
  2. 使用过滤器 filter,过滤出字符串中含有字符 a 的字符串
  3. distinct 进行去重
  4. toList 将以上所有中间操作过后得到的结果进行汇总,转换成 list 并输出
public static void main(String[] args) {
    List<String> strings = new ArrayList<>();
    strings.add("asd");
    strings.add("asd");
    strings.add("qwe");

    List<String> names = strings.stream()
            // 过滤
            .filter(d -> {
                return d.contains("a");
            })
            // 去重
            .distinct()
            // 转换成列表
            .toList();
    for (String name : names) System.out.println(name); // 输出:asd
}

一些常见的终端操作

foreach:消费流中所有元素并使用 lambda,该操作返回 void

count:返回流中的元素个数,返回类型为 long

collect:把流处理结果返回成一个集合,譬如 toList 方法


进阶流

筛选各异的元素

distinct 进行去重

public static void main(String[] args) {
    List<Integer> numbers = Arrays.asList(1, 2, 3, 1, 2, 4, 2, 2);
    numbers.stream()
            .filter(i -> i % 2 == 0)
            .distinct()
            .forEach(System.out::println);
}

截断

limit,做多返回前 n 个元素

public static void main(String[] args) {
    List<Integer> numbers = Arrays.asList(1, 2, 3, 1, 2, 4, 2, 2);
    numbers.stream()
            .limit(3)
            .forEach(System.out::println);
}

跳过元素

skip(4) 表示跳过前四个元素,并返回后面所有的元素;

由于代码都差不多,这里不做过多演示


映射流

map

map 接收一个函数作为参数,他将对集合中的每个元素应用该函数,并返回该函数规定的值;

如下代码使用 map 获取了每个 dish 的名称并返回它,由此生成了由 dishname 构成的列表

public static void main(String[] args) {
    List<Dish> dishes = new ArrayList<>();
    dishes.add(new Dish("apple", true, 120, Dish.Type.FRUIT));
    dishes.add(new Dish("pork", false, 900, Dish.Type.MEAT));
    dishes.add(new Dish("fish", false, 400, Dish.Type.FISH));

    List<String> dishNames = dishes.stream()
            .map(Dish::getName)
            .toList();
    dishes.forEach(System.out::println);
}

flatMap

map 是将每个元素都映射成了一个流;

flatMap 是将每个元素都放如同一个流中!

以下代码实现:提取单词表中出现的单词;
Arrays.stream 可以将集合转换成流的形式;

应当首先应用 map,将元素进行映射后,在使用 flatMap 把这些映射完毕的元素全部装入一个统一的流里面!

public static void main(String[] args) {
    // 创建单词表
    String[] words = {"goodbye", "hello", "night"};
    // 将单词表转换成流的形式
    Stream<String> swords = Arrays.stream(words);

    // 首先使用map,将所有字母都一一分割来开
    List<String> strings = swords.map(word -> word.split(""))
            // 使用扁平map,将提取到的字母装入一个流中
            .flatMap(Arrays::stream)
            // 字母去重
            .distinct()
            // 转换成列表
            .toList();
    strings.forEach(System.out::println);
}

匹配

anyMatch 能应答:流中是否有至少有一个元素能匹配所给定的谓词(方法引用)

public static void main(String[] args) {
    List<Dish> dishes = Menu.getMenu();
    if(dishes.stream().anyMatch(Dish::isVegetarian)){
        System.out.println("至少有一个素菜!");
    }
}

全匹配与非全匹配

allMatch 方法检查谓词能否匹配所有元素;

noneMatch 方法作用与 allMatch 方法完全相反;


Optional

findAny

findAny 方法默认返回一个 Optional

ifPresent 会在值存在的时候执行后面的 lambda 函数

public static void main(String[] args) {
    List<Dish> dishes = Menu.getMenu();
    dishes.stream()
            .filter(Dish::isVegetarian)
            .findAny()
            .ifPresent(d -> System.out.println(d.getName()));
}

findFirst

顾名思义,找到集合中的第一个元素


归约

求和

下方展示了三种求和方式:

  1. 直接使用 arrays 函数自带的 sum 方法求和;
  2. 使用 reduce,参数一表示初始值,参数二为对值的操作
  3. 同样使用 reduce,但是引入了谓词!
public static void main(String[] args) {
    int[] nums = {1, 2, 3, 4, 5};

    int sum = Arrays.stream(nums).sum();
    int sum2 = Arrays.stream(nums)
            .reduce(0, (a, b) -> a + b);
    int sum3 = Arrays.stream(nums)
            .reduce(0, Integer::sum);
}

归约相关阐发

map+reduce 常被作为一种形式来进行并行化;

使用 reduce 进行的迭代被内部抽象化掉了,所以有益于并行的执行;

parallelStream 可以方便的进行并行操作,但是也带来了同步不安全的隐患;


数值流

使用 mapToInt 返回特化的 IntStream

public static void main(String[] args) {
    List<Dish> dishes = Menu.getMenu();
    int sum = dishes.stream()
            .mapToInt(Dish::getCalories)
            .sum();

}

boxed

将某个特化流转换成一般流,可以使用 boxed 方法

IntStream is = dishes.stream().mapToInt(Dish::getCalories);
Stream<Integer> sis = is.boxed();

range

针对特化流 IntStream 和 LongStream,他们均有 range 和 rangeClose 方法;

range:遍历范围内所有数字除了右边界数字
rangeClose:遍历包含右边界的所有范围数字

下面代码展示了获取 1-100 内所有偶数的个数

IntStream evenNumbers = IntStream.rangeClosed(1,100)
        .filter(n->n%2==0);
System.out.println(evenNumbers.count());

构建流

创建流的三种方式

Stream.of(xxx) 通过数值直接构建;

Arrays.stream() 数组创建;

File.lines() 通过获取的文件内容创建;


你可能感兴趣的:(Java,java,算法,数据结构)