常见的jdk8流操作总结

最新推荐文章于 2023-11-29 18:00:00 发布

泰山压顶12138

最新推荐文章于 2023-11-29 18:00:00 发布

阅读量441

点赞数 2

文章标签： java

本文链接：https://blog.csdn.net/qq_27661881/article/details/104371655

版权

流操作可以分为两类：中间操作和终端操作

　中间操作：又可以分为有状态和无状态两种

定义：一个流可以后面跟随零个或多个中间操作。其目的主要是打开流，做出某种程度的数据映射/过滤，然后返回一个新的流，交给下一个操作使用。这类操作都是惰性化的（lazy），就是说，仅仅调用到这类方法，并没有真正开始流的遍历。

　终端操作：又可以分为短路和非短路两种

定义：一个流只能有一个终端操作，当这个操作执行后，流就被使用“光”了，无法再被操作。所以这必定是流的最后一个操作。终端操作的执行，才会真正开始流的遍历，并且会生成一个结果。

中间无状态操作：

可以在单个对单个的数据进行处理。比如：filter（过滤）一个元素的时候，也可以判断，比如map(映射)、filter(过滤)、flatmap（扁平化）、peek（遍历每一个元素）

过滤 filter：过滤掉不符合要求的元素
映射 map：将一个元素转化为另一个元素，比如:将Integer型的对象转换为String型的对象

public void mapTest() {

        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.stream()
                .map(e-> e.toString)
                .forEach(item ->
                        System.out.println(item)));
    }

   扁夹化 flatMap:将一个对象转换成流
    @Test
    public void flatMapTest() {
        list.stream()

                // flatMap
                .flatMap(sku -> Arrays.stream(
                        sku.getSkuName().split("")))

                .forEach(item ->
                        System.out.println(
                                JSON.toJSONString(
                                        item, true)));
    }
   遍厉 peek:对流中元素进行遍历操作，与forEach类似，但不会销毁流元素

public void peek() {
list.stream()

// peek
.peek(sku -> System.out.println(sku.getSkuName()))

                .forEach(item ->
                        System.out.println(
                                JSON.toJSONString(
                                        item, true)));
    }

中间有状态操作：

是在所有的数据基础上进行操作的。比如：去重 distinct、跳过 skip、排序 sorted、截断 limit

去重 distinct

    /**
     * distinct使用：对流元素进行去重。有状态操作
     */
    @Test
    public void distinctTest() {
        list.stream()
                .map(sku -> sku.getSkuCategory())

// distinct
.distinct()

                .forEach(item ->
                        System.out.println(
                                JSON.toJSONString(
                                        item, true)));

}
跳过 skip

    /**
     * skip使用：跳过前N条记录。有状态操作
     */
    @Test
    public void skipTest() {
        list.stream()

.sorted(Comparator.comparing(Sku::getTotalPrice))

// skip
.skip(3)

                .forEach(item ->
                        System.out.println(
                                JSON.toJSONString(
                                        item, true)));
    }

截断 limit

/**
     * limit使用：截断前N条记录。有状态操作
     */
    @Test
    public void limitTest() {
        list.stream()
                .sorted(Comparator.comparing(Sku::getTotalPrice))

.skip(2 * 3)

// limit
.limit(3)

                .forEach(item ->
                        System.out.println(
                                JSON.toJSONString(
                                        item, true)));
    }

排序 sorted

    /**
     * sort使用：对流中元素进行排序，可选则自然排序或指定排序规则。有状态操作
     */
    @Test
    public void sortTest() {
        list.stream()