Java8新特性-009-Stream查找与匹配-终止操作

终端操作会从流的流水线生成结果。其结果可以是任何不是流的值，例如：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;

/** 
* @author 微信公众号：JavaWeb架构师
* @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 listInteger = Arrays.asList(1,2,3,-10,-11,60,80,0,50);
            
    // 1.allMatch(Predicate p)：是不是所有的元素都匹配条件
    @Test
    public void test1() {
        /**
         * boolean allMatch(Predicate 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 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 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 findFirst():
         * 返回描述此流的第一个元素的Optional如果流为空，则返回一个空的Optional 。 
         * 如果流没有遇到顺序，则可能会返回任何元素。 
         * 这是一个short-circuiting terminal operation 。 
         * 结果 
         *  一个 Optional此流的第一个元素的 Optional如果流为空， Optional 
         * 异常 
         *  NullPointerException - 如果选择的元素为空 
         */
        // 返回流中的第一个元素
        Optional findFirst = listInteger.stream().findFirst();
        
        System.out.println(findFirst.get());
    }
    
    // 5.findAny()：返回任意一个
    @Test
    public void test5() {
        /**
         * Optional findAny()：
         *  返回描述流的一些元素的Optional如果流为空，则返回一个空的Optional 。 
         *  这是一个short-circuiting terminal operation 。 
         *  这个操作的行为显然是不确定的; 可以自由选择流中的任何元素。 
         *  这是为了允许并行操作中的最大性能; 成本是同一来源上的多次调用可能
         *  不会返回相同的结果。 （如果需要稳定的结果，请改用findFirst() ） 
         * 结果 
         *  一个 Optional此流的某些元素的 Optional如果流为空， Optional 
         * 异常 
         *  NullPointerException - 如果选择的元素为空 
         */
        // 从大于0的数中任意选取一个出来
        Optional 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 com = (a,b) -> a - b;
        
        /**
         * Optional max(Comparator comparator)：
         * 根据提供的Comparator返回此流的最大元素。 这是一个reduction的特殊情况。 
         * 这是一个terminal operation 。 
         * 参数 
         *  comparator -一个 non-interfering ， stateless Comparator比较该流的元素 
         * 结果 
         *  一个 Optional此流的最大元素的 Optional如果流为空， Optional 
         * 异常 
         *  NullPointerException - 如果最大元素为空 
         */
        // 返回流中最大的元素，按照Comparator
        Optional max = listInteger.stream().max(com);
        
        System.out.println(max.get());
    }
    
    // 8.min(Comparator c)：返回流中最小值，按Comparator
    @Test
    public void test8() {
        Comparator com = (a,b) -> a-b;
        
        /**
         * Optional min(Comparator comparator)：
         * 根据提供的Comparator返回此流的最小元素。 这是一个reduction的特例 。 
         * 这是一个terminal operation 。 
         * 参数 
         *  comparator -一个 non-interfering ， stateless Comparator比较该流的元素 
         * 结果 
         *  一个 Optional此流的最小元素的 Optional如果流为空， Optional 
         * 异常 
         *  NullPointerException - 如果最小元素为空 
         */
        // 返回流中的最小值，按照Comparator
        Optional min = listInteger.stream().min(com);
        
        System.out.println(min.get());
    }
    
    // 9.forEach(Consumer c)：内部迭代
    @Test
    public void test9() {
        /**
         * void forEach(Consumer action)：
         * 对此流的每个元素执行操作。 
         * 这是一个terminal operation 。 
         * 这个操作的行为显然是不确定的。 对于并行流管道，
         * 此操作不保证遵守流的遇到顺序，因为这样做将牺牲并行性的好处。 
         * 对于任何给定的元素，动作可以在图书馆选择的任何时间和任何线索中执行。
         * 如果操作访问共享状态，则负责提供所需的同步。 
         * 参数 
         *  action - 一个 non-interfering对元素执行的动作 
         */
        // 内部迭代所有元素
        listInteger.stream().forEach(System.out::println);
    }
}

微信公众号：JavaWeb架构师

---

其它

• 源码下载

关注下方公众号，回复：Java8.code

• 欢迎加入交流群：451826376

• 更多信息：www.itcourse.top

完整教程PDF版本下载