stream 流

最新推荐文章于 2022-11-11 23:27:38 发布
最新推荐文章于 2022-11-11 23:27:38 发布
阅读量172 收藏
点赞数
文章标签： 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_68130794/article/details/125702506
版权
本文通过实例展示了如何使用Java Stream API进行集合操作，包括创建集合、过滤、映射、聚合等操作。同时，讲解了Stream的中间方法如filter、limit、skip和distinct，以及终结操作如forEach、count和collect。最后，通过一个年中结算的案例展示了如何在实际场景中应用Stream API来处理复杂数据。
摘要由CSDN通过智能技术生成

目的:用于简化集合和数组操作的API。

需求:按照下面的要求完成集合的创建和遍历

创建一个集合，存储多个字符串元素

package com;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;

public class StreamTest {
    public static void main(String[] args) {
       List<String> names=new ArrayList<>();
        Collections.addAll(names,"张三丰","赵敏","张无忌","周芷若","张强");
        System.out.println(names);
       /* //1、从集合中找出姓张的放到新集合
        List<String> zhanglist=new ArrayList<>();
        for (String name:names) {
            if (name.startsWith("张")){
                zhanglist.add(name );
            }
        }
        System.out.println(zhanglist);
        //2、找名称长度是3的姓名
        List<String> zhangthreelist=new ArrayList<>();
        for (String name:zhangthreelist) {
            if (name.length()==3){
                zhangthreelist.add(name );
            }
        }
        System.out.println(zhangthreelist);*/

       //3、使用Stream实现的
        names.stream().filter(s->s.startsWith("张")).filter(s -> s.length()==3).forEach(s-> System.out.println(s));
    }

}

Stream流的三类方法：

  1. 集合获取stream流的方式

可以使用Collection接口中的默认方法stream()生成流

名称                                                                                   说明

default Stream<E> stream（）                        获取当前集合对象的Stream流

  1. 数组获取stream流的方式

名称                                                                                说明

public static <T> Stream<T> stream(T[] array)      获取当前数组的Stream流

public static<T> Stream<T> of(T... values)            获取当前数组/可变数据的stream流

package com;

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

public class stream01 {
    public static void main(String[] args) {
        //- -----Collection集合获取流------
        Collection<String> list=new ArrayList<>();
        Stream<String> s=list.stream();
        //-------------Hap集合获取流---------
        Map<String,Integer> maps=new HashMap<>();
        //键流
        Stream<String> keystream=maps.keySet().stream();
        //值流
        Stream<Integer> valuestream=maps.values().stream();
        //键值对流
        Stream<Map.Entry<String,Integer>>   ketandvaluestream=maps.entrySet().stream();
        //------数组获取流----------
        String[] names={"赵敏","小昭","灭绝"};
        Stream<String> namestream=Arrays.stream(names);
        Stream<String> namestream2=Stream.of(names);
    }
}

常用API：

名称                                                                                    说明

stream<T> filter(Predicate<? super T> predicate)         用于对流中的数据进行过

stream<T> limit( long maxSize)                                     获取前几个元素

stream<T> skip(long n)                                                  跳过前几个元素

Stream<T> distinct()                                   去除流中重复的元素。依赖(hashCode和equals方法)

static <T> Stream<T> concat(Stream a,stream b)          合并a和b两个流为一个流

package com.stream;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Stream;

public class stream01 {
    public static void main(String[] args) {
        List<String> list=new ArrayList<>();
        list.add("张三丰");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张无忌");
        list.add("张强");
        //stream<T> filter(Predicate<? super T> predicate)
        //法一
        /*list.stream().filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.startsWith("张");
            }
        });*/
        //法二
        list.stream().filter(s-> s.startsWith("张")).forEach(s-> System.out.println(s));
        //stream<T> limit( long maxSize)
        long size=list.stream().filter(s ->s.length()==3).count();
        System.out.println(size);
        list.stream().filter(s->s.startsWith("张")).limit(2).forEach(s-> System.out.println(s));//两个一样
        list.stream().filter(s->s.startsWith("张")).limit(2).forEach( System.out::println);

        //stream<T> skip(long n)
        list.stream().filter(s->s.startsWith("张")).skip(2).forEach( System.out::println);
        //Stream<T> distinct()
        //给集合前面加上黑马的
        //map加工方法:第一个参数原材料->第二个参数是加工后的结果。
        list.stream().map(s->"黑马的"+s).forEach(a-> System.out.println(a));
        /*list.stream().map(new Function<String, String>() {
            @Override
            public String apply(String s) {

                return "黑马的"+s;
            }
        });*/
        //需求：把所有名称做成学生类
        list.stream().map(s->new student(s)).forEach(s-> System.out.println(s));
        list.stream().map(student::new).forEach(System.out::println);//构造器引用  方法引用
        //合并流
        Stream<String> s1=list.stream().filter(s->s.startsWith("张"));
        Stream<String> s2=Stream.of("java01","java02");
       // static <T> Stream<T> concat(Stream a,stream b)  同一类型用同一类型  不同类型用object（等号前面）
        Stream<String> s3=Stream.concat(s1,s2);
        s3.forEach(s-> System.out.println(s));
    }
}

