Java8实战之（四）使用流

最新推荐文章于 2022-07-21 09:19:08 发布
最新推荐文章于 2022-07-21 09:19:08 发布
阅读量206 收藏 2
点赞数
分类专栏： java8 实战
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42324034/article/details/107726205
版权

4 使用流

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

4.1 筛选和切片

在这里插入图片描述
谓词做筛选（忽略流中的数据），截短到指定长度教切片

4.1.1 用谓词筛选

在这里插入图片描述

4.1.2 筛选各异的元素

在这里插入图片描述
在这里插入图片描述

4.1.3 截短流

在这里插入图片描述
在这里插入图片描述

4.1.4 跳过元素

在这里插入图片描述
在这里插入图片描述

4.2 映射

一个非常常见的映射就是获取对象中的属性值，比如在sql中选择一列，Streamapi也提供了map和flatmap方法提供了类似的工具

4.2.1 对流中每一个元素应用函数

在这里插入图片描述

        List<Dish> dishes = Arrays.asList(new Dish("asda",false,1, Dish.Type.MEAT),new Dish("1",false,1, Dish.Type.MEAT),new Dish("2",false,1, Dish.Type.MEAT));
        List<String> dishNames = dishes.stream().map((Dish dish) -> dish.getName()).collect(Collectors.toList())

在这里插入图片描述

        // 获取字符串长度
        List<String> words = Arrays.asList("a12","asd","lamdba","adsasd");
        List<Integer> wordsLength = words.stream().map(String::length).collect(Collectors.toList());

在这里插入图片描述
在这里插入图片描述

4.2.2 流的扁平化

扁平化就是将每个流化成单个流
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
1.尝试使用map和Arrays.stream
首先你需要一个字符流，而不是数组流，有一个叫做Arrays.stream的方法可以接受一个数组并产生一个流。例如

        List<String> list1 = Arrays.asList("Hello", "World");
        // 以下代码报异常，因为map返回的是流的列表，并不是流的内容
        List<String> dd = list1.stream().map((String s) -> s.split(""))
                .map(Arrays::stream)
                .distinct()
                .collect(toList());

使用flatmap


        List<String> list1 = Arrays.asList("Hello", "World");
        List<String> dd = list1.stream().map((String s) -> s.split(""))
                .flatMap(Arrays::stream)
                .distinct()
                .collect(toList());

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

4.3 测验

在这里插入图片描述

        // 你可以利用map方法的Lambda，接受一个数字，并返回该数字的平方的Lambda来ᝌ
        //解决这个问题。
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        List<Integer> squares =
                numbers.stream()
                        .map(n -> n * n)
                        .collect(toList());
        squares.forEach(item -> System.out.println(item));

在这里插入图片描述
在这里插入图片描述

        // 测验二
/*        给定两个数字列表，如何返回所有的数对呢？例如给定列表1[1, 2, 3]和表[3, 4]，应
        该返回[(1, 3), (1, 4), (2, 3), (2, 4), (3, 3), (3, 4)]。为简单期起见，你可以用有两个元素的数组来代
        表数对。*/
        List<Integer> number1 = Arrays.asList(1,2,3);
        List<Integer> number2 = Arrays.asList(3,4);
        List<int[]> pairs =
                number1.stream()
                        .flatMap(i -> number2.stream()
                                .map(j -> new int[]{i,j})
                        )
                        .collect(toList());
        pairs.parallelStream().forEach((int[] i) -> System.out.println(i));

在这里插入图片描述

        // 测试三
        List<int[]> pairs1 =
                number1.stream()
                        .flatMap((Integer i) -> number2.stream()
                                // 过滤
                                .filter((Integer j) -> (i + j) % 3 == 0)
                                .map((Integer j) -> new int[]{i,j})
                        )
                        .collect(toList());
        System.out.println(pairs1);

4.4 查找和匹配

在这里插入图片描述

4.4.1 检查谓词是否至少匹配一个元素

说白了就是是否包含某个元素
anyMatch方法可以回答“流中是否有一个元素能匹配给定的谓词”。比如，你可以用它来看看菜单里面是否有素食可选择：

        // 检查谓词是否至少匹配一个元素
        if(dishes.stream().anyMatch(Dish::isVegetarian)){
            System.out.println("找到素食");
        }

