Java基础 -＞ Stream流的终止操作(allMatch,findFirst,count,max,forEach),归约,收集

package Test10月;

import org.junit.Test;

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

/**
 * 功能描述:Stream流的终止操作
 * @version 1.0
 * @className Test1007
 * @author: 罗德
 * @create: 2020-10-07 15:25
 */
public class Test1007 {
    /**
     * 功能描述:
     * sream终止操作之allMatch()
     * 所有元素是否满足给定的条件
     * 方法参数描述:无
     */
    @Test
    public void test1() {
        List<Integer> list = Arrays.asList(5, 4, 3, 2, 1, 0);
        Stream<Integer> stream = list.stream();
        /**
         * public abstract boolean allMatch
         * (java.util.function.Predicate<? super T> predicate)
         * 返回此流的所有元素是否与提供的谓词匹配。如果不需要确定结果，则不能对所有元素求值谓词。
         * 如果流为空，则返回true，不计算谓词。 这是短路终端操作。
         */
        boolean allMatch = stream.allMatch(integer -> integer > 1);
        System.out.println(list);//[5, 4, 3, 2, 1, 0]
        System.out.println(allMatch);//false
    }

    /**
     * 功能描述:
     * sream终止操作之anyMatch()
     * 至少有一个元素,是否满足给定的条件
     * 方法参数描述:无
     */
    @Test
    public void test2() {
        List<String> list = Arrays.asList("a", "ab", "bc", "cd");
        Stream<String> stream = list.stream();
        /**
         * public abstract boolean anyMatch
         * (java.util.function.Predicate<? super T> predicate)
         * 返回此流的任何元素是否与提供的谓词匹配。如果不需要确定结果，则不能对所有元素求值谓词。
         * 如果流为空，则返回false，并且不计算谓词。 这是短路终端操作。
         */
        boolean anyMatch = stream.anyMatch(s -> s.contains("a"));
        System.out.println(list);//[a, ab, bc, cd]
        System.out.println(anyMatch);//true
    }

    /**
     * 功能描述:
     * sream终止操作之noneMatch()
     * 没有元素满足给定的条件
     * 方法参数描述:无
     */
    @Test
    public void test3() {
        List<String> list = Arrays.asList("a", "ab", "bc", "cd");
        Stream<String> stream = list.stream();
        /**
         * public abstract boolean noneMatch
         * (java.util.function.Predicate<? super T> predicate)
         * 返回此流中是否没有与提供的谓词匹配的元素。如果不需要确定结果，则不能对所有元素求值谓词。
         * 如果流为空，则返回true，不计算谓词。 这是短路终端操作。
         */
        boolean noneMatch = stream.noneMatch(s -> s.contains("m"));
        System.out.println(list);//[a, ab, bc, cd]
        System.out.println(noneMatch);//true
    }

    /**
     * 功能描述:
     * sream终止操作之findFirst()/findAny
     * 回描述此流的第一个元素的可选值/任意一个
     * 方法参数描述:无
     */
    @Test
    public void test4() {
        List<String> list = Arrays.asList("a", "ab", "bc", "cd");
        Stream<String> stream = list.stream();
        /**
         * public abstract java.util.Optional<T> findFirst()
         * 返回描述此流的第一个元素的可选值，如果流为空，则返回空的可选值。
         * 如果流没有遇到顺序，则可以返回任何元素。 这是短路终端操作。
         */
        Optional<String> first = stream.findFirst();
        //Optional<String> any = stream.findAny();//任意一个
        System.out.println(list);//[a, ab, bc, cd]
        System.out.println(first);//Optional[a]
    }

    /**
     * 功能描述:sream终止操作之count/max/forEach
     * count():返回此流中元素的计数。
     * max():根据提供的比较器返回此流的最大元素
     * forEach():对此流的每个元素执行操作。
     * 方法参数描述:无
     */
    @Test
    public void test5() {
        List<String> list = Arrays.asList("a", "ab", "bc", "cd");
        Stream<String> stream = list.stream();
        System.out.println(stream.count());//4
        System.out.println(list.stream().max((o1, o2) -> o1.compareTo(o2)));//Optional[cd]
        list.stream().forEach(System.out::print);//aabbccd
        System.out.println("外部迭代");
        list.forEach(System.out::print);//aabbccd
    }
    
    /**
     * 功能描述:sream终止操作之归约(计算-如求和)
     * reduce():使用函数对元素进行操作,如累加,返回一个值
     * 方法参数描述:无
     */
    @Test
    public void test6() {
        List<Integer> list = Arrays.asList(5, 4, 3, 2, 1, 0);
        Stream<Integer> stream = list.stream();
        /**
         * public abstract java.util.Optional<T> reduce
         * (java.util.function.BinaryOperator<T> accumulator)
         * 使用关联累加函数对该流的元素执行缩减，并返回一个可选的描述减少值（如果有）。
         * 这是终端操作。
         */
        Optional<Integer> reduce = stream.reduce(Integer::max);
        System.out.println(list);//[5, 4, 3, 2, 1, 0]
        System.out.println(reduce);//Optional[5]

        Stream<Integer> stream1 = list.stream();
        Optional<Integer> reduce1 = stream1.reduce(Integer::sum);
        System.out.println(reduce1);//Optional[15]
    }

    /**
     * 功能描述:sream终止操作之收集collect
     * 使用集合工具的方法来处理stream流,返回一个集合(List,Set)
     * 方法参数描述:无
     */
    @Test
    public void test7() {
        List<Integer> list = Arrays.asList(5, 4, 3, 2, 1, 0);
        Stream<Integer> stream = list.stream();
        /**
         * public abstract <R, A> R collect
         * (java.util.stream.Collector<? super T, A, R> collector)
         * 使用收集器对此流的元素执行可变的缩减操作。这是终端操作
         */
        List<Integer> collect = stream.collect(Collectors.toList());
        System.out.println(collect);//[5, 4, 3, 2, 1, 0]
        Set<Integer> collect1 = list.stream().collect(Collectors.toSet());
        System.out.println(collect1);//[0, 1, 2, 3, 4, 5]
    }
}