package com.stream;

public class student {
    private String name;

    public student() {
    }

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

    public String getName() {
        return name;
    }

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

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

注意：中间方法也称为非终结方法，调用完成后返回新的Stream流可以继续使用，支持链式编程。

在Stream流中无法直接修改集合、数组中的数据。

Stream流的常见终结操作方法：

  名称                                                                                         说明

void forEach(Consumer action)                          对此流的每个元素执行遍历操作

long count()                                                       返回此流中的元素数

案例：

需求:某个公司的开发部门，分为开发一部和二部，现在需要进行年中数据结算。

分析：

  1. 员工信息至少包含了(名称、性别、工资、奖金、处罚记录)
  2. 开发一部有4个员工、开发二部有5名员工
  3. 分别筛选出2个部门的最高工资的员工信息，封装成优秀员工对象Topperformer
  4. 要求去掉最高和最低工资。分别统计出2个部门的平均月收入， 
    	package com.stream;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;

public class stream02 {
    public static double allmoney1=0;
    public static double allmoney2=0;
    public static void main(String[] args) {

        List<Employee> one=new ArrayList<>();
        one.add(new Employee("猪八戒",'男',300000,25000,null));
        one.add(new Employee("孙悟空",'男',25000,100,"顶撞上司"));
        one.add(new Employee("沙僧",'男',20000,20000,null));
        one.add(new Employee("小白龙",'男',25000,26000,null));
        List<Employee> two=new ArrayList<>();
        one.add(new Employee("武松",'男', 1500 , 9000, null));
        one.add(new Employee("李逵",'男',200 , 10000, null));
        one.add(new Employee("西门庆",'男',500, 100080,"被打"));
        one.add(new Employee("潘金莲",'女', 350,1000,"被打"));
        one.add(new Employee("武大郎",'女', 200,0,"下毒"));
        //1、开发一部的最高工资的员工
        //制定大小规则
        /*Employee e=one.stream().max((e1,e2)->Double.compare(e1.getSalary()+e1.getBonus() ,e2.getSalary()+e2.getBonus()))
                .get();
        System.out.println(e);*/
        Topperformer t=one.stream().max((e1,e2)->Double.compare(e1.getSalary()+e1.getBonus() ,e2.getSalary()+e2.getBonus()))
                .map(e ->new Topperformer(e.getName(), e.getSalary()+e.getBonus())).get();
        System.out.println(t);

        //2.
        one.stream().sorted((e1,e2)->Double.compare(e1.getSalary()+e1.getBonus() ,e2.getSalary()+e2.getBonus()))
                .skip(1).limit(one.size()-2).forEach(e->{
                    allmoney1+=(e.getSalary()+e.getBonus());
                });
        System.out.println("开发一部的平均工资："+allmoney1/(one.size()-2));
        //合并两个集合流
        Stream<Employee> s1=one.stream();
        Stream<Employee> s2=one.stream();
        Stream<Employee> s3=Stream.concat(s1,s2);
        s3.sorted((e1,e2)->Double.compare(e1.getSalary()+e1.getBonus() ,e2.getSalary()+e2.getBonus()))
                .skip(1).limit(one.size()-2).forEach(e->{
                    allmoney2+=(e.getSalary()+e.getBonus());
                });
        //BIGEecimol
        BigDecimal a=BigDecimal.valueOf(allmoney2);
        BigDecimal b=BigDecimal.valueOf(one.size()+two.size()-2);
        System.out.println("开发部的平均工资："+a.divide(b,2, RoundingMode.HALF_UP));
    }
}
	package com.stream;

public class Topperformer {
    private String name;
    private double mongey;

