java8中stream流和Lambda的实现demo实例汇总

最新推荐文章于 2023-04-07 17:57:37 发布
最新推荐文章于 2023-04-07 17:57:37 发布
阅读量153 收藏
点赞数 1
分类专栏： 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45414350/article/details/117701957
版权

一、demo准备

实体类Employee

package dto;
import lombok.Data;
@Data
public class Employee {
    private Integer id;
    private String name;
    private Integer age;
    private Double weight;

    public Employee(Integer id,String name, Integer age, Double weight) {
        this.id=id;
        this.name = name;
        this.age = age;
        this.weight = weight;
    }
    public Employee() {
    }
}

service层
MyFunction普通接口

package service;

public interface MyFunction {
    public String getValue(String str);
}

MyPredicate带泛型的接口

package service;

public interface MyPredicate<T> {
    /**
     * 对传递过来的T类型的数据进行过滤
     * 符合规则返回true，不符合规则返回false
     */
    boolean filter(T t);
}

两个实现类impl：

1.比较年龄

package service.impl;

import dto.Employee;
import service.MyPredicate;

public class FilterEmployeeByAge implements MyPredicate<Employee>{
    public boolean filter(Employee employee) {
        return employee.getAge()>18;
    }
}


2.比较体重

package service.impl;

import dto.Employee;
import service.MyPredicate;

public class FilterEmployeeByWeight implements MyPredicate<Employee>{
    public boolean filter(Employee employee) {
        return employee.getWeight()>50;
    }
}

二、测试类tast

package tast;

import dto.Employee;
import service.MyPredicate;
import service.impl.FilterEmployeeByAge;
import service.impl.FilterEmployeeByWeight;
import service.MyFunction;
import java.util.*;
import java.util.stream.Collectors;

