WebFlux响应式编程基础之 3 Stream 流 编程

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

流水线
外部迭代和内部迭代
惰性求值
惰性求值就是终止没有调用的情况下，中间操作不会执行

package stream;

import java.util.stream.IntStream;

public class StreamDemo1 {

    public static void main(String[] args) {
        int[] nums = { 1, 2, 3 };
        // 外部迭代
        int sum = 0;
        for (int i : nums) {
            sum += i;
        }
        System.out.println("结果为：" + sum);

        // 使用stream的内部迭代
        // map就是中间操作（返回stream的操作）
        // sum就是终止操作
        int sum2 = IntStream.of(nums).map(StreamDemo1::doubleNum).sum();
        System.out.println("结果为：" + sum2);

        System.out.println("惰性求值就是终止没有调用的情况下，中间操作不会执行");
        IntStream.of(nums).map(StreamDemo1::doubleNum);
    }

    public static int doubleNum(int i) {
        System.out.println("执行了乘以2");
        return i * 2;
    }

}

短路操作

流的创建
这里写图片描述

package stream;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class StreamDemo2 {

    public static void main(String[] args) {
        List<String> list = new ArrayList<>();

        // 从集合创建
        list.stream();
        list.parallelStream();

        // 从数组创建
        Arrays.stream(new int[] { 2, 3, 5 });

        // 创建数字流
        IntStream.of(1, 2, 3);
        IntStream.rangeClosed(1, 10);

        // 使用random创建一个无限流
        new Random().ints().limit(10);
        Random random = new Random();

        // 自己产生流
        Stream.generate(() -> random.nextInt()).limit(20);

    }

}

流的中间操作
这里写图片描述

package stream;

import java.util.Random;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class StreamDemo3 {

    public static void main(String[] args) {
        String str = "my name is 007";

        // 把每个单词的长度调用出来
        Stream.of(str.split(" ")).filter(s -> s.length() > 2)
                .map(s -> s.length()).forEach(System.out::println);

        // flatMap A->B属性(是个集合), 最终得到所有的A元素里面的所有B属性集合
        // intStream/longStream 并不是Stream的子类, 所以要进行装箱 boxed
        Stream.of(str.split(" ")).flatMap(s -> s.chars().boxed())
                .forEach(i -> System.out.println((char) i.intValue()));

        // peek 用于debug. 是个中间操作,和 forEach 是终止操作
        System.out.println("--------------peek------------");
        Stream.of(str.split(" ")).peek(System.out::println)
                .forEach(System.out::println);

        // limit 使用, 主要用于无限流
        new Random().ints().filter(i -> i > 100 && i < 1000).limit(10)
                .forEach(System.out::println);

    }

}

这里写图片描述

package stream;

import java.util.List;
import java.util.Optional;
import java.util.OptionalInt;
import java.util.Random;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class StreamDemo4 {

    public static void main(String[] args) {
        String str = "my name is 007";

        // 使用并行流
        str.chars().parallel().forEach(i -> System.out.print((char) i));
        System.out.println();
        // 使用 forEachOrdered 保证顺序
        str.chars().parallel().forEachOrdered(i -> System.out.print((char) i));

        // 收集到list
        List<String> list = Stream.of(str.split(" "))
                .collect(Collectors.toList());
        System.out.println(list);

        // 使用 reduce 拼接字符串
        Optional<String> letters = Stream.of(str.split(" "))
                .reduce((s1, s2) -> s1 + "|" + s2);
        System.out.println(letters.orElse(""));

        // 带初始化值的reduce
        String reduce = Stream.of(str.split(" ")).reduce("",
                (s1, s2) -> s1 + "|" + s2);
        System.out.println(reduce);

        // 计算所有单词总长度
        Integer length = Stream.of(str.split(" ")).map(s -> s.length())
                .reduce(0, (s1, s2) -> s1 + s2);
        System.out.println(length);

        // max 的使用
        Optional<String> max = Stream.of(str.split(" "))
                .max((s1, s2) -> s1.length() - s2.length());
        System.out.println(max.get());

        // 使用 findFirst 短路操作
        OptionalInt findFirst = new Random().ints().findFirst();
        System.out.println(findFirst.getAsInt());
    }

}

并行流

package stream;

import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.TimeUnit;
import java.util.stream.IntStream;

public class StreamDemo5 {

