Java 8实战阅读-Stream 查找&替换 VS 归约reduce

Java 8实战阅读笔记--Stream流的使用

1、查找和替换(anyMatch/allMatch/noneMatch/findAny/findFirst)

A、注意点：

* findFirst & findAny差异：
* 为什么会同时有findFirst和findAny呢？答案是并行。
* (1)、找到第一个元素在并行上限制更多。
* (2)、如果你不关心返回的元素是哪个，请使用findAny，因为它在使用并行流时限制较少

B、Java 8的库设计人员引入了Optional<T> 这样就不用返回众所周知容易出问题的null了。

Optional里面几种可以迫使你显式地检查值是否存在或处理值不存在的情形的方法:

* (1)、isPresent()将在Optional包含值的时候返回true, 否则返回false。
* (2)、ifPresent(Consumer<T> block)会在值存在的时候执行给定的代码块(Consumer函数式接口；它让你传递一个接收T类型参数，并返回void的Lambda 表达式)
* (3)、T get()会在值存在时返回值，否则抛出一个NoSuchElement异常。
* (4)、T orElse(T other)会在值存在时返回值，否则返回一个默认值(即入参other)

实践代码如下：

package com.csdn.test;

import java.util.Arrays;
import java.util.List;
import java.util.Optional;

/**
 * stream 查找和替换
 */
public class TestStreamFindAndMatch
{

    public static void testMatch(List<String> strList)
    {
        boolean flag = strList.stream()
                       // 流中是否有一个元素能匹配给定的谓词 (终结操作--返回boolean)
                       .anyMatch(String::isEmpty);
                       // allMatch 所有都匹配   noneMatch 没有元素匹配
        System.out.println("AnyMatch-->" + flag);
    }
    
    public static void testFind(List<String> strList)
    {
        /**
         * findFirst & findAny差异：
         * 为什么会同时有findFirst和findAny呢？答案是并行。
         * 1、找到第一个元素在并行上限制更多。
         * 2、如果你不关心返回的元素是哪个，请使用findAny，因为它在使用并行流时限制较少
         */
        Optional<String> str = strList.stream()
                               // 返回当前流中的任意元素 (终结操作--返回boolean)
                               .findAny();
                               // findFirst 返回第一个元素
                        /**
                         * Optional<T>类（java.util.Optional）是一个容器类，代表一个值存在或不存在 
                         * findAny可能什么元素都没找到，因此，Java 8的库设计人员引入了Optional<T> 这样就不用返回众所周知容易出问题的null了 
                         */
        optionalOper(str);
    }
    
    public static void optionalOper(Optional<String> str)
    {
        /**
         * Optional里面几种可以迫使你显式地检查值是否存在或处理值不存在的情形的方法: 
         * 1、isPresent()将在Optional包含值的时候返回true, 否则返回false。  
         * 2、ifPresent(Consumer<T> block)会在值存在的时候执行给定的代码块(Consumer函数式接口；它让你传递一个接收T类型参数，并返回void的Lambda 表达式)
         * 3、T get()会在值存在时返回值，否则抛出一个NoSuchElement异常。  
         * 4、T orElse(T other)会在值存在时返回值，否则返回一个默认值(即入参other)
         */
        // str.ifPresent(System.out::println);
        System.out.println(str.orElse("111"));
    }
    
    
    public static void main(String[] args)
    {
        List<String> strList = Arrays.asList(new String[]{});
        testMatch(strList);
        testFind(strList);
    }

}

输出：

AnyMatch-->false
111

2、reduce--归约操作，函数依次作用于上一次函数的结果(有初始值则第一次为初始值)和流中的下一个元素

以下图例摘自《Java8实战》5.4节

实践代码：

package com.csdn.test;

import java.util.Arrays;
import java.util.List;
import java.util.Optional;

/**
 * stream 归约操作
 * 元素两两进行函数操作，最终所有元素完成函数操作
 */
public class TestStreamReduce
{

    public static void testReduce(List<Integer> intList)
    {
        // 有初始值,返回Integer
        int sum = intList.stream()
                       .reduce(0, Integer::sum);
        System.out.println("sum reduce-->" + sum);
    }
    
    public static void testReduceOptional(List<Integer> intList)
    {
        // 无初始值，返回 Optional<Integer>
        // 取最小值
        Optional<Integer> min = intList.stream()
                                       .reduce(Integer::min);
        System.out.println("sum reduce-->" + min.get());
    }
    
    
    public static void main(String[] args)
    {
        List<Integer> strList = Arrays.asList(new Integer[]{1});
        testReduce(strList);
        testReduceOptional(strList);
    }

}

输出：

sum reduce-->1
min reduce-->1