public class Test {
    protected List<Employee> arrayList =(List<Employee>) Arrays.asList(
            new Employee(1,"张三", 16, 99.99D),
            new Employee(2,"李四", 38, 55.55D),
            new Employee(4,"田七", 18, 49.33D),
            new Employee(3,"王五", 60, 66.66D),
            new Employee(5,"赵六", 16, 77.77D),
            new Employee(6,"",19,50D),
            new Employee(7,"孙悟空",99,99999.0D),
            new Employee(7,"齐天大圣",99,99999.0D)
    );
    /*
    * 优化方案1
    * */
    public List<Employee> filterEmployee(List<Employee> list, MyPredicate<Employee> myPredicate){
        List<Employee> employees = new ArrayList<Employee>();
        for(Employee e : list){
            if(myPredicate.filter(e)){
                employees.add(e);
            }
        }
        return employees;
    }
    @org.junit.Test
    public void test1() {
        ArrayList<Employee> employees=new ArrayList<Employee>();
        for (Employee employee:arrayList) {
            if(employee.getAge()>18){
                employees.add(employee);
            }
        }
        System.out.println("年龄大于18的："+employees);
        employees=new ArrayList<Employee>();
        for (Employee employee:arrayList) {
            if(employee.getWeight()>50){
                employees.add(employee);
            }
        }
        System.out.println("体重大于50的："+employees);


        List<Employee> employeeList = this.filterEmployee(arrayList, new FilterEmployeeByAge());
        System.out.println("年龄大于18的：");
        for (Employee employee:employeeList) {
            System.out.println(employee);
        }
        System.out.println("体重大于50的：");
        employeeList=this.filterEmployee(arrayList,new FilterEmployeeByWeight());
        for (Employee employee:employeeList) {
            System.out.println(employee);
        }

    }
    /*
    *
    * 方案2使用内部类
    * */
    @org.junit.Test
    public void test2(){
        List<Employee> employees = this.filterEmployee(arrayList, new MyPredicate<Employee>() {
            public boolean filter(Employee employee) {
                return employee.getAge() > 18;
            }
        });
        for (Employee employee:employees) {
            System.out.println(employee);
        }
    }
    /*
    * 方案3使用Lambda
    * */
    @org.junit.Test
    public void test3(){
        filterEmployee(arrayList,(e)->e.getAge()>18).forEach(System.out::println);
    }
    /*
    * 方案4使用Stream API
    * limit
    * */
    @org.junit.Test
    public void test4(){
        arrayList.stream().filter(employee -> employee.getAge()>18).forEach(System.out::println);
        //限制几名
        arrayList.stream().filter(employee -> employee.getWeight()>50).limit(2).forEach(System.out::println);
    }
    /*
    * 拿取实体类的个别属性
    *
    * */
    @org.junit.Test
    public void test5(){
        arrayList.stream().filter(employee -> employee.getAge() > 18).map(Employee::getName).forEach(System.out::println);
        arrayList.stream().filter(employee -> employee.getWeight()>50).map(Employee::getName).forEach(System.out::append);
    }
    /*
    * 先比较年龄，如果年龄相同再比较姓名
    * */
    @org.junit.Test
    public void test6(){
        Collections.sort(
                arrayList,(e1,e2)->{
                    if(e1.getAge()==e2.getAge()){
                        return e1.getName().compareTo(e2.getName());
                    }
                    return Integer.compare(e1.getAge(),e2.getAge());
                    //如果想实现倒叙的排序，直接在Integer前加-
                    //return -Integer.compare(e1.getAge(),e2.getAge());
                }
        );
        arrayList.stream().forEach(System.out::println);
    }
    public String stringHander(String str, MyFunction myFunction){
        return myFunction.getValue(str);
    }
    /*
    * 大小写，截取
    * */
    @org.junit.Test
    public void test7(){
        String str = stringHander("wuchengen", e -> e.toUpperCase());
        System.out.println(str);
        String subStr = stringHander("wuchengen", e -> e.substring(0,5));
        System.out.println(subStr);

    }
    /*
    * 排序
    * */
    @org.junit.Test
    public void test8(){
        List<Employee> employees = arrayList.stream().sorted(Comparator.comparing(Employee::getAge)).collect(Collectors.toList());
        employees.stream().forEach(System.out::println);
    }
    /*
    * 字符串返回结果
    * */
    @org.junit.Test
    public void test9(){
        String str = arrayList.stream().filter(employee -> employee.getAge() > 18).map(Employee::getName).collect(Collectors.joining(","));
        System.out.println(str);
    }
    /*
    *聚合函数的应用
    * */
    @org.junit.Test
    public void test10(){
        long count = arrayList.stream().filter(employee -> employee.getName().isEmpty()).count();
        IntSummaryStatistics intSummaryStatistics = arrayList.stream().mapToInt(Employee::getAge).summaryStatistics();
        int max = intSummaryStatistics.getMax();
        int min = intSummaryStatistics.getMin();
        long sum = intSummaryStatistics.getSum();
        double average = intSummaryStatistics.getAverage();
        System.out.println("姓名为空的人数："+count);
        System.out.println("最大的年龄："+max);
        System.out.println("最小的年龄："+min);
        System.out.println("年龄和："+sum);
        System.out.println("平均年龄："+average);
        List<Employee> employees = arrayList.stream().filter(employee -> employee.getAge() == min).collect(Collectors.toList());
        System.out.println("最小年龄的员工信息"+employees);
    }
    /*
    * 其中map有三种构造方法的重载：
    * 正常的key-value结构
    * toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper);
    * key存在冲突时，解决方案
    * toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper,BinaryOperator<U> mergeFunction);
    * 第四个参数是排序的方式
    * toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper,BinaryOperator<U> mergeFunction, Supplier<M> mapSupplier);
    * */
    @org.junit.Test
    public void test11(){
        //得到姓名中包含"三"的人的姓名和员工号
        Map<Integer, String> map = arrayList.stream().filter(employee -> employee.getName().contains("三")).collect(Collectors.toMap(Employee::getId, Employee::getName));
        System.out.println(map);
        //若key存在冲突那么，可以调用tomap的第二个重载方式
        Map<Integer, String> map2 = arrayList.stream().collect(Collectors.toMap(Employee::getId, Employee::getName, (n, m) -> n +","+m));
        System.out.println(map2);
        //tomap四个参数，第四个参数是排序方式
        Map<Integer, String> map3 = arrayList.stream().collect(Collectors.toMap(Employee::getId, Employee::getName, (n, m) -> n +","+m,TreeMap::new));
        System.out.println(map3);
    }
}

