JDK 8 Stream流的常用方法

已于 2023-06-26 08:42:30 修改
阅读量196 收藏 2
点赞数
分类专栏： Java学习之路 文章标签： java 开发语言 jvm
于 2023-06-07 22:58:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44036439/article/details/131097797
版权

Stream常用API总结

在这里插入图片描述

可以理解的是，forEach输出了一个流以后，不能再次对它forEach

获取流

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

/**
 * @Author jiangxuzhao
 * @Description
 * @Date 2023/6/6
 */
public class Demo01GetStream {
    public static void main(String[] args) {
        // 通过.stream()获取
        ArrayList<String> list = new ArrayList<>();
        Stream<String> stream1 = list.stream();

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

        HashMap<String, Object> map = new HashMap<>();
        Set<String> keySet = map.keySet();
        Stream<String> stream3 = keySet.stream();

        Collection<Object> values = map.values();
        Stream<Object> stream4 = values.stream();

        Set<Map.Entry<String, Object>> entries = map.entrySet();
        Stream<Map.Entry<String, Object>> stream5 = entries.stream();


        // Stream.of()静态方法
        Integer[] arr={1,2,3};
        Stream<Integer> stream6 = Stream.of(arr);
        
        // Stream.of()底层调用的方法
        Stream<Integer> stream7 = Arrays.stream(arr);
    }
}

forEach

import java.util.stream.Stream;

/**
 * @Author jiangxuzhao
 * @Description 遍历
 * @Date 2023/6/7
 */
public class Demo2Stream_forEach {
    public static void main(String[] args) {
        Stream<String> stream2 = Stream.of("张三", "李四", "王五");
        // void forEach(Consumer<? super T> action) 接受一个范型T，返回void  void accept(T t);
        stream2.forEach(name-> System.out.print(name+" ")); // 张三 李四 王五
    }
}

filter

import java.util.stream.Stream;

/**
 * @Author jiangxuzhao
 * @Description
 * @Date 2023/6/7
 */
public class Demo3Stream_filter {
    public static void main(String[] args) {
        Stream<String> stream3 = Stream.of("张三", "李四", "王五");
        Stream<String> stream4 = stream3.filter(name -> name.startsWith("张")); //Stream流只能被消费使用一次，每次返回一个新流
        stream4.forEach(System.out::println); // 张三

        Stream<Integer> stream5 = Stream.of(28, 29, 30, 31);
        stream5.filter(age->age>28).forEach(System.out::println); // 29 30 31
    }
}

map

import java.util.stream.Stream;

/**
 * @Author jiangxuzhao
 * @Description 将一种类型的流转换成另一种类型的流
 * @Date 2023/6/7
 */
public class Demo4Stream_map {
    public static void main(String[] args) {
        Stream<String> stream4 = Stream.of("1","2","3","4");
        // 将Stream<String>转换为Stream<Integer>并输出
        stream4.map(s->Integer.parseInt(s)+1).forEach(System.out::println);// 2 /n 3 /n 4 /n 5 /n
    }

}

count

import java.util.ArrayList;

/**
 * @Author jiangxuzhao
 * @Description 统计Stream流中的元素个数
 * @Date 2023/6/7
 */
public class Demo5Stream_count {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);

        long count = list.stream().count();
        System.out.println(count); // 3
    }
}

collect

从Stream流收集生成Collection集合

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

/**
 * @Author jiangxuzhao
 * @Description 从Stream流收集生成Collection集合
 * @Date 2023/6/7
 */
public class Demo6Steam_collect {
    public static void main(String[] args) {
        List<User> list = Arrays.asList(new User(19), new User(21), new User(22));
        // Stream collect成list
        Collection<User> collectList = list.stream().filter(user -> user.getId() > 20)
                .collect(Collectors.toList());
        System.out.println("collectList:"+collectList.toString());

        // Stream collect成set
        Set<User> collectSet = list.stream().filter(user -> user.getId() > 20)
                .collect(Collectors.toSet());
        System.out.println("collectSet:"+collectSet);

        // Stream collect成map, key为id，value为User
        Map<Integer, User> collectMap = list.stream().collect(Collectors.toMap(
                user -> user.getId(),
                user -> user
        ));
        for(Map.Entry<Integer,User> entry:collectMap.entrySet()){
            System.out.println(entry.getKey()+" "+entry.getValue());
        }

    }
}


class User{
    Integer id;
    public User(Integer id){
        this.id=id;
    }
    public Integer getId(){
        return this.id;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                '}';
    }
}

collect高级用法：分组，max,min,average,sum

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;

/**
 * @Author jiangxuzhao
 * @Description
 * @Date 2023/6/7
 */
