JDK8之流Stream实战

最新推荐文章于 2022-07-19 07:30:00 发布

java-girl

最新推荐文章于 2022-07-19 07:30:00 发布

阅读量225

点赞数 1

分类专栏： JDK8-13学习

本文链接：https://blog.csdn.net/qq_39922867/article/details/103726051

版权

JDK8-13学习专栏收录该内容

2 篇文章 0 订阅

订阅专栏

什么是stream

Stream中文称为"流",通过将集合转换为这么一种叫做"流"的元素队列,通过声明性方式,能够对集合中的每个元素进行一系列并行或者串行的流水线操作
元素是指特定类型的对象,所以元素集合看做一种流,流在管道中传输,且可以在管道的节点上进行处理,比如:排序,聚合,过滤等操作

数据元素集合—>生成流—>中间操作—>终端操作

操作详情

数据元素便是原始集合,如List,Set,Map等
生成流,可以是串行流Stream()或者并行流parallelStream()
中间操作,可以是排序,聚合,过滤,转换等
终端操作,很多流操作本身就会返回一个流,所以多个操作可以直接连接起来,最后统一进行收集
概览stream接口源码

实操 .map 函数


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

public class Main {
    public static void main(String[] args) {
        /**
         * map 使用场景:把一个对象转成另一个对象
         * 如 把数据库数据转换成DTO接口数据
         */
        List<User> list = Arrays.asList(new User(1, "a", "123"), new User(2, "b", "123"), new User(3, "c", "123"));
        List<UserDTO> userDTOS = list.stream().map(obj -> new UserDTO(obj)).collect(Collectors.toList());
        System.out.println(userDTOS);
    }
}

class User {

    private int id;
    private String name;
    private String pwd;

    public User() {
    }

    public User(int id, String name, String pwd) {
        this.id = id;
        this.name = name;
        this.pwd = pwd;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

}

class UserDTO {

    private String username;
    private int userId;

    public UserDTO(User user) {
        this.username = user.getName();
        this.userId = user.getId();
    }

    public UserDTO() {
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public int getUserId() {
        return userId;
    }

    public void setUserId(int userId) {
        this.userId = userId;
    }

    @Override
    public String toString() {
        return "UserDTO{" +
                "username='" + username + '\'' +
                ", userId=" + userId +
                '}';
    }
}

打印结果:
[UserDTO{username='a', userId=1}, UserDTO{username='b', userId=2}, UserDTO{username='c', userId=3}]

实操 .filter函数 (主要用于筛选过滤出符合条件的元素)

filter函数

用于通过设置的条件过滤元素
需求:过滤出字符串长度大于5的字符串
场景:主要用于筛选过滤出符合条件的元素

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

public class Main {
    public static void main(String[] args) {
    /**
    * 筛选含有我的字符
    */
        List<String> list = Arrays.asList("abc我客户方", "我是不会错的", "韩国的说法", "最近我有什么好事");
        List<String> list1 = list.stream().filter(obj -> obj.contains("我")).collect(Collectors.toList());
        System.out.println(list1);
    }
}

打印结果
[abc我客户方, 我是不会错的, 最近我有什么好事]

实操 .sorted函数

sorted()对流进行自然排序,其中的元素必须实现Comparable接口

默认是升序
public class Main {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("a", "e", "f", "d","q");
        List<String> list1 = list.stream().sorted().collect(Collectors.toList());
        System.out.println(list1);
    }
}

打印结果
[a, d, e, f, q]

sorted(Comparator<? super T> comparator)用来自定义升降序

public class Main {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("apples", "email", "abc", "dogs", "tomcat-a");
        // 升序
        List<String> list1 = list.stream().sorted(Comparator.comparing(obj -> obj.length())).collect(Collectors.toList());
        System.out.println(list1);
        //降序
        List<String> list2 = list.stream().sorted(Comparator.comparing(obj -> obj.length(), Comparator.reverseOrder())).collect(Collectors.toList());
        System.out.println(list2);
        
        List<String> list3 = list.stream().sorted(Comparator.comparing(String::length, Comparator.reverseOrder())).collect(Collectors.toList());
        System.out.println(list3);

    }
}

打印结果
[abc, dogs, email, apples, tomcat-a]
[tomcat-a, apples, email, dogs, abc]
[tomcat-a, apples, email, dogs, abc]

实操 .limit 函数

截断流使其最多只包含指定数量的元素

   List<String> list = Arrays.asList("apples", "email", "abc", "dogs", "tomcat-a");
        List<String> list4 = list.stream().sorted(Comparator.comparing(String::length).reversed()).limit(2).collect(Collectors.toList());
        System.out.println(list4);

打印结果
[tomcat-a, apples]

需求操作