三、输出测试结果

  1. 优化方案1

年龄大于18的：[Employee(id=2, name=李四, age=38, weight=55.55), Employee(id=3, name=王五, age=60, weight=66.66), Employee(id=6, name=, age=19, weight=50.0), Employee(id=7, name=孙悟空, age=99, weight=99999.0), Employee(id=7, name=齐天大圣, age=99, weight=99999.0)]
体重大于50的：[Employee(id=1, name=张三, age=16, weight=99.99), Employee(id=2, name=李四, age=38, weight=55.55), Employee(id=3, name=王五, age=60, weight=66.66), Employee(id=5, name=赵六, age=16, weight=77.77), Employee(id=7, name=孙悟空, age=99, weight=99999.0), Employee(id=7, name=齐天大圣, age=99, weight=99999.0)]
年龄大于18的：
Employee(id=2, name=李四, age=38, weight=55.55)
Employee(id=3, name=王五, age=60, weight=66.66)
Employee(id=6, name=, age=19, weight=50.0)
Employee(id=7, name=孙悟空, age=99, weight=99999.0)
Employee(id=7, name=齐天大圣, age=99, weight=99999.0)
体重大于50的：
Employee(id=1, name=张三, age=16, weight=99.99)
Employee(id=2, name=李四, age=38, weight=55.55)
Employee(id=3, name=王五, age=60, weight=66.66)
Employee(id=5, name=赵六, age=16, weight=77.77)
Employee(id=7, name=孙悟空, age=99, weight=99999.0)
Employee(id=7, name=齐天大圣, age=99, weight=99999.0)

  1. 方案2使用内部类

Employee(id=2, name=李四, age=38, weight=55.55)
Employee(id=3, name=王五, age=60, weight=66.66)
Employee(id=6, name=, age=19, weight=50.0)
Employee(id=7, name=孙悟空, age=99, weight=99999.0)
Employee(id=7, name=齐天大圣, age=99, weight=99999.0)

  1. 方案3使用Lambda

Employee(id=2, name=李四, age=38, weight=55.55)
Employee(id=3, name=王五, age=60, weight=66.66)
Employee(id=6, name=, age=19, weight=50.0)
Employee(id=7, name=孙悟空, age=99, weight=99999.0)
Employee(id=7, name=齐天大圣, age=99, weight=99999.0)

  1. 方案4使用Stream API

Employee(id=2, name=李四, age=38, weight=55.55)
Employee(id=3, name=王五, age=60, weight=66.66)
Employee(id=6, name=, age=19, weight=50.0)
Employee(id=7, name=孙悟空, age=99, weight=99999.0)
Employee(id=7, name=齐天大圣, age=99, weight=99999.0)
Employee(id=1, name=张三, age=16, weight=99.99)
Employee(id=2, name=李四, age=38, weight=55.55)

  1. 拿取实体类的个别属性

李四
王五

孙悟空
齐天大圣
张三李四王五赵六孙悟空齐天大圣

  1. 先比较年龄，如果年龄相同再比较姓名

Employee(id=1, name=张三, age=16, weight=99.99)
Employee(id=5, name=赵六, age=16, weight=77.77)
Employee(id=4, name=田七, age=18, weight=49.33)
Employee(id=6, name=, age=19, weight=50.0)
Employee(id=2, name=李四, age=38, weight=55.55)
Employee(id=3, name=王五, age=60, weight=66.66)
Employee(id=7, name=孙悟空, age=99, weight=99999.0)
Employee(id=7, name=齐天大圣, age=99, weight=99999.0)

  1. 大小写，截取

