首页 > 资讯 > 后端开发 > Python >关于JAVA8的 Stream学习

897

分享到

关于JAVA8的 Stream学习

2024-04-02 19:04:59 897人浏览八月长安

Python 官方文档：入门教程 => 点击学习

摘要

目录一、Stream的使用1 创建2 步骤二、Stream的特性三、中间操作1 filter()2 limit()3 skip()4 map()3.1 flatM

一、Stream的使用

1 创建

通过Collection接口的实现类提供的 stream（）方法，或
通过Arrays中的静态方法 stream（）获取
通过Stream类中的静态方法 of()
无限流(迭代/生成)



public class StreamTests {
    @Test
    public void test(){
        //1.通过Collection接口的实现类提供的 stream（）方法，或
        Collection<String> list = new ArrayList<>();
        list.stream();
        list.parallelStream();
        //2.通过Arrays中的静态方法 stream（）获取
        Integer[] integers = new Integer[10];
        Arrays.stream(integers);
        //3.通过Stream类中的静态方法 of()
        Stream<String> stream = Stream.of("1","2");
        //4.无限流
        //迭代
        Stream<Integer> iterate = Stream.iterate(0, (x) -> x + 2);
        //生成
        Stream<Double> generate = Stream.generate(() -> Math.random());
    }
}

1.1.1并行流parallelStream

parallelStream提供了流的并行处理，它是Stream的另一重要特性，其底层使用Fork/Join框架实现。简单理解就是多线程异步任务的一种实现。

2 步骤

创建Stream；
转换Stream，每次转换原有Stream对象不改变，返回一个新的Stream对象（可以有多次转换）；
对Stream进行聚合（Reduce）操作，获取想要的结果；

二、Stream的特性

惰性求值:

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

三、中间操作

筛选与切片】

1 filter()

接受lambda表达式，从流中排除某些元素


@Test
public void test2(){
    //获取一个数组
    ArrayList<Integer> arrayList = new ArrayList<>();
    for (int i = 0; i <10; i++) {
        arrayList.add(i);
    }
    //流操作：获取大于5的
    arrayList.stream().filter((num)->num>5).forEach(System.out::println);
}
//结果：  6 7 8 9

2 limit()

截断流，使其元素个数不超过一定数量

满足limit的数量后，就短路，不在执行后续操作


@Test
public void test2(){
    //获取一个数组
    ArrayList<Integer> arrayList = new ArrayList<>();
    for (int i = 0; i <10; i++) {
        arrayList.add(i);
    }
    //流操作：获取大于5的
    arrayList.stream().filter((num)->num>5)
                    .limit(2)
                    .forEach(System.out::println);
}
//结果： 6 7

3 skip()

跳过元素，跳过前n个元素，执行后面的元素，如果不足n个则返回空流


@Test
public void test2(){
    //获取一个数组
    ArrayList<Integer> arrayList = new ArrayList<>();
    for (int i = 0; i <10; i++) {
        arrayList.add(i);
    }
    //流操作：获取大于5的
    arrayList.stream().filter((num)->num>5)
                    .skip(2)
                    .forEach(System.out::println);
}
//结果： 8 9
3.3 map()
映射，在方法中使用方法Function< T> 函数型接口 -----> R apply(T t);

@Test
public void  test4(){
    //获取一个list
    List<String> list = Arrays.asList("aaa","bbb","ccc");
    //使用流操作 转化大写
    list.stream().map((str)->str.toUpperCase())
            .forEach(System.out::println);
}

@Test
public void test3(){
    //获取一个list
    List<String> list = Arrays.asList("aaa","bbb","ccc");
    //流操作： 将list中的元素取出
    //第一步使用map取出流，流里存放的还是流
    //因此需要二次foreach
    Stream<Stream<Character>> chs = list.stream().map(StreamTests::getUpper);
            chs.forEach((stream)->{
                stream.forEach(System.out::print);
            });
}
//将str返回为流对象
public static Stream<Character> getUpper(String str){
    List<Character> list = new ArrayList<>();
    for (Character character: str.toCharArray()){
        list.add(character);
    }
    return list.stream();
}
//结果：aaabbbccc

