JAVA之Stream流

最新推荐文章于 2023-03-24 19:04:24 发布
最新推荐文章于 2023-03-24 19:04:24 发布
阅读量150 收藏
点赞数
分类专栏： JAVA 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41870790/article/details/104276256
版权

传统方法过滤集合


import java.util.ArrayList;
import java.util.List;

/*
    使用传统方式，遍历集合，对集合中的数据进行过滤
 */
public class Demo01List {
    public static void main(String[] args) {
        List<String> list=new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张强");
        list.add("张三丰");

        //对list元素过滤 以张开头的元素存储到一个新的集合中
        List<String> listA=new ArrayList<>();
        for (String s : list) {
            if(s.startsWith("张")){
                listA.add(s);
            }
        }

        //对listB进行过滤 只要姓名长度为3的人 存储到心集合中
        List<String> listB=new ArrayList<>();
        for (String s : listA) {
            if(s.length()==3){
                listB.add(s);
            }
        }

        //遍历listB集合
        for (String s : listB) {
            System.out.println(s);
        }
    }
}

利用Stream流过滤集合


import java.util.ArrayList;
import java.util.List;


public class Demo01List {
    public static void main(String[] args) {
        List<String> list=new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张强");
        list.add("张三丰");

        //对list元素过滤 以张开头的元素存储到一个新的集合中
        //对listB进行过滤 只要姓名长度为3的人 存储到心集合中
        //遍历listB集合
        list.stream().filter(name->name.startsWith("张")).filter(name->name.length()==3).forEach(name-> System.out.println(name));

    }
}

流的获取


import java.util.*;
import java.util.stream.Stream;

/*
    java.util.stream.Stream<T>是java 8新加入的最常用的流接口。（这并不是一个函数式接口）
    获取流：
        所有Collection集合都可以通过stream默认方法获取流
            default Stream<E> stream()
        Stream接口的静态方法of可以获取数组对应的流
            static <T> Stream<T> of(T...values)
            参数是一个可变参数
 */
public class Demo02GetStream {
    public static void main(String[] args) {
        //把集合转换为Stream流
        List<String> list=new ArrayList<>();
        Stream<String> stream1 = list.stream();

        Set<String> set=new HashSet<>();
        Stream<String> stream2 = set.stream();

        Map<String,String> map=new HashMap<>();
        //获取键，存储到set集合中
        Set<String> keySet = map.keySet();
        Stream<String> stream3 = keySet.stream();

        //获取值，存储到一个Collectoin集合中
        Collection<String> values = map.values();
        Stream<String> stream4 = values.stream();

        //获取键值对（键与值映射关系entrySet）
        Set<Map.Entry<String, String>> entries = map.entrySet();
        Stream<Map.Entry<String, String>> stream5 = entries.stream();



        //把数组转换为Stream流
        Stream<Integer> stream6 = Stream.of(1, 2, 3, 4, 5);
        //可变参数可以传递数组
        Integer[] arr={1,2,3,4,5};
        Stream<Integer> stream7 = Stream.of(arr);
        String[] arr2={"a","bb","ccc"};
        Stream<String> stream8 = Stream.of(arr2);

        


    }
}

Stream流中的常用方法

延迟方法：返回值类型仍然是Stream接口自身类型的方法，因此支持链式调用。（除了终结方法，其余方法均为延迟方法。）
终结方法：返回值类型不再是Stream接口自身类型的方法，因此不在支持类似StringBuilder那样的链式调用。常用终结方法count和forEach方法。
注意：
Stream流属于管道流只能被消费（使用）一次
第一个Stream流调用完毕方法，数据就会流转到下一个Stream上
而这时第一个Stream流已经使用完毕，就会关闭了
所以第一个Stream流就不能调用方法了

forEach
import java.util.stream.Stream;

/*
    void forEach(Consumer<? super T> action)
    方法接收一个Consumer函数式接口，会将每一个流元素交给该函数进行处理
    可以传递Lambda表达式，消费数据

    简单记：
        forEach方法，用来遍历流中数据
        是一个终结方法，遍历之后就不能继续调用Stream流中的其他方法
 */
public class Demo02Stream_forEach {
    public static void main(String[] args) {
        //获取一个Stream流
        Stream<String> stream = Stream.of("张三", "李四", "王五", "赵六", "田七");
        //使用Stream流中的方法forEach对Stream流中的数据进行遍历
        stream.forEach(name->System.out.println(name));
    }
}
filter
import java.util.stream.Stream;

/*
    Stream<T> filter(Predicate<? super T> predicate)
    对数据进行过滤  延迟方法
 */