public class Demo7Stream_collect2 {
    public static void main(String[] args) {
        // 分组groupingBy分组，按照年龄进行分组
        List<Stu> list = Arrays.asList(new Stu(19,8), new Stu(21,8), new Stu(22,9), new Stu(27,7));
        // 自动收集成Map<Integer, List<Stu>>集合
        Map<Integer, List<Stu>> collectGroup = list.stream().collect(Collectors.groupingBy(stu -> stu.getAge()));
        System.out.println(collectGroup.toString()); // {7=[Stu{id=27, age=7}], 8=[Stu{id=19, age=8}, Stu{id=21, age=8}], 9=[Stu{id=22, age=9}]}

        // 收集年龄最大的值 collect(Collectors.maxBy())返回的是一个Optional对象，如果有多个满足条件的就返回一个
        Optional<Stu> maxAgeOptional = list.stream().collect(Collectors.maxBy((p1, p2) -> p1.getAge() - p2.getAge()));
        System.out.println(maxAgeOptional.get()); // Stu{id=22, age=9}

        // 收集年龄最小的值 collect(Collectors.minBy())返回的是一个Optional对象，如果有多个满足条件的就返回一个
        Optional<Stu> minAgeOptional = list.stream().collect(Collectors.minBy((p1, p2) -> p1.getAge() - p2.getAge()));
        System.out.println(minAgeOptional.get()); // Stu{id=22, age=9}

        // 收集年龄总和
        Integer sumAge = list.stream().collect(Collectors.summingInt(Stu::getAge));
        System.out.println(sumAge); // 32

        // 收集年龄均值
        Double aveAge = list.stream().collect(Collectors.averagingInt(Stu::getAge));
        System.out.println(aveAge); // 8.0
    }
}


class Stu{
    Integer id;
    Integer age;
    public Stu(Integer id,Integer age){
        this.id=id;
        this.age=age;
    }
    public Integer getId(){
        return this.id;
    }

    public Integer getAge(){
        return this.age;
    }

    @Override
    public String toString() {
        return "Stu{" +
                "id=" + id +
                ", age=" + age +
                '}';
    }
}

mapToDouble

import java.util.stream.DoubleStream;
import java.util.stream.Stream;

/**
 * @Author jiangxuzhao
 * @Description 完成 Stream<String>到DoubleStream的转换
 * @Date 2023/6/7
 */
public class Demo8Stream_doubleMap {
    public static void main(String[] args) {
        Stream<String> stream8 = Stream.of("1", "2", "3");
        DoubleStream doubleStream = stream8.mapToDouble(m -> Double.parseDouble(m));
        doubleStream.forEach(System.out::println);
    }
}

sorted

import java.util.stream.Stream;

/**
 * @Author jiangxuzhao
 * @Description
 * @Date 2023/6/7
 */
public class Demo9Stream_sorted {
    public static void main(String[] args) {
        // 升序排列
        Stream<Integer> stream9 = Stream.of(5, 4, 3, 2, 1).sorted((o1,o2)->o1-o2);
        stream9.forEach(System.out::println);
    }
}

match

判断数据是否匹配条件，也是终结运算

boolean anyMatch(Predicate<? super T> predicate);

boolean allMatch(Predicate<? super T> predicate);

boolean noneMatch(Predicate<? super T> predicate);

import org.junit.Test;

import java.util.stream.Stream;

/**
 * @Author jiangxuzhao
 * @Description
 * @Date 2023/6/26
 */
public class Demo10Stream_match {
    @Test
    public void testAllMatch() {
        boolean result = Stream.of(1, 2, 3, 4, 5)
                .allMatch(s -> s > 0);
        System.out.println(result); // true
    }

    @Test
    public void testAnyMatch() {
        boolean result = Stream.of(1, 2, 3, 4, 5)
                .anyMatch(s -> s < 0);
        System.out.println(result); // false
    }

    @Test
    public void testNoneMatch() {
        boolean result = Stream.of(1, 2, 3, 4, 5)
                .noneMatch(s -> s < 0);
        System.out.println(result); // true
    }
}

find

找到某些数据，其也是终结操作，返回的是Optional，不是Stream

Optional<T> findFirst();
Optional<T> findAny();

import org.junit.Test;

import java.util.Optional;
import java.util.stream.Stream;

/**
 * @Author jiangxuzhao
 * @Description
 * @Date 2023/6/26
 */
public class Demo11Stream_find {
    @Test
    public void testFindFirst() {
        Stream<String> stream = Stream.of("1", "2", "3", "4", "5");
        Optional<String> first = stream.findFirst();
        System.out.println(first.get()); // 1
    }