4 map()

映射，在方法中使用方法Function< T> 函数型接口 -----> R apply(T t);


@Test
public void  test4(){
    //获取一个list
    List<String> list = Arrays.asList("aaa","bbb","ccc");
    //使用流操作 转化大写
    list.stream().map((str)->str.toUpperCase())
            .forEach(System.out::println);
}


@Test
public void test3(){
    //获取一个list
    List<String> list = Arrays.asList("aaa","bbb","ccc");
    //流操作： 将list中的元素取出
    //第一步使用map取出流，流里存放的还是流
    //因此需要二次foreach
    Stream<Stream<Character>> chs = list.stream().map(StreamTests::getUpper);
            chs.forEach((stream)->{
                stream.forEach(System.out::print);
            });
}
//将str返回为流对象
public static Stream<Character> getUpper(String str){
    List<Character> list = new ArrayList<>();
    for (Character character: str.toCharArray()){
        list.add(character);
    }
    return list.stream();
}
//结果：aaabbbccc

3.1 flatMap

相当于集合方法的 addAll

即：将流中的流内元素取出，放入一个流中，而不是流内套流


@Test
public void test3(){
    //获取一个list
    List<String> list = Arrays.asList("aaa","bbb","ccc");
    //流操作： 将list中的元素取出
    //第一步使用map取出流，流里存放的还是流
    //因此需要二次foreach
    Stream<Stream<Character>> chs = list.stream().map(StreamTests::getUpper);
            chs.forEach((stream)-> stream.forEach(System.out::print));

    System.out.println("\n=====");
    //方法二：
    //使用flatMap
    list.stream().flatMap(StreamTests::getUpper).forEach(System.out::print);
}

5 sorted


@Test
public void test5(){
    List<String> list = Arrays.asList("aaa", "ccc", "bbbb", "eeeee");
    //自然排序
    list.stream()
            .sorted()
            .forEach(System.out::println);
    System.out.println("=============");
    //定制排序
    list.stream()
            .sorted((x,y)->{
                //如果长度一样，则按照字典排序
                if (x.length() == y.length()){
                    return x.compareTo(y);
                }
                //如果长度不一样则按照长度的降序排序
                else {
                    return y.length() - x.length();
                }
            })
            .forEach(System.out::println);

}

四、终止操作

查找与匹配

1 allMatch


Predicate<? super T> predicate

public class FinalOperation {
    static ArrayList<Student> list;
    
    @BeforeEach
    public void before(){
        //准备集合
        Student student1 = new Student(10,"张三", Student.Status.Sad);
        Student student2 = new Student(20,"李四", Student.Status.Happy);
        Student student3 = new Student(30,"王五", Student.Status.Free);
        Student student4 = new Student(18,"田七", Student.Status.Free);
        Student student5 = new Student(140,"赵六", Student.Status.Tired);
        list = new ArrayList<>();
        list.add(student1);
        list.add(student2);
        list.add(student3);
        list.add(student4);
        list.add(student5);
    }
}
class Student{
    private int age;
    private String name;
    private Status status;

    public int getAge() {
        return age;
    }

    public String getName() {
        return name;
    }

    public Status getStatus() {
        return status;
    }

    
    public enum Status{
        Free,Tired,Happy,Sad;
    }

    public Student(int age, String name, Status status) {
        this.age = age;
        this.name = name;
        this.status = status;
    }
}

    @Test
    public void test1(){
        boolean b = list.stream().allMatch((s) -> s.getAge() > 20);
        System.out.println(b);
    }
//结果： false

2 anyMatch


Predicate<? super T> predicate

@Test
public void test2(){
    boolean b = list.stream().anyMatch((s) -> s.getAge() > 20);
    System.out.println(b);
}
//结果：true

3 noneMatch


Predicate<? super T> predicate

@Test
public void test3(){
    boolean b = list.stream().noneMatch((s) -> s.getAge() > 20);
    System.out.println(b);
}
//结果：false

4 findFirst()

