Java8新特性-006-Stream筛选与切片-中间操作

Stream 的中间操作

多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理！而在终止操作时一次性全部处理，称为“惰性求值”。

---

筛选与切片

方 法	描 述
filter(Predicate p)	接收 Lambda ， 从流中排除某些元素。
distinct()	筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素
limit(long maxSize)	截断流，使其元素不超过给定数量。
skip(long n)	跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补

---

测试代码

TestFilterSlice.java

package java8.filter.slice;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;

import org.junit.Test;

/** 
* @author 微信公众号：JavaWeb架构师
* @version 创建时间：2017年12月27日 下午6:12:16 
*/
public class TestFilterSlice {
    /**
     * 1.中间操作：
     *     多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，
     *      否则中间操作不会执行任何的处理！而在终止操作时一次性全部处理，称为“惰性求值”。
     * 
     * 2.筛选与切片：
     *  filter(Predicate p)     ：接收 Lambda ， 从流中排除某些元素。
     *  distinct()              ：筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素
     *  limit(long maxSize)     ：截断流，使其元素不超过给定数量。
     *  skip(long n)            ：跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，
     *                              则返回一个空流。与 limit(n) 互补
     *
     */
    // 1.filter：筛选
    @Test
    public void test1() {
        List integerList = new ArrayList() {
            {
                add(10);
                add(1);
                add(-10);
                add(-1);
                add(0);
            }
        };
            
        /**
         *  Stream filter(Predicate predicate)：
         * 返回由与此给定谓词匹配的此流的元素组成的流。 
         * 这是一个intermediate operation 。 
         * 参数 
         *      predicate -一个 non-interfering ， stateless谓词应用到每个元素，
         *  以确定是否它应包含。 
         * 结果 
         *      新的流 
         */
        // 过滤其中元素值 大于 0 的元素到新流中。
        Stream newStream = integerList.stream().filter((e)-> e > 0);
        
        // 终止操作，遍历
        newStream.forEach(System.out::println);
    }
    
    // 2.distinct：去重
    @Test
    public void test2() {
        List listInteger = new ArrayList() {
            {
                add(10);
                add(11);
                add(12);
                add(10);
            }
        };
        
        /**
         * Stream distinct()：
         *  返回由该流的不同元素（根据Object.equals(Object) ）组成的流。 
         *  对于有序流，选择不同的元素是稳定的（对于重复的元素，首先在遇到顺序中出
         *  现的元素被保留。）对于无序流，不能保证稳定性。 
         *  这是一个stateful intermediate operation 。 
         */
        // 去掉其中重复的元素：hashCode相等、equals为true的元素。
        Stream stream = listInteger.stream().distinct();
        
        // 终止操作，遍历
        stream.forEach(System.out::println);
    }
    
    // 3.limit：限制元素个数
    @Test
    public void test3() {
        List listInteger = new ArrayList() {
            {
                add(10);
                add(11);
                add(12);
                add(13);
                add(14);
                add(15);
                add(16);
                add(17);
            }
        };
        
        /**
         * Stream limit(long maxSize)：
         *  返回由该流的元素组成的流，截断长度不能超过maxSize 。 
         *  这是一个short-circuiting stateful intermediate operation 。 
 
         */
        // 限制新的流的元素个数，只有5个
        Stream limit = listInteger.stream().limit(5);
        
        // 终止操作，遍历
        limit.forEach(System.out::println);
    }
    
    // 4.skip：跳过元素个数
    @Test
    public void test4() {
        List listInteger = new ArrayList() {
            {
                add(10);
                add(11);
                add(12);
                add(13);
                add(14);
                add(15);
                add(16);
                add(17);
            }
        };
        
        /**
         * Stream skip(long n)：
         *  在丢弃流的第一个n元素后，返回由该流的n元素组成的流。 
         *  如果此流包含少于n元素，那么将返回一个空流。 
         *  这是一个stateful intermediate operation 。 
         */
        // 丢掉前一步结果的前两个元素
        Stream skip = listInteger.stream().skip(2);
        
        skip.forEach(System.out::println);
    }
    
    // “惰性求值”
    @Test
    public void test5() {
        /**
         * 中间操作不会立即执行，在执行终止操作时一次性完成。
         */
        List listInteger = new ArrayList() {
            {
                add(10);
                add(11);
                add(12);
                add(13);
                add(14);
                add(15);
                add(16);
            }
        };
        
        Stream filter = listInteger.stream().filter((e) -> {
            System.out.println("正在进行过滤操作！");
            return e > 12;
        });
        
        System.out.println("下面进行终止操作……");
        
        // 所有的中间操作，在进行终止操作时才会真正的执行
        filter.forEach(System.out::println);
    }
}

微信公众号：JavaWeb架构师

---

其它

• 源码下载

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

• 欢迎加入交流群：451826376

• 更多信息：www.itcourse.top

完整教程PDF版本下载