    public Topperformer() {
    }

    public Topperformer(String name, double mongey) {
        this.name = name;
        this.mongey = mongey;
    }

    public String getName() {
        return name;
    }

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

    public double getMongey() {
        return mongey;
    }

    public void setMongey(double mongey) {
        this.mongey = mongey;
    }

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

package com.stream;

public class Employee {
    private String name ;
    private char sex;
    private double salary;
    private double bonus;
    private String punish; //处罚信思

    public Employee() {
    }

    public Employee(String name, char sex, double salary, double bonus, String punish) {
        this.name = name;
        this.sex = sex;
        this.salary = salary;
        this.bonus = bonus;
        this.punish = punish;
    }

    public String getName() {
        return name;
    }

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

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public double getBonus() {
        return bonus;
    }

    public void setBonus(double bonus) {
        this.bonus = bonus;
    }

    public String getPunish() {
        return punish;
    }

    public void setPunish(String punish) {
        this.punish = punish;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", sex=" + sex +
                ", salary=" + salary +
                ", bonus=" + bonus +
                ", punish='" + punish + '\'' +
                '}';
    }
}

    Stream流的收集操作:

    收集Stream流的含义︰就是把Stream流操作后的结果数据转回到集合或者数组中去。

    Stream流:方便操作集合/数组的手段。

    名称                                                                                      说明

    Rcollect(collector collector)                         开始收集Stream流，指定收集器

    collectors工具类提供了具体的收集方式

  5. package com.stream;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Set;
import java.util.function.IntFunction;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class stream03 {
    public static void main(String[] args) {
        List<String> list=new ArrayList<>();
        list.add("张三丰");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张无忌");
        list.add("张强");
        list.add("张三丰");
        Stream<String> s1=list.stream().filter(s->s.startsWith("张"));
        List<String> zhanglist= s1.collect(Collectors.toList());
        System.out.println(zhanglist);
        //流只能使用一次
        Stream<String> s2=list.stream().filter(s->s.startsWith("张"));
        Set<String> zhangset= s2.collect(Collectors.toSet());
        System.out.println(zhangset);

           //set会去掉重复

        Stream<String> s3=list.stream().filter(s->s.startsWith("张"));
        //Object[] arrs=s3.toArray();
        String[] arrs=s3.toArray(String[]::new);
        System.out.println("Array数组内容："+ Arrays.toString(arrs));
    }
}

    名称                                                                                     说明

    public static <T> collector toList()                  把元素收集到List集合中

    public static <T> collector toset()                   把元素收集到Set集合中

    public static collector toMap(Function keyMapper , Function valueMapper)