public static void main(String[] args) {
        List<VideoOrder> videoOrders1 = Arrays.asList(
                new VideoOrder("20190242812", 3, "springboot教程"),
                new VideoOrder("20194350812", 5, "微服务Springcloud"),
                new VideoOrder("20190814232", 9, "Redis教程"),
                new VideoOrder("20190523812", 9, "网页开发教程"),
                new VideoOrder("201932324", 9, "百万并发是实战Netty"));

        List<VideoOrder> videoOrders2 = Arrays.asList(
                new VideoOrder("2019024285312", 3, "springboot教程"),
                new VideoOrder("2019081453232", 9, "Redis教程"),
                new VideoOrder("20190522338312", 9, "网页开发教程"),
                new VideoOrder("2019435230812", 5, "Jmeter压力测试"),
                new VideoOrder("2019323542424", 21, "Idea全套教程"),
                new VideoOrder("2019323542411", 7, "Git+Jenkins持续集成"));

        //统计出同事被两个人购买的商品列表(交集)
        List<VideoOrder> list = videoOrders1.stream().filter(videoOrders2::contains).collect(Collectors.toList());
        System.out.println(list);

        //统计出两个人购买商品的差集
        List<VideoOrder> diffList1 = videoOrders1.stream().filter(obj -> !videoOrders2.contains(obj)).collect(Collectors.toList());
        System.out.println("差集1=" + diffList1);
        List<VideoOrder> diffList2 = videoOrders2.stream().filter(obj -> !videoOrders1.contains(obj)).collect(Collectors.toList());
        System.out.println("差集2=" + diffList2);
        
        //统计出全部被购买商品的并集
        List<VideoOrder> videoOrderStream = videoOrders1.parallelStream().collect(Collectors.toList());
        videoOrderStream.addAll(videoOrders2);
        System.out.println("并集=" + videoOrderStream);
        
        //统计出全部被购买商品的去重并集
        List<VideoOrder> collect = videoOrderStream.parallelStream().distinct().collect(Collectors.toList());
        System.out.println("去重并集=" + collect);

        //统计出两个人的分别购买订单的平均价格
        Double avg1 = videoOrders1.stream().collect(Collectors.averagingInt(VideoOrder::getMoney)).doubleValue();
        System.out.println("订单1平均价格="+avg1);
        Double avg2 = videoOrders2.stream().collect(Collectors.averagingInt(obj -> obj.getMoney())).doubleValue();
        System.out.println("订单2平均价格="+avg2);
        
        //统计出两个人的分别购买订单的总价格
        Integer total1 = videoOrders1.stream().collect(Collectors.summingInt(obj -> obj.getMoney())).intValue();
        System.out.println("订单1总价格="+total1);
        Integer total2 = videoOrders2.stream().collect(Collectors.summingInt(obj -> obj.getMoney())).intValue();
        System.out.println("订单2总价格="+total2);
    }
}

打印结果
[VideoOrder{title='springboot教程'}, VideoOrder{title='Redis教程'}, VideoOrder{title='网页开发教程'}]
差集1=[VideoOrder{title='微服务Springcloud'}, VideoOrder{title='百万并发是实战Netty'}]
差集2=[VideoOrder{title='Jmeter压力测试'}, VideoOrder{title='Idea全套教程'}, VideoOrder{title='Git+Jenkins持续集成'}]
并集=[VideoOrder{title='springboot教程'}, VideoOrder{title='微服务Springcloud'}, VideoOrder{title='Redis教程'}, VideoOrder{title='网页开发教程'}, VideoOrder{title='百万并发是实战Netty'}, VideoOrder{title='springboot教程'}, VideoOrder{title='Redis教程'}, VideoOrder{title='网页开发教程'}, VideoOrder{title='Jmeter压力测试'}, VideoOrder{title='Idea全套教程'}, VideoOrder{title='Git+Jenkins持续集成'}]
去重并集=[VideoOrder{title='springboot教程'}, VideoOrder{title='微服务Springcloud'}, VideoOrder{title='Redis教程'}, VideoOrder{title='网页开发教程'}, VideoOrder{title='百万并发是实战Netty'}, VideoOrder{title='Jmeter压力测试'}, VideoOrder{title='Idea全套教程'}, VideoOrder{title='Git+Jenkins持续集成'}]
订单1平均价格=7.0
订单2平均价格=9.0
订单1总价格=35
订单2总价格=54

**实体类**
class VideoOrder {

    private String tradeNo;
    private int money;
    private String title;

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        //重写equals方法
        if (o instanceof VideoOrder) {
            VideoOrder obj = (VideoOrder) o;
            return title.equals(obj.title);
        }

        if (!(o instanceof VideoOrder)) return false;
        VideoOrder that = (VideoOrder) o;
        return money == that.money &&
                Objects.equals(tradeNo, that.tradeNo) &&
                Objects.equals(title, that.title);
    }

    @Override
    public int hashCode() {
        //重写hashcode
        return title.hashCode();
    }

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

    public VideoOrder() {
    }

    public VideoOrder(String tradeNo, int money, String title) {
        this.tradeNo = tradeNo;
        this.money = money;
        this.title = title;
    }

    public String getTradeNo() {
        return tradeNo;
    }

    public void setTradeNo(String tradeNo) {
        this.tradeNo = tradeNo;
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }
}