4.4.2 检查谓词是否匹配所有元素

allMatch方法的工作原理和anyMatch类似，但它会看看流中的元素是否都能匹配给定的谓词。比如，你可以用它来看看菜品是否有利安全（即所有热量都低于1000卡路里）

        // 检查谓词是否匹配所有元素
        boolean isHealthy = dishes.stream().allMatch((Dish dish) -> dish.getCalories() < 1000);

在这里插入图片描述
在这里插入图片描述

4.4.3 查找元素

在这里插入图片描述

        // 查找元素
        Optional<Dish> dish =
                dishes.stream()
                        .filter(Dish::isVegetarian)
                        .findAny();

Optional简介
在这里插入图片描述
在这里插入图片描述

4.4.4 查找第一个元素

在这里插入图片描述

4.5 规约

在这里插入图片描述
在这里插入图片描述

4.5.1 元素求和

在这里插入图片描述

         // 求和
         int sumCalories = dishes.stream().map(Dish::getCalories).reduce(0,(int a,int b) -> {
             return a + b;
         });

4.5.2 最大值与最小值

在这里插入图片描述
在这里插入图片描述


         // 计算最大值
         Optional<Integer> maxCalories = dishes.stream().map(Dish::getCalories).reduce(Integer::max);
         Optional<Integer> minCalories1 = dishes.stream().map(Dish::getCalories).reduce((Integer x,Integer y) -> x < y ? x : y);

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

        int dishNum = dishes.stream().map(d -> 1).reduce(0,Integer::sum);
        System.out.println(dishNum);

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

4.6 付诸实践

在本节中，你会将迄今学到的关于流的知付诸诸实践。我们来看一个不同的领域：执行交易的交易员。你的经理让你为八个查询找到答案。你能做到吗？
(1) 找出2011年发生的所有交易，并按交易额排序（从低到高）。
(2) 交易员都在哪些不同的ۡ市工作过？
(3) 查找所有来自剑桥的交易员，并按ހ名排序。
(4) 返回所有交易员的姓名字符串，按字母顺序排序。
(5) 有没有交易员是在米兰工作的？
(6) 打印生活在剑桥的交易员的所有交易额。
(7) 所有交易中，最高的交易额是多少？
(8) 找到交易额最小的交易。

package com.java.lamdba.four;

import lombok.Data;

/**
 * 交易员类
 */
@Data
public class Trader {
    private final String name;
    private final String city;
    public Trader(String n, String c){
        this.name = n;
        this.city = c;
    }
}


package com.java.lamdba.four;

import lombok.Data;

/**
 * 交易类
 */
@Data
public class Transaction {
    private final Trader trader;
    private final int year;
    private final int value;
    public Transaction(Trader trader, int year, int value){
        this.trader = trader;
        this.year = year;
        this.value = value;
    }
}


package com.java.lamdba.four;

import java.util.*;
import java.util.stream.Collectors;

import static java.util.stream.Collectors.toSet;

/**
 * 测试类
 */