WUCHENGEN
wuche

  1. 排序按照年龄排序的)

Employee(id=1, name=张三, age=16, weight=99.99)
Employee(id=5, name=赵六, age=16, weight=77.77)
Employee(id=4, name=田七, age=18, weight=49.33)
Employee(id=6, name=, age=19, weight=50.0)
Employee(id=2, name=李四, age=38, weight=55.55)
Employee(id=3, name=王五, age=60, weight=66.66)
Employee(id=7, name=孙悟空, age=99, weight=99999.0)
Employee(id=7, name=齐天大圣, age=99, weight=99999.0)

  1. 字符串返回结果

李四,王五,孙悟空,齐天大圣

  1. 聚合函数的应用

姓名为空的人数：1
最大的年龄：99
最小的年龄：16
年龄和：365
平均年龄：45.625
最小年龄的员工信息
[Employee(id=1, name=张三, age=16, weight=99.99), Employee(id=5, name=赵六, age=16, weight=77.77)]

  1. 其中map有三种构造方法的重载

{1=张三}
{1=张三, 2=李四, 3=王五, 4=田七, 5=赵六, 6=, 7=孙悟空,齐天大圣}
{1=张三, 2=李四, 3=王五, 4=田七, 5=赵六, 6=, 7=孙悟空,齐天大圣}