public class Demo02Stream_filter {
    public static void main(String[] args) {
        //创建一个Stream流
        Stream<String> stream = Stream.of("张三丰", "张翠山", "赵敏", "周芷若", "张无忌");
        //对流中的元素进行过滤只要姓张的人
        Stream<String> stream2 = stream.filter(name -> name.startsWith("张"));
        //遍历stream2流
        stream2.forEach(name-> System.out.println(name));


    }
}
map
import java.util.stream.Stream;

/*
    <R> Stream<R> map(Function<? super T,? extends R> mapper)
    延迟方法
 */
public class Demo02Stream_map {
    public static void main(String[] args) {
        //获取一个String类型的Stream流
        Stream<String> stream1 = Stream.of("1", "2", "3", "4");
        //使用map方法把字符串类型的整数，映射成Integer类型整数
        Stream<Integer> stream2=stream1.map(s->Integer.parseInt(s));
        //遍历Stream
        stream2.forEach(name-> System.out.println(name));
    }
}
count
import java.util.ArrayList;
import java.util.stream.Stream;

/*
    long count()
    用于统计Stream流中的元素个数
    终结方法 不能继续调用Stream流中的其他方法
 */
public class Demo02Stream_count {
    public static void main(String[] args) {
        //获取一个Stream流
        ArrayList<Integer> list=new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(6);
        list.add(7);
        Stream<Integer> stream = list.stream();
        long count = stream.count();
        System.out.println(count);
    }
}
limit
import java.util.stream.Stream;

/*
    Stream<T> limit(long maxSize)
    用于截取流中元素 对流中元素截取，只取前n个
    延迟方法    只对流中元素截取 返回新的流
 */
public class Demo02Stream_limit {
    public static void main(String[] args) {
        //获取一个Stream流
        String[] arr={"鲁班七号","安其拉","盘古","狄仁杰"};
        Stream<String> stream = Stream.of(arr);
        //使用limit对Stream流中的元素截取，只要前三个元素
        Stream<String> stream1 = stream.limit(3);
        //遍历
        stream1.forEach(name-> System.out.println(name));
    }
}
skip
import java.util.stream.Stream;

/*
    Stream<T> skip(long n)  跳过前几个元素
    如果希望跳过前几个元素，可以使用skip方法获取一个截取之后的新流：
    如果流的长度大于n，则跳过前n个；否则将会得到一个长度为0的空流

 */
public class Demo02Stream_skip {
    public static void main(String[] args) {
        //获取一个Stream流
        String[] arr={"鲁班七号","安其拉","盘古","狄仁杰"};
        Stream<String> stream = Stream.of(arr);
        //使用skip方法跳过前3个元素
        Stream<String> stream1 = stream.skip(3);
        //遍历
        stream1.forEach(name-> System.out.println(name));

    }
}
concat

import java.util.stream.Stream;

/*
    static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)
    如果两个流，希望合并成为一个流，那么使用Stream接口的静态方法concat
 */
public class Demo02Stream_concat {
    public static void main(String[] args) {
        //获取一个Stream流
        String[] arr={"鲁班七号","安其拉","盘古","狄仁杰"};
        Stream<String> stream1 = Stream.of(arr);
        //创建一个Stream流
        Stream<String> stream2 = Stream.of("张三丰", "张翠山", "赵敏", "周芷若", "张无忌");
        //把以上两个流组合为一个流
        Stream<String> stream = Stream.concat(stream1, stream2);
        //遍历
        stream.forEach(name-> System.out.println(name));
    }
}

综合案例


public class Person {
    private String name;

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }

    public Person(String name) {
        this.name = name;
    }

    public Person() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}



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