public class TradDemo {
    public static void main(String[] args) {
        Trader raoul = new Trader("Raoul", "Cambridge");
        Trader mario = new Trader("Mario","Milan");
        Trader alan = new Trader("Alan","Cambridge");
        Trader brian = new Trader("Brian","Cambridge");
        List<Transaction> transactions = Arrays.asList(
                new Transaction(brian, 2011, 300),
                new Transaction(raoul, 2012, 1000),
                new Transaction(raoul, 2011, 400),
                new Transaction(mario, 2012, 710),
                new Transaction(mario, 2012, 700),
                new Transaction(alan, 2012, 950)
        );
        // 1.找出2011年的所有交易并按交易额排序（从低到高）
        List<Transaction> tr2011 = transactions.stream().filter(d -> d.getYear() == 2011)
                .sorted(Comparator.comparing(Transaction::getValue))
                .collect(Collectors.toList());

        // 2.交易员都在哪些不同的城市工作过
        List<String> cities = transactions.parallelStream().map((Transaction transaction) -> transaction.getTrader().getCity())
                .distinct()
                .collect(Collectors.toList());
        Set<String> cities1 =
                transactions.stream()
                        .map(transaction -> transaction.getTrader().getCity())
                        .collect(toSet());

        // 3.查找所有来自于剑桥的交易员，并按姓名排序
        List<Trader> traders = transactions.stream().map(Transaction::getTrader)
                .filter( d -> "Cambridge".equals(d.getCity()))
                .distinct()
                .sorted(Comparator.comparing(Trader::getName))
                .collect(Collectors.toList());

        // 4.返回所有交易员姓名的字符串并通过字母排序，按字母顺序排序
        String nameStr = transactions.stream().map((Transaction t) -> t.getTrader().getName())
                .distinct()
                .sorted()
                .reduce("",(String::concat));
        String nameStr1 = transactions.stream().map((Transaction t) -> t.getTrader().getName())
                .distinct()
                .sorted()
                .collect(Collectors.joining());

        // 5.有没有交易员是在米兰工作的
        boolean isMilan = transactions.stream().anyMatch(d -> d.getTrader().getCity().equals("Milan"));

        // 6.打印生活在剑桥的交易员的所有交易额
        transactions.stream().filter(item -> "Cambridge".equals(item.getTrader().getCity()))
                .map(item -> item.getValue())
                .forEach(item -> System.out.println("交易额为" + item));

        // 7. 所有交易中，最高的交易额是多少
        Optional<Integer> maxValue = transactions.stream().map(item -> item.getValue()).reduce(Integer::max);


        // 8. 所有交易中，最少的交易额是多少
        Optional<Integer> minValue = transactions.stream().map(item -> item.getValue()).reduce(Integer::min);

    }
}

4.7 数值流

在这里插入图片描述

4.7.1 原始类型流特化

IntStream,DoubleStream,LongStream作为原始类型特化流，顾名思义就是将流中的元素转成int,double,long，从而避免的装箱操作

  1. 映射到数值流
    在这里插入图片描述

  2. 转回对象流
    在这里插入图片描述

  3. 默认值OptionalInt
    在这里插入图片描述

4.7.2 数值范围

和数字打交道时，有一个常用的东西就是数值范围。比如，假设你想要生成1和100之间的所有数字。Java 8引入了两个可以用于IntStream和LongStream的静态方法，帮助生成这种范围：
range和rangeClosed。这两个方法都是第一个参数接受起始值，第二个参数接受结束值。但range是不包含结束值的，而rangeClosed则包含结束值。让我们来看一个例子：
在这里插入图片描述

4.7.3 数值流的应用，勾股数

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

//        // 生成勾股数
//        Stream<int []> gouguStream = IntStream.rangeClosed(1,100)
//                // 生一个勾股数形成一个流
//                .boxed()
//                .flatMap(a -> IntStream.rangeClosed(a,100).filter(b -> Math.sqrt( a*a + b*b) % 1==0)
//                        .mapToObj(b -> new int[]{a,b, (int) Math.sqrt(a*a + b*b)})
//                );
//        gouguStream.forEach(item -> System.out.println(item[0] + "," + item[1] + "," + item[2]));

        Stream<double []> gouguStream2 = IntStream.rangeClosed(1,100)
                // 生一个勾股数形成一个流
                .boxed()
                .flatMap(a -> IntStream.rangeClosed(a,100)
                        .mapToObj(b -> new double[]{a,b, Math.sqrt(a*a + b*b)})
                        .filter(item -> item[2]  % 1 ==0 )
                );
        gouguStream2.forEach(item -> System.out.println(item[0] + "," + item[1] + "," + item[2]));

4.8 构建流

在这里插入图片描述
在这里插入图片描述

4.8.1 由值创建流

在这里插入图片描述

4.8.2 由数组创建流

在这里插入图片描述

4.8.3 由文件创建流

在这里插入图片描述

4.8.4 由函数生成流：创建无限流

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

package com.java.lamdba.four;