返回第一元素，但结果可能为null，因此使用Optional<T> 来接收,如果为null则可以替换。



@Test
public void test4(){
    Optional<Student> first = list.stream()
            .filter((e) -> e.getStatus().equals(Student.Status.Free))
            .findFirst();
    System.out.println(first);
}
//结果：Optional[Student{age=30, name='王五', status=Free}]

5 findAny()

返回任意一个



@Test
public void test5(){
    Optional<Student> b = list.parallelStream()
            .filter((student -> student.getAge()<30))
            .findAny();
     System.out.println(b.get());
}
//结果： 任意一个年龄小于30的学生

6 count



@Test
public void test6(){
    long count = list.stream().count();
    System.out.println(count);
}
//结果 : 5

7 max



    @Test
    public void test7(){
        Optional<Integer> max = list.stream()
                .map(x->x.getAge())
                .max(Integer::compare);
        System.out.println(max.get());

    }
//结果： 140

8 min



@Test
public void test7(){
    Optional<Integer> max = list.stream()
            .map(x->x.getAge())
            .min(Integer::compare);
    System.out.println(max.get());
}

9 forEach


@Test
public void test2(){
    //获取一个数组
    ArrayList<Integer> arrayList = new ArrayList<>();
    for (int i = 0; i <10; i++) {
        arrayList.add(i);
    }
    //流操作：获取大于5的
    arrayList.stream().filter((num)->num>5)
                    .limit(2)
                    .forEach(System.out::println);
}
//结果： 6 7

10 reduce



    @Test
    public void test8(){
        Integer reduce = list.stream()
                .map(Student::getAge)
                .reduce(0, (x, y) -> x + y);
        System.out.println(reduce);
        //方法二：
        //此方法有可能为null,因此封装为Optional对象
        Optional<Integer> reduce1 = list.stream()
                .map(Student::getAge)
                .reduce(Integer::sum);
        System.out.println(reduce1.get());
    }

11 collect

可以收集为集合类，

可以在收集后进行分组、多级分组、分片



@Test
public void test9(){
    List<Student> collect = list.stream().collect(Collectors.toList());
    collect.forEach(System.out::println);
    //方式二：
    HashSet<Student> collect1 = list.stream().collect(Collectors.toCollection(HashSet::new));
    collect.forEach(System.out::println);
}


@Test
public void test10(){
    Map<Student.Status, List<Student>> collect = list.stream().collect(Collectors.groupingBy((x) -> x.getStatus()));
    System.out.println(collect.size());
    System.out.println(collect);
}

到此这篇关于JAVA8 Stream学习的文章就介绍到这了,更多相关JAVA8 Stream内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！

您可能感兴趣的文档:

点击免费下载>>软考高级考试备考技巧/历年真题/备考精华资料

--结束END--

本文标题: 关于JAVA8的 Stream学习

本文链接: https://www.lsjlt.com/news/134623.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑，方便收藏和打印～

下载Word文档

去做题

猜你喜欢

关于JAVA8的 Stream学习

目录一、Stream的使用1 创建2 步骤二、Stream的特性三、中间操作1 filter()2 limit()3 skip()4 map()3.1 flatM...

99+

2024-04-02
java8新特性-Stream入门学习心得

目录Stream是什么？创建StreamStream常见的操作总结上一篇介绍了Lambda的学习,如果对Lambda表达式还不清晰的同学可以戳一下这个链接：java8新特性-lamb...

99+

2023-03-13

java8新特性 Stream入门学习 java8 Stream
python 关于epoll的学习

在linux中，默认情况下所有的socket都是blocking;当用户进程调用了recvfrom这个系统调用，kernel就开始了IO的第一个阶段：准备数据。对于network io来说，很多时候数据在一开始还没有到达（比...

99+

2023-01-31

python epoll
深入学习java8 中的CompletableFuture

目录1 前言2 简单使用3 异步处理3.1 thenApply3.2 thenAccept 和 thenRun3.3 exceptionally 异常处理3.4 whenComple...

99+

2024-04-02
总结一下关于在Java8中使用stream流踩过的一些坑

