java stream 对符合条件的进行操作 java stream find

终端操作会从流的流水线生成结果。其结果可以是任何不是流的值，例如：List、Integer，甚至是 void 。

方法名	描述
allMatch(Predicate p)	检查是否匹配所有元素
anyMatch(Predicate p)	检查是否至少匹配一个元素
noneMatch(Predicate p)	检查是否没有匹配所有元素
findFirst()	返回第一个元素
findAny()	返回当前流中的任意元素
count()	返回流中元素总数
max(Comparator c)	返回流中最大值
min(Comparator c)	返回流中最小值
forEach(Consumer c)	内部迭代(使用 Collection 接口需要用户去做迭代，称为外部迭代。相反，Stream API 使用内部迭代——它帮你把迭代做了)

测试代码

TestFind.java

package java8.find;

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

import org.junit.Test;

/** 
* @autho
* @version 创建时间：2017年12月28日 下午4:07:48 
*/
public class TestFind {
    /**
     * 1.查找与匹配（终止操作，返回结果）:
     *  allMatch(Predicate p)       检查是否匹配所有元素
     *  anyMatch(Predicate p)       检查是否至少匹配一个元素
     *  noneMatch(Predicate p)      检查是否没有匹配所有元素
     *  findFirst()                 返回第一个元素
     *  findAny()                   返回当前流中的任意元素
     *  count()                     返回流中元素总数
     *  max(Comparator c)           返回流中最大值
     *  min(Comparator c)           返回流中最小值
     *  forEach(Consumer c)         内部迭代(使用 Collection 接口需要用户去做迭代，
     *                                  称为外部迭代。相反，Stream API 使用内部迭代
     *                                  ——它帮你把迭代做了)
     */

    List<Integer> listInteger = Arrays.asList(1,2,3,-10,-11,60,80,0,50);

    // 1.allMatch(Predicate p)：是不是所有的元素都匹配条件
    @Test
    public void test1() {
        /**
         * boolean allMatch(Predicate<? super T> predicate)：
         *  返回此流的所有元素是否与提供的谓词匹配。 如果不需要确定结果，则不
         *  能评估所有元素上的谓词。 如果流为空，则true返回和谓语不评估。 
         *  这是一个short-circuiting terminal operation 。 
         * 参数 
         *  predicate - a non-interfering，stateless 谓词适用于此流的元素 
         * 结果 
         *  如果流的所有元素匹配提供的谓词或流是空的返回true，否则 false 
         */
        // 是不是所有的元素都大于0
        boolean allMatch = listInteger.stream().allMatch((e) -> e >0);

        System.out.println(allMatch);
    }

    // 2.anyMatch(Predicate p)：是否有一个元素匹配条件
    @Test
    public void test2() {
        /**
         * boolean anyMatch(Predicate<? super T> predicate)：
         * 返回此流的任何元素是否与提供的谓词匹配。 如果不需要确定结果，
         * 则不能评估所有元素上的谓词。 如果流为空，则false返回和谓语不评估。 
         * 这是一个short-circuiting terminal operation 。 
         * 参数 
         *  predicate -一个 non-interfering ， stateless谓词适用于该流的元素 
         * 结果 
         *  如果流的任何元素匹配提供的谓词返回true，否则为 false 
         */
        // 是不是有一个元素大于79
        boolean anyMatch = listInteger.stream().anyMatch((e) -> e > 79);

        System.out.println(anyMatch);

    }

    // 3.noneMatch(Predicate p)：是不是没有元素满足条件（p）
    @Test
    public void test3() {
        /**
         * boolean noneMatch(Predicate<? super T> predicate)：
         * 返回此流的元素是否与提供的谓词匹配。 如果不需要确定结果，
         * 则不能评估所有元素上的谓词。 如果流为空，则true返回和谓语不评估。 
         * 这是一个short-circuiting terminal operation 。 
         * 参数 
         *  predicate -一个 non-interfering ， stateless谓词适用于该流的元素 
         * 结果 
         *  如果流中没有元素匹配提供的谓词或流是空的返回true，否则 false 
         */
        // 是不是没有元素小于2
        boolean noneMatch = listInteger.stream().noneMatch((e) -> e < 2);

        System.out.println(noneMatch);
    }