import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.function.IntSupplier;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class StructStreamDemo {
    public static void main(String[] args) {

        // 由值创建流
        Stream<String> stringStream = Stream.of("java8", "lamdba", "adasdasd");
        stringStream.map(String::toUpperCase).forEach(item -> System.out.println(item));
        // 创建空流
        Stream<String> emptyStream = Stream.empty();

        // 数组创建流
        int[] numbers = {2, 3, 5, 7, 11, 13};
        int sum = Arrays.stream(numbers).sum();

        // 由文件生成流
        long uniqueWords = 0;
        try {
            Stream<String> stringStream1 = Files.lines(Paths.get("E:\\learn\\java_learning\\design\\lamdba\\src\\main\\resources\\data.txt"), Charset.defaultCharset());
            uniqueWords = stringStream1.flatMap(line -> Arrays.stream(line.split(" ")))
                    .distinct()
                    .count();
            System.out.println(uniqueWords);
        } catch (Exception ex) {
            System.out.println(ex);
        }

        // c由函数创建无限流，
        // 1.迭代
        Stream.iterate(0, n -> n + 2)
                .limit(10)
                .forEach(System.out::println);

        // 斐波那契数列
//        Stream.iterate(new int[]{0, 1},
//                t -> new int[]{t[1],t[0] + t[1]})
//                .limit(10)
//                .map(t -> t[0])
//                .forEach(System.out::println);

        IntSupplier fib = new IntSupplier(){
            private int previous = 0;
            private int current = 1;
            @Override
            public int getAsInt(){
                int oldPrevious = this.previous;
                int nextValue = this.previous + this.current;
                this.previous = this.current;
                this.current = nextValue;
                return oldPrevious;
            }
        };
        IntStream.generate(fib).limit(10).forEach(System.out::println);
    }
}

4.9 小结

在这里插入图片描述