Java8的stream流第一个坑: Collectors.toAsList（）其实是new了一个list，在向里面赋值。注意这里Collectors.toList（）的写法，...

99+

2024-04-02
java8的stream怎么取max

这篇文章主要讲解了“java8的stream怎么取max”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“java8的stream怎么取max”吧！java8的stream取max p...

99+

2023-07-05
Java8 Stream collect(Collectors.toMap())的使用

目录Collectors.toMap的用法三个重载的方法Java8 stream特性 Collectors.toMapCollectors.toMap的用法在我们实际开发过程中经常...

99+

2024-04-02
关于slf4j_log4j2源码学习心得

目录日志工厂获取Logger日志输出Logger.info异步日志写入异步日志上下文选择locateContext定位选择日志上下文总结日志工厂获取Logger 获取日志工厂_ge...

99+

2024-04-02
java8的stream如何取max

目录java8的stream取maxjava8 stream详解~聚合（max/min/count)「案例一：获取String集合中最长的元素。」「案例二：获取Integer集合中的...

99+

2023-03-23

java8的stream stream取max java8 stream取max
[Python学习25] 关于函数更多的

在这一章的学习中，做了一些函数和变量的练习。并不是直接运行脚本，而是在脚本中定义了一些函数，把他们导入到Python中通过执行函数的方式运行。先看代码： def break_words(stuff): """This functio...

99+

2023-01-31

函数更多 Python
Java8中Stream的使用方式

目录前言：1. 为什么有经验的老手更倾向于使用Stream2. Stream 的使用方式3. Stream 的创建4. Stream 中间操作5. Stream 终止操作6. Str...

99+

2024-04-02
Java8中Stream的一些神操作

Java8对集合提供了一种流式计算的方式，这种风格将要处理的元素集合看作一种流，流在管道中传输，并且可以在管道的节点上进行处理，比如筛选，排序，聚合等。 Stream A...

99+

2024-04-02
Java关于JDK1.8新特性的Stream流

目录Java的Stream流一、定义二、操作的特征三、代码示例1、生成流2、forEach迭代3、limit方法用于获取指定数量的流4、map5、sorted6、并行（paralle...

99+

2024-04-02
关于golang中死锁的思考与学习

目录1、Golang中死锁的触发条件1.1 书上关于死锁的四个必要条件的讲解1.2 Golang 死锁的触发条件1.3 golang 中阻塞的场景2、死锁案例讲解2.1 案例一：空 ...

99+

2023-03-19

golang 死锁
关于Java8的知识点有哪些

这篇文章主要讲解了“关于Java8的知识点有哪些”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“关于Java8的知识点有哪些”吧！在了解一项新技术之前，我们需要了解我们为什么要去学习它以及它的...

99+

2023-06-16
Java8 Stream教程之collect()的技巧

目录前言正文第一个小玩法将集合通过Stream.collect() 转换成其他集合/数组：第二个小玩法聚合（求和、最小、最大、平均值、分组）总结前言本身我是一个比较偏向少使用S...

99+

2024-04-02
Java8中的Stream的原理是什么

本篇内容主要讲解“Java8中的Stream的原理是什么”，感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷，实用性强。下面就让小编来带大家学习“Java8中的Stream的原理是什么”吧!Stream的组成与特点Stream（流）是一个...

99+

2023-06-15
Java8的Stream()与ParallelStream()的区别说明

Java8 Stream()与ParallelStream()区别 Stream 无状态：指元素的处理不受之前元素的影响；有状态：指该操作只有拿到所有元素之后才能继续下去。非短...

99+

2024-04-02
Java8实战之Stream的延迟计算

目录一、函数式编程1.1 示例一：方法中没有任何操作会修改现有结构1.2 实例二：“尾-递”迭代二、科里化三、函数式数据结构——持久化的四、Stream的延迟计算4.1 列表接口4....

99+

2024-04-02
Java8中Stream API的技巧有哪些

本篇内容介绍了“Java8中Stream API的技巧有哪些”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！ Stream简介Jav...

99+

2023-06-16