    public static void main(String[] args) {
        // 调用parallel 产生一个并行流
        // IntStream.range(1, 100).parallel().peek(StreamDemo5::debug).count();

        // 现在要实现一个这样的效果: 先并行,再串行
        // 多次调用 parallel / sequential, 以最后一次调用为准.
        // IntStream.range(1, 100)
        // // 调用parallel产生并行流
        // .parallel().peek(StreamDemo5::debug)
        // // 调用sequential 产生串行流
        // .sequential().peek(StreamDemo5::debug2)
        // .count();

        // 并行流使用的线程池: ForkJoinPool.commonPool
        // 默认的线程数是 当前机器的cpu个数
        // 使用这个属性可以修改默认的线程数
        // System.setProperty("java.util.concurrent.ForkJoinPool.common.parallelism","20");
        // IntStream.range(1, 100).parallel().peek(StreamDemo5::debug).count();

        // 使用自己的线程池, 不使用默认线程池, 防止任务被阻塞
        // 线程名字 : ForkJoinPool-1
        ForkJoinPool pool = new ForkJoinPool(20);
        pool.submit(() -> IntStream.range(1, 100).parallel()
                .peek(StreamDemo5::debug).count());
        pool.shutdown();

        //守护线程退出
        synchronized (pool) {
            try {
                pool.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void debug(int i) {
        System.out.println(Thread.currentThread().getName() + " debug " + i);
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void debug2(int i) {
        System.err.println("debug2 " + i);
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

收集器

package stream;

import java.util.Arrays;
import java.util.IntSummaryStatistics;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
import java.util.stream.Collectors;

import org.apache.commons.collections4.MapUtils;

/**
 * 学生 对象
 */
class Student {
    /**
     * 姓名
     */
    private String name;

    /**
     * 年龄
     */
    private int age;

    /**
     * 性别
     */
    private Gender gender;

    /**
     * 班级
     */
    private Grade grade;

    public Student(String name, int age, Gender gender, Grade grade) {
        super();
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.grade = grade;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Grade getGrade() {
        return grade;
    }

    public void setGrade(Grade grade) {
        this.grade = grade;
    }

    public Gender getGender() {
        return gender;
    }

    public void setGender(Gender gender) {
        this.gender = gender;
    }

    @Override
    public String toString() {
        return "[name=" + name + ", age=" + age + ", gender=" + gender
                + ", grade=" + grade + "]";
    }

}

/**
 * 性别
 */
enum Gender {
    MALE, FEMALE
}

/**
 * 班级
 */
enum Grade {
    ONE, TWO, THREE, FOUR;
}

public class CollectDemo {

    public static void main(String[] args) {
        // 测试数据
        List<Student> students = Arrays.asList(
                new Student("小明", 10, Gender.MALE, Grade.ONE),
                new Student("大明", 9, Gender.MALE, Grade.THREE),
                new Student("小白", 8, Gender.FEMALE, Grade.TWO),
                new Student("小黑", 13, Gender.FEMALE, Grade.FOUR),
                new Student("小红", 7, Gender.FEMALE, Grade.THREE),
                new Student("小黄", 13, Gender.MALE, Grade.ONE),
                new Student("小青", 13, Gender.FEMALE, Grade.THREE),
                new Student("小紫", 9, Gender.FEMALE, Grade.TWO),
                new Student("小王", 6, Gender.MALE, Grade.ONE),
                new Student("小李", 6, Gender.MALE, Grade.ONE),
                new Student("小马", 14, Gender.FEMALE, Grade.FOUR),
                new Student("小刘", 13, Gender.MALE, Grade.FOUR));

        // 得到所有学生的年龄列表
        // s -> s.getAge() --> Student::getAge , 不会多生成一个类似 lambda$0这样的函数
        Set<Integer> ages = students.stream().map(Student::getAge)
                .collect(Collectors.toCollection(TreeSet::new));
        System.out.println("所有学生的年龄:" + ages);

        // 统计汇总信息
        IntSummaryStatistics agesSummaryStatistics = students.stream()
                .collect(Collectors.summarizingInt(Student::getAge));
        System.out.println("年龄汇总信息:" + agesSummaryStatistics);

        // 分块
        Map<Boolean, List<Student>> genders = students.stream().collect(
                Collectors.partitioningBy(s -> s.getGender() == Gender.MALE));
        // System.out.println("男女学生列表:" + genders);
        MapUtils.verbosePrint(System.out, "男女学生列表", genders);

        // 分组
        Map<Grade, List<Student>> grades = students.stream()
                .collect(Collectors.groupingBy(Student::getGrade));
        MapUtils.verbosePrint(System.out, "学生班级列表", grades);

        // 得到所有班级学生的个数
        Map<Grade, Long> gradesCount = students.stream().collect(Collectors
                .groupingBy(Student::getGrade, Collectors.counting()));
        MapUtils.verbosePrint(System.out, "班级学生个数列表", gradesCount);

    }

}

Stream运行机制

package stream;

import java.util.Random;
import java.util.concurrent.TimeUnit;
import java.util.stream.Stream;

/**
 * 验证stream运行机制
 * 
 * 1. 所有操作是链式调用, 一个元素只迭代一次 
 * 2. 每一个中间操作返回一个新的流. 流里面有一个属性sourceStage 
 *     指向同一个 地方,就是Head 
 * 3. Head->nextStage->nextStage->... -> null
 * 4. 有状态操作会把无状态操作阶段,单独处理
 * 5. 并行环境下, 有状态的中间操作不一定能并行操作.
 * 
 * 6. parallel/ sequetial 这2个操作也是中间操作(也是返回stream)
 *      但是他们不创建流, 他们只修改 Head的并行标志
 * 
 *
 */
public class RunStream {

    public static void main(String[] args) {
        Random random = new Random();
        // 随机产生数据
        Stream<Integer> stream = Stream.generate(() -> random.nextInt())
                // 产生500个 ( 无限流需要短路操作. )
                .limit(500)
                // 第1个无状态操作
                .peek(s -> print("peek: " + s))
                // 第2个无状态操作
                .filter(s -> {
                    print("filter: " + s);
                    return s > 1000000;
                })
                // 有状态操作
                .sorted((i1, i2) -> {
                    print("排序: " + i1 + ", " + i2);
                    return i1.compareTo(i2);
                })
                // 又一个无状态操作
                .peek(s -> {
                    print("peek2: " + s);
                }).parallel();

        // 终止操作
        stream.count();
    }

    /**
     * 打印日志并sleep 5 毫秒
     * 
     * @param s
     */
    public static void print(String s) {
        // System.out.println(s);
        // 带线程名(测试并行情况)
        System.out.println(Thread.currentThread().getName() + " > " + s);
        try {
            TimeUnit.MILLISECONDS.sleep(5);
        } catch (InterruptedException e) {
        }
    }

}

有状态操作会把无状态操作阶段截断,单独处理

无状态操作基本都是一个参数

有转态操作一般两个参数

中间操作返回流

终止操作 短路操作
这里写图片描述

【微服务】spring webflux响应式编程使用详解
congge
10-18 6044
webflux使用详解
spring webflux响应式编程使用详解
最新发布
weixin_36873225的博客
09-19 1087
webflux,即响应式编程,响应式编程是一种用于处理异步数据流和事件的编程范式,spring webflux是spring在5.0版本后提供的一套响应式编程风格的web开发框架。
JDK新语法 之 Stream
有一个小阿飞
12-23 320
Stream是数据渠道，用于操作集合、数组等。 集合讲的是数据，Stream讲的是计算，即Stream是对集合的一系列操作过程。 注意： 1、Stream不会自己存储元素 2、Stream不会改变源对象，它会返回一个持有操作结果的新Stream 3、Stream操作是延迟执行的，这意味着他们会等到需要结果的时候才执行 Employee实体类，后面会用到 package com.lee.jdk.En...
[JDK8] Stream
weixin_34246551的博客
04-23 73
1　collect(toList()) collect(toList()) 方法由Stream 里的值生成一个列表，是一个及早求值操作。 2　map 如果有一个函数可以将一种类型的值转换成另外一种类型，map 操作就可以使用该函数，将一个流中的值转换成一个新的流。 3　filter 遍历数据并检查其中的元素时，可尝试使用Stream 中提供的新方法filter 4　flatMap f...
JDK8之Stream流
bluede2015的博客
04-01 1130
Stream流式思想类似于工厂车间的“生产流水线”，Stream流不是一种数据结构，不保存数据，而是对数据进行加工 处理。
【Java】JDK8新特性(Stream)
源僧
05-28 2085
文章目录简介主要内容Lambda表达式Lambda表达式的简化Lambda 表达式语法类型推断函数式接口什么是函数式接口自定义函数式接口使用参数传递Lambda表达式Java内置四大核心函数式接口其它接口方法的引用与构造器引用方法引用构造器引用数组引用强大的Stream API了解Stream什么是StreamStream的操作三个步骤创建Stream由数组创建流由值创建流由函数创建流：创建无限流Stream 的中间操作筛选与切片映射排序Stream 的终止操作查找与匹配归约收集并行流与串行流了解 Fork
Jdk8 之 Stream流详细用法(一)
木字楠的博客
11-14 3880
本篇文章参考云深i不知处的文章 原文链接：https://blog.csdn.net/mu_wind/article/details/109516995 一、概述   Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简而言之，Stream API 提供了一种高效且易于使用的处理数据的方
WebFlux 响应式编程 2 - Stream
weixin_42167897的博客
08-06 232
intStream longStream 非Stream子类 需要boxed装箱 flatMap(s -> s.chars.boxed()) 拆箱.intValue。每一个中间操作返回一个新的流 流的sourceStage指向同一处head->nextStage-nextStage。parallel/sequetial也是中间操作 不创建流只修改head的并行标志。分块 .partitioningBy() 2块。汇总.summarizingInt()分组.groupingBy()...
WebFlux响应式编程
BBinChina的专栏
02-15 1277
文章目录概要入门WebFluxWebClient 概要 在SpringMvc框架下，http的请求是同步的，在某些场景下为了提供性能，可以采用异步的方式来进行优化。WebFlux便是提供了异步的技术栈 响应式编程（reactive programming）是一种基于数据流（data stream）和变化传递（propagation of change）的声明式（declarative）的编程范式 WebFlux经常会跟响应式编程挂钩，其实其只不过是响应式编程中的一部分技术，代表的是web控制端实现异步
响应式编程（二）——webflux
weixin_50458070的博客
01-24 926
WebFlux：底层完全基于netty+reactor+springweb 完成一个全异步非阻塞的web响应式框架：异步 + 消息队列(内存) + 事件回调机制 = 整套系统：能使用少量资源处理大量请求；
Spring Boot进阶(66)：翻转编程思路，探索Spring Boot响应式编程和WebFlux
**My Coding Family**
09-03 1530
本文将介绍Spring Boot中的响应式编程以及WebFlux的使用。响应式编程是一种编程范式，它强调数据流的异步处理和响应式编程模型，能够提高程序性能和可伸缩性。WebFlux是Spring框架中的一个响应式Web框架，它支持响应式编程模式，能够轻松地处理高并发的Web请求。本文将对WebFlux的使用进行详细介绍，并提供源代码和测试用例
jdk 8 Stream介绍
moren2016的博客
05-26 384
函数式编程-Stream流 概述 //查询未成年作家的评分在70以上的书籍 作家和书籍可能出现重复，需要进行去重 List bookList = new ArrayList<>(); Set uniqueBookValues = new HashSet<>(); Set uniqueAuthorValues = new HashSet<>(); for (Author author : authors) { if (uniqueAuthorValues.add(aut
jdk8中Stream的使用
qq_58267473的博客
06-09 485
一个数据源( 如: 集合、数组 ) , 获取一个流一个中间操作链,对数据源的数据进行处理一旦执行终止操作,就执行中间操作链,并产生结果.之后,就不会再被使用 List<Integer> list = Arrays.asList(1, 2, 3, 4, 5); Stream<Integer> stream = list.stream(); 方式二:通过数组 Integer[] arr={1,2,3,4}; Stream<Integer> stream = Arrays
jdk8新特性-stream
一张小羊毛的博客
01-18 2213
以一种声明的方式处理数据。让程序员写出高效率、干净、简洁的代码。将要处理的元素集合看作一种流， 流在管道中传输， 并且可以在管道的节点上进行处理， 比如筛选， 排序，聚合等。元素流在管道中经过中间操作（intermediate operation）的处理，最后由最终操作(terminal operation)得到前面处理的结果。
JDK Stream
曲怪曲怪
12-21 528
JDK Stream
JDK-Stream
qq_51972847的博客
11-22 194
1.Stream 1.前沿 ​ Stream是JDK1.8出现的，提供了我们对集合进行一些操作的API，配合这Lambda的使用，个人感觉是棒极了，虽然我们用普通的代码也可以实现，但是用Stream的话 ，会让代码更加的清新。 2.Stream的工作流程 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3iGSkC5P-1637593204295)(C:\Users\user\AppData\Roaming\Typora\typora-user-images\image-202
jdk8的新特性总结（二）：StreamAPI
caishi13202的博客
09-12 5390
这篇文章我们一起来学习java8最重要的新特性之一，强大的StreamAPI，在本文中的代码示例中我们会大量使用lambda表达式，如果对lambda表达式还不太熟悉，可以看一下上一篇文章。 java8中Java8中有两大最为重要的改变。第一个是 Lambda 表达式；另外一个则是 Stream API(java.util.stream.*)。Stream 是 Java8 中处理集合的关键抽象概...
java 8 新特性之 Stream API
找个借口安静
08-29 232
https://www.ibm.com/developerworks/cn/java/j-lo-java8streamapi/
理解Spring响应式编程：从Reactor到WebFlux
"Spring响应式编程基础教程，适合初学者，由王增成讲解，涵盖了响应式编程模型、Reactor框架、Spring WebFlux和响应式RESTful服务等内容。" 响应式编程是一种编程范式，它强调数据流和变化的传播，使系统能够根据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值