    @Test
    public void testFindAny() {
        Stream<String> stream = Stream.of("1", "2", "3", "4", "5");
        Optional<String> any = stream.findAny();
        System.out.println(any.get()); // 1
    }
}
互联网民工蒋大钊
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
JDK8有一些我们最常用的新特性
11-11
这个资源包括了我们在实际项目开发过程中最常用的一些JDK8的新特性，比如Stream流是如何使用的，当然资源里的案例都是非常基础的，加上了一些通俗易懂的描述，有兴趣的可以下载看一看哦！
JDK8核心新特性
06-20
JDK8已经发行有几年了，在该版本中推出了不少新特性，其中比较有代表的新特性有：Lambda表达式，Stream流，方法引用。...Stream流常用方法：forEach/filter/limit/skip/map/count/collect/concat/parall/pa
JDK8之Stream流
bluede2015的博客
04-01 869
Stream流式思想类似于工厂车间的“生产流水线”，Stream流不是一种数据结构，不保存数据，而是对数据进行加工 处理。
Java8新特性stream
qq_42964601的博客
05-02 616
Java8新特性stream 概念 Stream是Java8 API的新成员，它允许以声明性方式处理数据集合 特点 （1）代码简洁：函数式编程写出的代码简洁且意图明确，使用stream接口让你从此告别for循环。 （2）多核友好：Java函数式编程使得编写并行程序从未如此简单，你需要的全部就是调用一下方法。 流程 1）第一步：把集合转换为流stream 2）第二步：操作stream流stream流在管道中经过中间操作（intermediate operation）的处理，最后由最终操作(terminal o
java8新特性之Steam
C_Karen的博客
10-30 1872
java8新特性之Steam
黑马点评--基于Stream消息队列实现异步秒杀优化，jmeter高并发测试
qq_45524787的博客
01-12 1722
jmeter高并发测试，1000token
JDK8 stream常见用法
bswsf的专栏
11-07 297
javajdk8 stream常用方法
java8stream源码-blade:刀
06-04
java8流源码 基于Java8 + Netty4打造轻量级、高性能、简洁优雅的Web框架 :face_savoring_food: 花1个小时学习它做一些有趣的事情，是除了Spring框架的最佳选择。 :paw_prints: | :blue_book: | :clapper_board: | :...
java8stream源码-ss:SS
06-04
java8流源码 基于Java8 + Netty4打造轻量级、高性能、简洁优雅的Web框架 :face_savoring_food: 花1个小时学习它做一些有趣的事情，是除了Spring框架的最佳选择。 :paw_prints: | :blue_book: | :clapper_board: | :...
java8stream源码-padma:帕德玛
06-04
java8流源码 基于Java8 + Netty4打造轻量级、高性能、简洁优雅的Web框架 :face_savoring_food: 花1个小时学习它做一些有趣的事情，是除了Spring框架的最佳选择。 :paw_prints: | :blue_book: | :clapper_board: | :...
Jdk8，Stream流：常用方法，玩转集合操作
lyd的博客
02-09 890
Jdk8，Stream流：常用方法，玩转集合操作
Java8流式操作
Jarvan的博客
08-04 220
很多时候我们需要到底层返回数据，上层再对数据进行遍历，进行一些数据统计，但是之前的Java API 中很少有这种方法，这就需要我们自己来 Iterator 来遍历，如果JDK 能够为我们提供一些这种方法，并且能够为我们优化就好了。所以JDK8加入 了 java.util.stream包，实现了集合的流式操作，流式操作包括集合的过滤，排序，映射等功能。Stream 不是 集合元素，也不是数据结构，它相当于一个 高级版本的 Iterator，不可以重复遍历里面的数据，像水一样，流过了就一去不复返。
JDK8的stream()的常用方法
weixin_43682323的博客
01-12 107
【代码】JDK8的stream()的常用方法。
JDK8新特性(三)：集合之 Stream 流式操作
热门推荐
扛麻袋的少年的博客
01-07 1万+
1.Stream流由来 首先我们应该知道：Stream流的出现，主要是用在集合的操作上。在我们日常的工作中，经常需要对集合中的元素进行相关操作。诸如：增加、删除、获取元素、遍历。 最典型的就是集合遍历了。接下来我们先举个例子来看看 JDK8 Stream流式操作出现之前，我们对集合操作的过程，从中来了解一下JDK8 之前集合操作数据的弊端。 Demo...
Java8新特性-流式操作
一起加油吧~
05-02 1649
在Java8中提供了新特性—流式操作，通过流式操作可以帮助我们对数据更快速的进行一些过滤、排序、去重、最大、最小等等操作并且内置了并行流将流划分成多个线程进行并行执行，提供更高效、快速的执行能力。接下来我们一起看看Java8为我们新增了哪些便捷呢？
Java8之常用的流（Stream）操作
qq_43305367的博客
11-03 982
Java8常用的Stream和Collectors操作
Jdk8 之 Stream流详细用法(一)
木字楠的博客
11-14 3688
本篇文章参考云深i不知处的文章 原文链接：https://blog.csdn.net/mu_wind/article/details/109516995 一、概述   Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简而言之，Stream API 提供了一种高效且易于使用的处理数据的方
JDK8 Stream 常见应用
D的博客
05-12 1083
一、双循环遍历： 例： ListOne.stream().forEach(one -> ListTwo.stream().anyMatch(two->{ // 处理业务逻辑 ...... return false; })); 二、去重 1、针对 对象 一个字段： ArrayList<ProductProcessDrawbackDto> collect = records1.stre
【jdk8新特性】Stream API：三种创建方式，中间操作，终止操作
知识输出、记录学习
08-07 245
Stream 流知识架构，概念，特点，总结
jdk1.8开发常用stream流
最新发布
08-30
Stream流是在Java 8之后新增的一个特性，它是用来操作集合（Collection）的工具。Stream流提供了一种简洁、高效的方式来对集合进行处理和操作。Stream流可以用于遍历集合中的元素、进行过滤、映射、排序、聚合等各种...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

互联网民工蒋大钊

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值