    把元素收集到Map集合中

我是秀秀
关注
Stream流
a137771035的博客
04-07 327
概述: Stream流是java8新增的函数式编程方式.其实就是一个函数模型,用来解决已有集合存在的弊端,比如必须依靠循环的方式来遍历集合元素,造成了代码的冗余等. Stream流类似于工厂流水线,它有以下特点: 1.Stream流是单向的,不能重复使用.重复使用同一个Stream流对象,会报出非法状态异常. 2.Stream流不能保存数据.Stream流其实是集合元素的函数模型,本身并不...
JAVA的Stream
qq_52425315的博客
11-11 392
1.初识流 import java.util.ArrayList; import java.util.List; import java.util.stream.Stream; public class Start1 { public static void main(String [] args){ List<String> list = new ArrayList<>(); list.add("王xx"); list.ad
Java函数式编程学习——Stream流
weixin_49561506的博客
11-11 1528
Java函数式编程学习——Stream流，详细介绍了Stream流的各种操作。
Java8 Stream新特性详解及实战
程序新视界
10-09 7952
Java8 Stream新特性详解及实战 背景介绍 在阅读Spring Boot源代码时，发现Java 8的新特性已经被广泛使用，如果再不学习Java8的新特性并灵活应用，你可能真的要out了。为此，针对Java8的新特性，会更新一系列的文章，欢迎大家持续关注。 首先，我们来看一下Spring Boot源代码ConfigFileApplicationListener类中的一段代码： private...
stream().map()方法详解
m0_67393686的博客
04-13 1万+
使用Stream流时发现其中的map方法使用不好容易理解，网上很多都说得很含糊不清，这里以一个小案例探讨一下Stream中map的使用。 案例涉及知识点： 1、Stream中of方法传入可变参数 2、Stream中map元素类型转化方法 3、Function匿名接口，自定义类匿名对象的使用 4、Lambda表达式 为了便于理解，首先借鉴其他博客中的说法， stream()优点 无存储。stream不是一种数据结构，它只是某种数据源的一个视图，数据源可以是一个数组，Java容器或I/O channel等。
Java Stream 流实现合并操作示例
08-19
Java Stream 流实现合并操作示例 Java Stream 流实现合并操作示例是 Java Stream Api 的一个重要应用场景。在实际开发中，我们经常需要将多个 Stream 流合并成一个流，以便进行后续的数据处理。今天，我们将详细...
Java Stream流知识总结
08-19
"Java Stream流知识总结" Java Stream流是Java 8中引入的一种新的编程模型，用于解决传统集合类库的弊端。 Stream流可以看作是一个集合元素的函数模型，它并不是集合，也不是数据结构，其本身并不存储任何元素或其...
详解JAVA Stream流
08-18
Java Stream流详解 Java Stream流是Java 8中引入的一种新的数据处理方式，它提供了一种高效、灵活的数据处理方式，能够帮助开发者更方便地处理大量数据。 Stream流不是一种数据结构，它也不是集合元素，而是一种...
Java Stream流（详解）
热门推荐
m0_60489526的博客
08-29 7万+
一、Stream流引入 Lambda表达式，基于Lambda所带来的函数式编程，又引入了一个全新的Stream概念，用于解决集合类库既有的鼻端。（Lambda表达式详解在上篇博客内容） 现有一个需求： 将list集合中姓张的元素过滤到一个新的集合中 然后将过滤出来的姓张的元素中，再过滤出来长度为3的元素，存储到一个新的集合中 1.用常规方法解决需求 /...
Java8之Stream/Map以及Lambda
努力学习，认真工作
11-28 3999
引用自Java8之Stream/Map 本篇用代码示例结合JDk源码讲了Java8引入的工具接口Stream以及新Map接口提供的常用默认方法. 参考:http://winterbe.com/posts/2014/03/16/java-8-tutorial/ 1. stream示例package com.mavsplus.java8.turtorial.streams;import jav
Java学习与复习笔记--Stream流思想概述：
gkx826的博客
09-15 281
/* * 使用传统的方式，遍历集合，对集合中的数据进行过滤 * */ public class Demo01List { public static void main(String[] args) { //创建一个List集合，存储姓名 List<String> list=new ArrayList<>(); list.add("张无忌"); list.add("周芷若"); list.add.
java8 stream()的用法
qq_32037561的博客
08-11 446
java8 stream()的用法
java8新特性（四）：Stream流的使用
不积跬步，无以至千里；不积小流，无以成江海。
11-08 2万+
过滤出素食List&lt;Dish&gt; vegetarian = menu.stream().filter(Dish::isVegetarian).collect(Collectors.toList());过滤出偶数，并且不重复的元素。List&lt;Integer&gt; numbers = Arrays.asList(1, 2, 1, 3, 3, 2, 4);numbers.stream(...
stream().map()
Mosq_yang的博客
07-17 2万+
Stream作为Java 8的一大特点，是对集合对象功能的增强，***.stream().map(...).collect(Collectors.toList())中，***需要是一个List类型的对象， 有实体类Person和Dto类PersonDto如下 public class Person { private String name; private Integer ...
jdk8 新特性stream().map()
weixin_30312563的博客
12-26 6251
1.大写字符串列表 1.1 简单的Java示例将Strings列表转换为大写 TestJava8.java package com.mkyong.java8; import java.util.ArrayList; import java.util.Arrays; import java.util.List; import java.util.stream.Collec...
stream 流方式
最新发布
04-25
stream流是Java中用于处理输入输出的一种方式。它提供了一种便捷的方式来读取和写入数据，可以用于处理文件、网络连接等各种输入输出操作。 stream流可以分为输入流和输出流两种类型。输入流用于从外部读取数据，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

我是秀秀

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

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

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

打赏作者

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

抵扣说明：

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

余额充值