    // 4.findFirst():返回第一个元素
    @Test
    public void test4() {
        /**
         * Optional<T> findFirst():
         * 返回描述此流的第一个元素的Optional如果流为空，则返回一个空的Optional 。 
         * 如果流没有遇到顺序，则可能会返回任何元素。 
         * 这是一个short-circuiting terminal operation 。 
         * 结果 
         *  一个 Optional此流的第一个元素的 Optional如果流为空， Optional 
         * 异常 
         *  NullPointerException - 如果选择的元素为空 
         */
        // 返回流中的第一个元素
        Optional<Integer> findFirst = listInteger.stream().findFirst();

        System.out.println(findFirst.get());
    }

    // 5.findAny()：返回任意一个
    @Test
    public void test5() {
        /**
         * Optional<T> findAny()：
         *  返回描述流的一些元素的Optional如果流为空，则返回一个空的Optional 。 
         *  这是一个short-circuiting terminal operation 。 
         *  这个操作的行为显然是不确定的; 可以自由选择流中的任何元素。 
         *  这是为了允许并行操作中的最大性能; 成本是同一来源上的多次调用可能
         *  不会返回相同的结果。 （如果需要稳定的结果，请改用findFirst() ） 
         * 结果 
         *  一个 Optional此流的某些元素的 Optional如果流为空， Optional 
         * 异常 
         *  NullPointerException - 如果选择的元素为空 
         */
        // 从大于0的数中任意选取一个出来
        Optional<Integer> findAny = listInteger.stream()
            .filter((e) -> e > 0)
            .findAny();

        System.out.println(findAny.get());
    }

    // 6.count()：返回流中的元素个数
    @Test
    public void test6() {
        /**
         * long count()：
         *  返回此流中的元素数。 这是一个reduction的特殊情况，相当于： 
         * return mapToLong(e -> 1L).sum();  这是一个terminal operation 。 
         * 结果 
         *  这个流中元素的数量 
         */
        // 统计流中元素的个数
        long count = listInteger.stream().count();

        System.out.println("流中元素个数：" + count);
    }

    // 7.max(Comparator c):返回流中最大值,根据Comparator
    @Test
    public void test7() {
        Comparator<Integer> com = (a,b) -> a - b;

        /**
         * Optional<T> max(Comparator<? super T> comparator)：
         * 根据提供的Comparator返回此流的最大元素。 这是一个reduction的特殊情况。 
         * 这是一个terminal operation 。 
         * 参数 
         *  comparator -一个 non-interfering ， stateless Comparator比较该流的元素 
         * 结果 
         *  一个 Optional此流的最大元素的 Optional如果流为空， Optional 
         * 异常 
         *  NullPointerException - 如果最大元素为空 
         */
        // 返回流中最大的元素，按照Comparator
        Optional<Integer> max = listInteger.stream().max(com);

        System.out.println(max.get());
    }

    // 8.min(Comparator c)：返回流中最小值，按Comparator
    @Test
    public void test8() {
        Comparator<Integer> com = (a,b) -> a-b;

        /**
         * Optional<T> min(Comparator<? super T> comparator)：
         * 根据提供的Comparator返回此流的最小元素。 这是一个reduction的特例 。 
         * 这是一个terminal operation 。 
         * 参数 
         *  comparator -一个 non-interfering ， stateless Comparator比较该流的元素 
         * 结果 
         *  一个 Optional此流的最小元素的 Optional如果流为空， Optional 
         * 异常 
         *  NullPointerException - 如果最小元素为空 
         */
        // 返回流中的最小值，按照Comparator
        Optional<Integer> min = listInteger.stream().min(com);

        System.out.println(min.get());
    }

    // 9.forEach(Consumer c)：内部迭代
    @Test
    public void test9() {
        /**
         * void forEach(Consumer<? super T> action)：
         * 对此流的每个元素执行操作。 
         * 这是一个terminal operation 。 
         * 这个操作的行为显然是不确定的。 对于并行流管道，
         * 此操作不保证遵守流的遇到顺序，因为这样做将牺牲并行性的好处。 
         * 对于任何给定的元素，动作可以在图书馆选择的任何时间和任何线索中执行。
         * 如果操作访问共享状态，则负责提供所需的同步。 
         * 参数 
         *  action - 一个 non-interfering对元素执行的动作 
         */
        // 内部迭代所有元素
        listInteger.stream().forEach(System.out::println);
    }
}

---