捕虫小伙伴
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java8中Lambda表达式使用和Stream API详解
08-26
主要给大家介绍了关于Java8中Lambda表达式使用和Stream API的相关资料，文中通过示例代码介绍的非常详细，对大家学习或者使用Java8具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
Java SE（十四）之 Java 8新特性（Lambda，Stream流，方法引用等）
ji_meng的博客
03-14 250
作用：简化匿名内部类的代码写法首先回顾一下匿名内部类：（为什么要引入匿名内部类？匿名内部类// 首先创建一个接口 interface inter {// 直接使用匿名内部类，重写eat方法并调用 new inter() {System . out . println("正在调用eat方法");} }但是，Lambda看到这里还是觉得不够简便，所以进一步开始简化！Lambda语法：注：-> 是语法形式，无实际含义。
java8 stream流开发常用案例，看着一篇就够了
qq_37306041的博客
04-07 187
java8 stream开发中常用案例
JAVA常用stream流操作demo演示
个人网站：https://www.longzipeng.online
09-30 1653
JAVA常用stream流操作demo演示
Java 8 Stream API Demo
6个日的博客
03-26 69
Java中的集合有了更好更方便的操作方式，下面一起看看。
Java8之Stream 集合聚合操作集锦（含日常练习Demo）
Kerwin的博客
03-22 1万+
Stream 是用函数式编程方式在集合类上进行复杂操作的工具，其集成了Java 8中的众多新特性之一的聚合操作，开发者可以更容易地使用Lambda表达式，并且更方便地实现对集合的查找、遍历、过滤以及常见计算等。 直接上代码： 基础实体类： 练习代码： public static void main(String[] args) { Student ...
jdk8 新特性stream 和lambda表达式Demo
01-24
jdk8 新特性stream 和lambda表达式Demo
Java 8 新特性之Stream 和 Lambda
01-24
Java 8 新特性之Stream 和 Lambda
在java 8 stream表达式中实现if/else逻辑
01-20
在Stream处理中，我们通常会遇到if/else的判断情况，对于这样的问题我们怎么处理呢？ 还记得我们在上一篇文章lambda最佳实践中提到，lambda表达式应该越简洁越好，不要在其中写臃肿的业务逻辑。 接下来我们看一个...
【Java8】Lambda表达式 和 Stream API 详解笔记.zip
11-26
视频地址：https://www.bilibili.com/video/BV1ut411g7E9 【Java8】Lambda表达式 和 Stream API 详解笔记 md文档
Java8系列--Java Stream入门篇（什么是Stream）
高自强的博客
07-16 1万+
1 知识框架　　先上一张图来说明一下Java8中”流”的引进、意义和优势。 2 传统Java集合的不足2.1 传统Java集合　　集合是Java中用途十分广泛的一个集合，正是因为它对于数据的处理的优势，几乎任何一个Java应用程序都会设计对Java集合的制造和处理。 　　然而，一个传统的Java集合仅仅是对Java集合内部的数据进行简单的添加、删除等操作，而且处理的数据类型有限。
java8 Stream 所有函数demo
zhouzhenyong的专栏
06-13 614
所有函数： allMatch 和 anyMatch /** * allMatch 和 anyMatch * 这个并不是过滤数据用的，而只是获取一个判断结果 * * 注意：这个函数一个Stream只能调用一次，调用一次后，这个Stream就调用close，也就是流就会关闭了， * 如果还要使用，那么需要再开辟一个 */ @Test public void allMatchAndAnyMatchTest(){ List<Integer> integerList = Array.
java8 stream按需汇总数据Demo
leejiliang的博客
04-24 2880
测试实体类：class Numer{ private int age; private int sum1; private Map map11; public int getAge() { return age; } public void setAge(int age) { this.age = age; } public int getSum1()
JAVA中的Lambda表达式
weixin_47600732的博客
03-28 6400
JAVA中的Lambda表达式 1.简介 1.Lambda表达式： JDK1.7版本以上推出新的特性，简单的说就是他没有声明的方法，也就是说没有访问修饰词，返回值等。 Lambda表达式用于创建匿名内部类所属的接口，必须只能有一个抽象方法，否则不可以使用Lambda表达式。 2.语法规则： （方法的参数）->{ 方法体 } 3.lambda表达式的标准格式由三部分组成： 1.一些参数 2.一个箭头 3.一段代码 4.格式说明： ()：接口中抽象方法参数，没有参数就空着，有参数就写参数，有多个参数就
Lambda表达式Stream流常用方法
weixin_45947759的博客
12-22 1241
lambda表达式 标准格式： 组成 一些参数 一个箭头 一段代码 格式：（参数列表）->{重写方法的代码}; 解释说明格式： ()：接口中抽象方法的参数列表，没有参数就空着，多个参数逗号分隔 ->：将参数传递给方法体 {} 函数式接口 位于 java.util.function 包中，下面为最简单的几个接口使用示例 Supplier接口（其它接口看文档） 接口仅包含一个午餐的方法：T get()。用于获取一个泛型参数指定类型的对象数据，由于这是一个函数式接口，也就意味着对应
Java 8 stream的使用示例
FanGer的博客
04-27 235
Java 8 stream的使用示例 一、概述 Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简而言之，Stream API 提供了一种高效且易于使用的处理数据的方式。 特点： 元素是特定类型的对象，形成一个队列。 Java中的Stream并不会存储元素，而是按需计算。 数据源
Java8新特性之Stream流以及方法引用
来日浅谈的博客
03-09 4993
Java8新特性之Stream流以及方法引用一. String流1. 引言2. 流式思想概述3. 获取流4. 常用方法4.1 逐一处理：forEach4.2 过滤：filter4.3 映射：map4.4 统计个数：count4.5 取前几个：limit4.6 跳过前几个：skip4.7 组合：concat二. 方法引用1. 冗余的Lambda场景2. 问题分析3. 用方法引用改进代码4. 方法引用...
【Java 8系列】Stream详解，看这一篇就够啦
热门推荐
Yangy的博客
12-23 5万+
热门系列： 【Java 8系列】Java开发者的判空利器 -- Optional 【Java 8系列】Lambda 表达式，一看就废 程序人生，精彩抢先看 1.前言 2.正文 3.总结 ...
stream流中lambda表达式详解
最新发布
09-07
在Android中，Lambda表达式的使用主要体现在Java 8引入的一些新特性中，例如Stream API、接口默认实现等。Lambda表达式在Android系统中的兼容性相对较好，可以兼容到Android 2.3版本的系统。 Lambda表达式的基本...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值