zglx123
关注
专栏目录
详解Java8中流(Stream)的使用
境里婆娑
03-28 755
文章列表一、回忆Lambda表达式二、什么是流1、流只能遍历一次2、外部迭代和内部迭代三、流操作1、谓词筛选2、筛选各异元素3、截段流4、跳过元素5、map和flatMap6、查找和匹配7、归约reduce 写在前面： 我是「境里婆娑」。我还是从前那个少年，没有一丝丝改变，时间只不过是考验，种在心中信念丝毫未减，眼前这个少年，还是最初那张脸，面前再多艰险不退却。 写博客的目的就是分享给大家一起学习交流，如果您对 Java感兴趣，可以关注我，我们一起学习。 前言：还没接触过流的同学可以深入研究下此篇文章，
JAVA8 流基本使用
zhanghe687的博客
01-11 211
参考地址： 用Stream来优化老代码，瞬间干净优雅了！https://mp.weixin.qq.com/s/DiFib195GFYOWTAu0__cIg
02 java8实战--常见函数式接口:Predicate
wyaoyao93的博客
08-24 229
文章目录1 Predicate2 LongPredicate3 BiPredicate 1 Predicate @FunctionalInterface public interface Predicate<T> { /** * Evaluates this predicate on the given argument. * * @param t the input argument * @return {@code true} if the
java stream流操作
m0_67193029的博客
07-21 161
1)找出2011年发生的所有交易，并按交易额排序（从低到高）。(2)交易员都在哪些不同的城市工作过？(3)查找所有来自于剑桥的交易员，并按姓名排序。(4)返回所有交易员的姓名字符串，按字母顺序排序。(5)有没有交易员是在米兰工作的？(6)打印生活在剑桥的交易员的所有交易额。(7)所有交易中，最高的交易额是多少？(8)找到交易额最小的交易。...
RDD基本转换操作(1)–map、flagMap、distinct
cloud-2014的专栏
09-14 1896
map 将一个RDD中的每个数据项，通过map中的函数映射变为一个新的元素。 输入分区与输出分区一对一，即：有多少个输入分区，就有多少个输出分区。 hadoop fs -cat /tmp/lxw1234/1.txthello worldhello sparkhello hive  //读取HDFS文件到RDDscala> var data = sc.textFile("/tmp/lx
Java+8实战_Java8_java8_
10-03
以上只是Java 8中部分重要特性，实际的“Java+8实战”书籍可能会涵盖更多细节，如如何使用新的日期和时间API进行日期计算、如何利用流API进行复杂的数据处理，以及如何有效地使用lambda和函数式接口进行函数式编程。...
java8实战：使用流收集数据之toList、joining、groupBy(多字段分组)
最新发布
10-11
在Java 8中，Stream API的引入为处理集合数据提供了新的、更为强大的方式。这篇实战指南将探讨如何利用Stream API的`toList`、`joining`和`groupBy`方法来高效地收集和操作数据。让我们深入了解一下这些方法以及它们...
java8实战读书笔记：初识Stream、流的基本操作（流计算）
01-07
本文是博主在学习《java8实战》的一些学习笔记。 从本节开始，将进入到java8 Stream(流)的学习中来。 本文中的部分示例基于如下场景：餐厅点菜，Dish为餐厅中可提供的菜品，Dish的定义如下： 1public class Dish...
java 8编程实战
04-17
java 8编程实战 本书全面介绍了Java 8 这个里程碑版本的新特性，包括Lambdas、流和函数式编程。有了函数式的编程特性，可以让代码更简洁，同时也能自动化地利用多核硬件。全书分四个部分：基础知识、函数式数据处理...
Java8关于map和flatMap的代码片段思考
路漫漫，等风来
04-27 5005
今天看到一段java8的代码，因为初学java8所以有点不好理解： 然后把流的每个过程单独用变量赋值，就好理解多了： List&lt;List&lt;String&gt;&gt; lists = Arrays.asList(Arrays.asList("Jordan"), Arrays.asList("Kobe","James"),Arrays.asList("Durant",
Java8 Stream流使用
菜鸟记录
03-31 1406
⏹Java Stream流使用
java8 stream中map与flatMap的区别
南来北往的客
03-09 3645
latMap与map的区别在于* flatMap是将一个流中的每个值都转成一个个流，然后再将这些流扁平化成为一个流 。举例如下： String[] strs = {“java8”, “is”, “easy”, “to”, “use”}; List&lt;String[]&gt; distinctStrs = Arrays.stream(strs) ...
java 8 Stream中flatMap方法
热门推荐
dengjili的专栏
05-26 1万+
在java 8 Stream中，flatMap方法是一个维度升降的方法 举例说明 给 定 单 词 列 表[“Hello”,“World”] ，要返回列表 [“H”,“e”,“l”, “o”,“W”,“r”,“d”] 。 使用map方法，代码如下： public class StreamStr { public static void main(String[] args) { List&lt...
Java找出文件中名字出现次数最多学生，并找到该学生的最高成绩
jian1057877236的博客
11-17 971
利用IO流知识写入数据，在控制台输出文本文件中名字出现最多的人，以及这个人最高的成绩是多少，以及这个人出现的次数 我的方法用得有些复杂，望大佬勿喷，希望大佬们指点一些更为优化的方法 public class Test { //这个集合用于存放文本里面的每一行数据 public static ArrayList<String> list = new ArrayList&...
Java8实战读书笔记-第5章 使用流
不正的博客
02-01 223
第5章今天读了一下午,主要是需要敲的案例比较多,第五章案例基本完整代码如下;测试题的实体类代码在这篇文章最下面 5.1 筛选和切片 见代码 @RunWith(SpringJUnit4ClassRunner.class) @SpringBootTest public class DishStreamTest { private List<Dish> menu = Arrays.asList( new Dish("pork", false, 800, Dish.Ty
transactions应用
kaishizige的博客
02-09 277
/** * 交易员类 */ public class Trader { private String name; private String city; public Trader() { } public Trader(String name, String city) { this.name = name; t...
浅谈java8中的流的使用
大道至简
06-03 7471
我们在开发的过程中会大量的使用集合，集合可以将数据进行分组，处理，好多的处理数据的业务逻辑类似于数据库的操作，比如说对一系列的实体根据它其中的某个属性来分组，筛选，像这样的操作，数据库是允许你声明式的指定这些操作的。比如说： SELECTnameFROMappleWHEREweight<400; 这样的业务逻辑，我们之前的代码实现都是for循环里面，填上一大堆的i...
了不起的Java-Stream流处理
昕友软件博客
03-01 232
问题引入 假如你是一个厨师，你有一份菜单列表（DishMenu），你需要一份低卡路里（Caloric低于400），并且按卡路里数值排序的top3（最低的前3个）的仅包含菜名的菜单列表，你会怎么做？这个问题也贯穿了开发中大量需要处理list、set、map之类的集合操作，是非常非常基础的问题。而Stream就是处理集合的。 相关数据类： import java.util.*; publ...
java有关排列、组合的算法
AnalogElectronic的博客
03-01 1135
package com.test.test02; import java.util.*; import java.util.stream.Collectors; import java.util.stream.Stream; import static java.util.stream.Collectors.toList; /** * @author cruder* * @date 2022/3/1 21:01 */ public class Test02 { public stati
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值