public class Demo01StreamTest {
    public static void main(String[] args) {
        //第一支队伍
        ArrayList<String> one=new ArrayList<>();
        one.add("迪丽热巴");
        one.add("宋源桥");
        one.add("苏星河");
        one.add("石破天");
        one.add("始终与");
        one.add("老子");
        one.add("庄子");
        one.add("洪七公");
        //1.第一支队伍只要名字为3个字的成员，存储到新的集合中
        //2.第一支队伍筛选之后只要前三个人，存储到新集合中
        Stream<String> oneStream = one.stream().filter(name -> name.length() == 3).limit(3);

        //第二支队伍
        ArrayList<String> two=new ArrayList<>();
        two.add("古丽拉闸");
        two.add("张无忌");
        two.add("赵丽颖");
        two.add("张三丰");
        two.add("尼古拉斯赵四");
        two.add("张天爱");
        two.add("张二狗");
        //3.第二个队伍只要姓张的，存到新集合中
        //4.第二个队伍筛选之后不要前两个人，存到新集合
        Stream<String> twoStream = two.stream().filter(name -> name.startsWith("张")).skip(2);

        //5.将两个队伍合并为一个队伍
        //6.根据姓名创建Person对象
        //7.打印整个队伍的Person信息
        Stream.concat(oneStream,twoStream).map(name->new Person(name)).forEach(p-> System.out.println(p));


    }
}
落落落Luo
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java8新特性ParallelStream并行流详细说明和注意事项
weixiang2039的博客
07-06 3453
ParallelStream在之前文章Java8新特性-Stream API中有简单的了解过它的使用 如Collection集合可以通过parallelStream()的得到一个并行流 Stream<Integer> stream = new ArrayList<Integer>().parallelStream(); 串行流也可以通过parallel()方法转为并行流 Stream<Integer> stream = new ArrayList<Integer&
Java8 并行流(parallelStream)原理分析及注意事项
Clearlove_S7的博客
04-16 2万+
众所周知，Java 使用Stream流做多线程处理是非常方便的。随着并行编程越来越流行，Java从1.7就开始提供了Fork/Join 支持并行处理，并且在1.8版本进一步加强了相关功能。并行处理就是将任务拆分子任务，分发给多个处理器同时处理之后进行合并。本文将会对并行流(parallelStream)原理分析及注意事项进行详细介绍。
Java 8之Stream适用场景
12-14 635
Stream是Java 8中的一个大的改进。Stream的功能是，支持集合的各种操作，比如filter, sum, max, min, average, map, reduce等等。所以我个人认为Stream的出现是基于以下原因: 增强集合操作拥抱函数式编程充分利用Lambda执行效率的提高 - 透明支持多线程集合操作 笔者尝试测试一下Stream并发处理的威力，发现面对特别简单的
parallelStream、stream.parallel关于集合类遍历并行执行
weixin_44874402的博客
03-24 749
由于在并行执行过程中，使用了ForkJoinPool线程池，所以要考虑线程安全问题：对于ArrayList线程不安全，可以采用Collections.synchronizedList，采用synchronized修饰，或者是CopyOnWriteArrayList，写时复制(读写分离的思想)，用到了lock；在实际使用的过程中，发现其实一个map定义在并行流外并且只读不写，这个map可以用hashmap，如果线程并没有改变变量，可以考虑用非线程安全集合类，提高性能；后续写点线程安全之类的吧！
Parallel Stream(并行流)
m0_53821599的博客
08-17 8652
Parallel Stream(并行流) 以上介绍的创建Stream流对象的3种方法都是创建的串行流(Serial Stream)，串行流就是将源数据转换为一个流对象，然后单线程下执行聚合操作的流（也就是单一管道流） 并行流（Parallel Stream)就是将数据分为多个子流对象进行多线程操作（也就是多个管道流） 如下图介绍： 简述：在创建Stream流对象时，默认创建都是串行流。两种方式创建Stream并行流：第1种方式是通过Collection集合接口中的parallelStream()方法直
Java之Stream流初识
12-22
Java中的Stream流是JDK 1.8引入的一项重要特性，它为处理集合数据提供了全新的方式，特别是结合Lambda表达式，极大地提升了代码的简洁性和可读性。Stream流并不是我们传统理解中的I/O流，而是用于处理数据的一种抽象...
Java Stream 流实现合并操作示例
08-19
Java Stream 流实现合并操作示例 Java Stream 流实现合并操作示例是 Java Stream Api 的一个重要应用场景。在实际开发中，我们经常需要将多个 Stream 流合并成一个流，以便进行后续的数据处理。今天，我们将详细...
详解JAVA Stream流
08-18
Java Stream流详解 Java Stream流是Java 8中引入的一种新的数据处理方式，它提供了一种高效、灵活的数据处理方式，能够帮助开发者更方便地处理大量数据。 Stream流不是一种数据结构，它也不是集合元素，而是一种...
Java Stream流知识总结
08-19
"Java Stream流知识总结" Java Stream流是Java 8中引入的一种新的编程模型，用于解决传统集合类库的弊端。 Stream流可以看作是一个集合元素的函数模型，它并不是集合，也不是数据结构，其本身并不存储任何元素或其...
Java Stream 流的使用过程解析
08-25
Java Stream 流的使用过程解析 Java Stream 流是 Java 8 中引入的一种新的数据处理方式，旨在提供一种高效、灵活的数据处理方法。Stream 流提供了丰富的数据处理功能，可以对数据进行筛选、映射、聚合、分组等操作...
深入浅出parallelStream
热门推荐
梦铃之境的专栏
10-12 9万+
about Stream什么是流？ Stream是java8中新增加的一个特性,被java猿统称为流. Stream 不是集合元素，它不是数据结构并不保存数据，它是有关算法和计算的，它更像一个高级版本的 Iterator。原始版本的 Iterator，用户只能显式地一个一个遍历元素并对其执行某些操作；高级版本的 Stream，用户只要给出需要对其包含的元素执行什么操作，比如 “过滤掉长度大于 1
java Stream使用
X_W_T的博客
01-22 1363
数据集合 ArrayList<Person> list = new ArrayList<>(10); list.add(new Person().setId(0).setAge(10).setName("a")); list.add(new Person().setId(1).setAge(11).setName("b")); list.add(new Person().setId(2).setAge(12).setName("c")); list.add(new Person().
Java8 Stream操作
兒戲BLOG
08-06 2640
package test; import java.util.ArrayList; import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; import java.util.stream.Stream; public class NewFeature { //java8的新特性
Java：什么时候使用Parallel Stream？
藿香正气的博客
11-29 2357
原文：When to Use a Parallel Stream in Java Streams in Java 顺序流 Sequential Stream 默认，Java中的任何流操作都是顺序执行的，除非特别指定为并行。 顺序流是单线程执行的： List<Integer> listOfNumbers = Arrays.asList(1,2,3,4); listOfNumbers.stream().forEach(number -> System.out.println(number +
谈谈并行流parallelStream
阳阳的博客
08-14 2万+
一、parallelStream内部使用了哪些线程 Java8中提供了能够更方便处理集合数据的Stream类，其中parallelStream()方法能够充分利用多核CPU的优势，使用多线程加快对集合数据的处理速度。不熟悉Stream类的同学，可以先参考我的另外一篇文章Java8中Stream的常用方法 以一个简单的例子，来看看parallelStream内部到底使用了哪些线程 Integer[] array = new Integer[]{1, 2, 3, 4, 5};
Java中的parallelStream
qq_25775675的博客
07-09 5129
Java 中的 parallelStream 的底层实现为 ForkJoinPool 。 线程池是所有并行流共享的。 线程池的线程数量和CPU核数一致。 需要等待任务全部执行完毕,主线程(调用线程)才继续往下执行。注意：因为线程池是全局共享的，所以我们尽量不要在 parallelStream 中执行阻塞任务，否则会影响到整个系统中其他的 parallelStream 任务执行的。下面的案例中使用了2个新线程，在其中分别执行 parallelStream 。 线程A启动后，我们暂停2秒，目的是为了让线程A中的
Java并行流ParallelStream你应了解的
lzzyok的专栏
02-11 6337
parallelStream作用 采用多线程可以加快处理集合操作，底层原理是使用线程池ForkJoinPool(深入原理期待你的分享) 并行流一定会比Stream快吗？ 在处理数据量并不大的情况下，“parallelStream（）”的代码有时比使用“stream（）”的代码慢。 因为：parallelStream（）总是需要执行比按顺序执行更多的，在多个线程之间分割工作并合并或组合结果会带来很大的开销。像将短字符串转换为小写字符串这样的用例非常小，与并行拆分开销相比，它们可以忽略不计。 [外链图片转存失败
Java中parallelStream的使用
小贱贱的博客
09-15 1万+
前言: 各位读者们好久不见，最近博主我一直在实习中， 而且也准备校招，刷了很多很多的题目，今天在实习中看到了师兄写的代码中使用到了parallelStream()这个并行流计算，所以我想写一篇博客总结一下这个parallelStream新特性的具体使用。 1、什么是parallelStream? 众所周知，stream流式计算是Java8中新添的一种新特性，可以把stream流理解为串行的流式计算，而parallelStream是一种多线程并行流式计算。 2、parallelStream的作用在哪？或者说有
Java Parallel Stream 源码深入解析
the shy
09-10 831
提出疑问 如何转换流类型，怎么实现的？ 如何切分任务的？ 如何合并任务结果的？ 任务切分 并行流的底层执行是基于ForkJoin框架的，了解的都知道ForkJoin框架要执行的任务逻辑需要使用者重写，重写内容包括如果切分任务，所以去看ForkJoinTask的实现子类如何实现Compute()方法就可以知道如何进行任务切分的。 在AbstractTask类中实现了核心方法。 其中最核心的方法是compute()方法，定义了计算算法的逻辑： /** * 决定是否进一步拆分一个
java之stream流常用方法
最新发布
01-12
以下是Java中Stream流的常用方法： 1. filter()方法：根据指定的条件过滤流中的元素。 ```java List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5); List<Integer> evenNumbers = numbers.stream() .filter(n ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值