java Stream流与Lambda表达式

已于 2023-03-25 23:02:53 修改
阅读量1.9k 收藏 4
点赞数
分类专栏： java 文章标签： java
于 2022-04-01 22:27:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45703155/article/details/123859669
版权

一. Stream流：

在这里插入图片描述

1.1中间操作和终止操作的区别：
中间操作是流水线中的数据进行加工的, 它是一个懒操作, 并不会马上执行, 需要等待有终止操作的时候才会执行.
终止操作是Stream的启动操作, 当有终止操作的时候, Stream才会真正的开始执行.

        List<Integer> list = Arrays.asList(4, 7, 9, 11, 12);
        list.stream()
                .peek(x -> System.out.println("stream: " + x));

没有输出，因为peek是中间操作，并不会马上执行, 需要等待有终止操作的时候才会执行。

List<Integer> list = Arrays.asList(4, 7, 9, 11, 12);
        list.stream()
                .peek(x -> System.out.println("stream: " + x))
                .collect(Collectors.toList());

有输出如下：
在这里插入图片描述
因为collect是终止操作，是终止操作的时候, Stream才会真正的开始执行。

1.2 Stream流的整个过程
(1)生成流：通过数据源(集合,数组等)生成流

list.stream0

(2)中间操作：一个流后面可以跟随零个或多个中间操作，其目的主要是打开流，做出某种程度的数据过滤/映射，然后返回一个新的流交给下一个操作使用

filter()
map()
limit()等等

(3)终结操作：一个流只能有一个终结操作，当这个操作执行后，流就被使用“光”了，无法再被操作。所以这必定是流的最后一个操作

forEach()
collect()
findAny()等等

1.3 Stream流的常见生成方式
Collection体系的集合：可以使用默认方法stream()生成流default Stream stream()
Map体系的集合:间接的生成流
数组:可以通过Stream接口的静态方法of(T…values)生成流
具体如下：
在这里插入图片描述
集合与数组拿到Stream流：
在这里插入图片描述
在这里插入图片描述
** （1）由数值直接构建流
（2）由数组直接构建流
（3）通过文件生成流
（4) 函数生成流**

public static void main(String[] args){
        /**
         * 由数值直接构建流
         */
        Stream stream = Stream.of(1, 2, 3, 4, 5);
        System.out.println("由数值直接构建流：");
        stream.forEach(System.out::println);

        /**
         * 由数组直接构建流
         */
        int[] numbers = {1, 2, 8};
        IntStream stream1 = Arrays.stream(numbers);
        System.out.println("由数组直接构建流：");
        stream1.forEach(System.out::println);

        /**
         * 通过文件生成流
         */
        Stream<String> stream2 = null;
        try {
            stream2 = Files.lines(Paths.get("E://admin//java//JedisDemo/pom.xml"));
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println("通过文件生成流：");
        stream2.forEach(System.out::println);

        /**
         * 函数生成流
         */
        Stream stream3 = Stream.generate(Math::random);
        System.out.println("函数生成流：");
        stream3.limit(100).forEach(System.out::println);
    }

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

1.4 Stream流的常见中间操作方法：
用于对流中的数据进行过滤：

Streamfilter(Predicate predicate)

Predicate接口中的方法，对给定的参数进行判断，返回一个布尔值

boolean test(T t)

1.4.1 filter使用（过滤掉不符合条件的数据）：
在这里插入图片描述
1.4.2 limit（只取前面几条数据） 和 skip（跳过前面的几条数据）的使用：
在这里插入图片描述
1.4.3 concat 和 distinct（返回不同元素，相同的只返回一个）的使用：
在这里插入图片描述
1.4.4 sorted的使用（排序）：

User user1 = new User();
        User user2 = new User();
        user1.setPhoneNum("19283");
        user1.setUserName("小小");
        user2.setPhoneNum("16736");
        user2.setUserName("哈哈");
        List<User> list1 = new ArrayList<>();
        list1.add(user1);
        list1.add(user2);
        System.out.println("list1的数据：");
        System.out.println(JSON.toJSONString(list1,true));
        System.out.println("stream后的数据：");
        list1.stream()
                //按照id降序排
                .sorted(Comparator.comparing(User::getUserName).reversed())
                .forEach(item -> System.out.println(JSON.toJSONString(item,true)));
        System.out.println("stream后的数据：");
        list1.stream()
                //按照id升序排
                .sorted(Comparator.comparing(User::getUserName))
                .forEach(item -> System.out.println(JSON.toJSONString(item,true)));

在这里插入图片描述
在这里插入图片描述
1.4.5 flatMap的使用（将一个对象转换成流）：

    public static void main(String[] args) {
        
        List<Map<String, Object>> list = new ArrayList<>();
        Map<String, Object> map1 = new HashMap<>();
        map1.put("id",1);
        map1.put("amount", BigDecimal.valueOf(23));
        map1.put("type","苹果");
        Map<String, Object> map2 = new HashMap<>();
        map2.put("id",2);
        map2.put("amount",BigDecimal.valueOf(54));
        map2.put("type","雪梨");
        Map<String, Object> map3 = new HashMap<>();
        map3.put("id",3);
        map3.put("amount",null);
        map3.put("type","苹果");
        list.add(map1);
        list.add(map2);
        list.add(map3);
        list.stream().peek(e -> e.get("type"));

        System.out.println("list集合数据：");
        System.out.println(list);
        System.out.println("stream后的数据：");
        list.stream()
                .flatMap(e -> Arrays.stream(MapUtils.getString(e,"type").split("")))
                .forEach(System.out::println);
    }

在这里插入图片描述

1.4.6 map的使用（将一个元素转换成另一给元素）：

    public static void main(String[] args) {
        
        List<Map<String, Object>> list = new ArrayList<>();
        Map<String, Object> map1 = new HashMap<>();
        map1.put("id",1);
        map1.put("amount", BigDecimal.valueOf(23));
        map1.put("type","苹果");
        Map<String, Object> map2 = new HashMap<>();
        map2.put("id",2);
        map2.put("amount",BigDecimal.valueOf(54));
        map2.put("type","雪梨");
        Map<String, Object> map3 = new HashMap<>();
        map3.put("id",3);
        map3.put("amount",null);
        map3.put("type","苹果");
        list.add(map1);
        list.add(map2);
        list.add(map3);
        list.stream().peek(e -> e.get("type"));
        System.out.println("list集合数据：");
        System.out.println(list);
        System.out.println("stream后的数据：");
        //只获取type数据，以集合方式返回
        list.stream().map(e -> MapUtils.getString(e,"type")).forEach(System.out::println);
    }

在这里插入图片描述

在这里插入图片描述
1.4.7 peek的使用（查看流中间内容）：

public static void main(String[] args) {
        List<Integer> list = Arrays.asList(4, 7, 9, 11, 12);
        list.stream()
                .peek(x -> System.out.println("stream: " + x))
                .map(x -> x + 2)
                .peek(x -> System.out.println("map: " + x))
                .filter(x -> x % 2 != 0)
                .peek(x -> System.out.println("filter: " + x))
                .limit(2)
                .peek(x -> System.out.println("limit: " + x))
                .collect(Collectors.toList());
    }

在这里插入图片描述
1.4.8 peek和map的区别：
peek的定义：

Stream peek(Consumer<? super T> action);

peek方法接收一个Consumer的入参. 了解λ表达式的应该明白 Consumer的实现类应该只有一个方法，该方法返回类型为void. 它只是对Stream中的元素进行某些操作,但是操作之后的数据并不返回到Stream中,所以Stream中的元素还是原来的元素.

map的定义：

Stream map(Function<? super T, ? extends R> mapper);

map方法接收一个Function作为入参. Function是有返回值的, 这就表示map对Stream中的元素的操作结果都会返回到Stream中去.

1.5 Stream流的常见终结操作方法
1.5.1 foreach 和 count的使用：
对此流的每个元素执行操作（Consumer接口中的方法 ；voidaccept(Tt):对给定的参数执行此操作） ：

void forEach(Consumer action)

返回此流中的元素数：

long count()
在这里插入图片描述
1.5.2 allMatch（是否集合中全部数据都符合条件，全部符合返回true，有一个不符合都返回false）
anyMatch（是否集合中有数据都符合条件，只要找到有一个符合条件就返回true，全部都不符合返回false）
noneMatch（是否集合中所有元素都不符合条件，只有都不符合条件才返回true，有一个符合条件就返回false）

User user1 = new User();
        User user2 = new User();
        user1.setPhoneNum("19283");
        user1.setUserName("小小");
        user1.setRole(18);
        user2.setPhoneNum("16736");
        user2.setUserName("哈哈");
        user2.setRole(20);
        List<User> list1 = new ArrayList<>();
        list1.add(user1);
        list1.add(user2);
        System.out.println("list1的数据：");
        System.out.println(JSON.toJSONString(list1,true));
        System.out.println("stream后的数据：");
        Boolean role1 = list1.stream()
                //是否list1中全部role都小于19，全部小于返回true，有一个不小于都返回false
                .allMatch(e -> e.getRole() < 19 );
        System.out.println(role1);
        System.out.println("stream后的数据：");
        Boolean role2 = list1.stream()
                .peek(e -> System.out.println(e.getRole()))
                //list1中是否有role小于19，只要找到有一个小于19就返回true，全部都不小于19返回false
                .anyMatch(e -> e.getRole() < 19);
        System.out.println(JSON.toJSONString(list1,true));
        System.out.println(role2);
        Boolean role3 = list1.stream()
                .peek(e -> System.out.println(e.getRole()))
                //list1中是否所有role都不小于17，全部不小于返回true，有一个小于返回false
                .noneMatch(e -> e.getRole() < 17);
        System.out.println(JSON.toJSONString(list1,true));
        System.out.println(role3);

在这里插入图片描述
在这里插入图片描述
1.5.3 findirst（获取第一条数据）
findAny（随机获取一条数据）

     User user1 = new User();
        User user2 = new User();
        user1.setPhoneNum("19283");
        user1.setUserName("小小");
        user1.setRole(18);
        user2.setPhoneNum("16736");
        user2.setUserName("哈哈");
        user2.setRole(20);
        List<User> list1 = new ArrayList<>();
        list1.add(user1);
        list1.add(user2);
        System.out.println("list1的数据：");
        System.out.println(JSON.toJSONString(list1,true));
        System.out.println("stream后的数据：");
        //找到第一条数据，并用get()方法获取，没有数据是null，有数据是User对象
        Optional<User> optional = list1.stream().findFirst();
        System.out.println(JSON.toJSONString(optional.get(),true));
        System.out.println("stream后的数据：");
        //随机找到一条数据，并用get()方法获取，没有数据是null，有数据是User对象
        Optional<User> optional2 = list1.stream().findAny();
        System.out.println(JSON.toJSONString(optional2.get(),true));

在这里插入图片描述

1.5.4 Max（获取最大值）
Min（获取最小值）
count（获取一共有多少条数据）

 User user1 = new User();
        User user2 = new User();
        user1.setPhoneNum("19283");
        user1.setUserName("小小");
        user1.setRole(18);
        user2.setPhoneNum("16736");
        user2.setUserName("哈哈");
        user2.setRole(20);
        List<User> list1 = new ArrayList<>();
        list1.add(user1);
        list1.add(user2);
        System.out.println("list1的数据：");
        System.out.println(JSON.toJSONString(list1,true));
        System.out.println("stream后的数据：");
        //获取Role最大的role值
        OptionalDouble optionalDouble = list1.stream()
                //mapToDouble把role值变成Double类型
                .mapToDouble(User::getRole)
                .max();
        System.out.println(optionalDouble.getAsDouble());
        System.out.println("stream后的数据：");
        //获取Role最小的role值
        OptionalDouble optionalDouble2 = list1.stream()
                //mapToDouble把role值变成Double类型
                .mapToDouble(User::getRole)
                .min();
        System.out.println(optionalDouble2.getAsDouble());
        System.out.println("stream后的数据：");
        //获取一共有多少条数据
        Long count = list1.stream()
                .count();
        System.out.println(count);

在这里插入图片描述
1.6 Stream流的收集操作：
对数据使用Stream流的方式操作完毕后，我想把流中的数据收集到集合中，该怎么办呢?stream流的收集方法：

R collect(Collector collector)

但是这个收集方法的参数是一个Collector 接口

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

publicstatic Collector toList(): 把元素收集到List集合中

publicstatic Collector toSet(): 把元素收集到Set集合中

publicstatic CollectortoMap(Function keyMapper,FunctionvalueMapper):把元素收集到Map集合中

1.6.1 collect的使用：
在这里插入图片描述
在这里插入图片描述
1.6.2 groupingBy（分组，按照某个字段分组，key为该字段的值）
partitioningBy（分区，符合条件和不符合条件的分组，key为布尔值）

        User user1 = new User();
        User user2 = new User();
        User user3 = new User();
        user1.setPhoneNum("19283");
        user1.setUserName("小小");
        user1.setRole(18);
        user2.setPhoneNum("16736");
        user2.setUserName("哈哈");
        user2.setRole(20);
        user3.setPhoneNum("18734");
        user3.setUserName("丽丽");
        user3.setRole(1);
        List<User> list1 = new ArrayList<>();
        list1.add(user1);
        list1.add(user2);
        list1.add(user3);
        System.out.println("list1的数据：");
        System.out.println(JSON.toJSONString(list1, true));
        System.out.println("stream后的数据：");
        Map<String, List<User>> listGroupMap = list1.stream()
                //按照userName分组
                .collect(Collectors.groupingBy(e -> e.getUserName()));
        System.out.println(JSON.toJSONString(listGroupMap,true));
        System.out.println("stream后的数据：");
        Map<Boolean, List<User>> listGroupMap1 = list1.stream()
                //按照userName分组
                .collect(Collectors.partitioningBy(e -> e.getRole() > 18));
        System.out.println(JSON.toJSONString(listGroupMap1,true));

在这里插入图片描述

1.7 总结：
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
例子：

List<Map<String,Object>> orgUnitList = new ArrayList<>();

		Map<String,Object> orgUnit1 = new HashMap<>();
		orgUnit1.put("id",1);
		orgUnit1.put("unitName","组织1");
		orgUnitList.add(orgUnit1);

		Map<String,Object> orgUnit2 = new HashMap<>();
		orgUnit2.put("id",2);
		orgUnit2.put("unitName","组织2");
		orgUnitList.add(orgUnit2);

		System.out.println(orgUnitList);
		List<Integer> allIdList = orgUnitList.stream().map(i -> Integer.parseInt(i.get("id").toString())).collect(Collectors.toList());
		System.out.println(allIdList);

        String treeSql = " select org.id,org.parentId as pId,org.unitName as name " +
                " from orgunit org  " +
                " where org.id in ?1 ";

        List<Map<String, Object>> orgUnitTreeList = jpaDao.nativeQueryAll(treeSql, allIdList);
		System.out.println(orgUnitTreeList);

[{unitName=组织1, id=1}, {unitName=组织2, id=2}]
[1, 2]
[{name=超级管理员, pId=-1, id=1}, {name=总公司, pId=null, id=2}]

Lambda表达式：

任何一个接口，有且只有 一个抽象方法，那么它就是函数式接口。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
抽象方法带参数，没有返回值：
在这里插入图片描述

在这里插入图片描述
抽象方法带参数，有返回值：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

实例：

1.求某个人的总存款：


    public static void main(String[] args) {
        /**
         * 创建集合数据
         */
        List<Map<String,Object>> orderMapList = new ArrayList<>();
        Map<String,Object> orderMap1 = new HashMap<>();
        orderMap1.put("money",20.00);
        orderMap1.put("name","LiLi");
        Map<String,Object> orderMap2 = new HashMap<>();
        orderMap2.put("money",33.34);
        orderMap2.put("name","HaHa");
        Map<String,Object> orderMap3 = new HashMap<>();
        orderMap3.put("money",11.21);
        orderMap3.put("name","LiLi");
        orderMapList.add(orderMap1);
        orderMapList.add(orderMap2);
        orderMapList.add(orderMap3);
        System.out.print("orderMapList:"+orderMapList+"\n");

        /**
         * 过滤出 name="LiLi" 的数据
         */
        List<Map<String,Object>> liLiList = orderMapList.stream().filter(e -> e.get("name")
                        .equals("LiLi")).collect(Collectors.toList());
        System.out.printf("liLiList:"+liLiList+"\n");

        /**
         * 计算出 name="LiLi" 的 money的和
         */
        Double money = liLiList.stream().mapToDouble(e ->
                Double.parseDouble(e.get("money").toString())).sum();
        System.out.printf("money:"+money);
    }

结果如图：
在这里插入图片描述

2.求list集合里的某个时间字段指定时间范围的数据：

public static void main(String[] args) {
        /**
         * 创建集合数据
         */
        String stringA = "2021-01-07";
        String stringB = "2021-01-08";
        String stringC = "2021-01-09";
        Date dateA = null;
        Date dateB = null;
        Date dateC = null;
        try {
            dateA = new SimpleDateFormat("yyyy-MM-dd").parse(stringA);
            dateB = new SimpleDateFormat("yyyy-MM-dd").parse(stringB);
            dateC = new SimpleDateFormat("yyyy-MM-dd").parse(stringC);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        List<Map<String,Object>> orderMapList = new ArrayList<>();
        Map<String,Object> orderMap1 = new HashMap<>();
        orderMap1.put("date",dateA);
        orderMap1.put("name","LiLi");
        Map<String,Object> orderMap2 = new HashMap<>();
        orderMap2.put("date",dateB);
        orderMap2.put("name","HaHa");
        Map<String,Object> orderMap3 = new HashMap<>();
        orderMap3.put("date",dateC);
        orderMap3.put("name","LiLi");
        orderMapList.add(orderMap1);
        orderMapList.add(orderMap2);
        orderMapList.add(orderMap3);
        System.out.print("orderMapList:"+orderMapList+"\n");

        /**
         * 字符串日期转Date
         */
        String  string1 = "2021-01-07";
        String string2= "2021-01-09";
        Date startDate1 = null;
        Date endDate1 = null;
        try {
            //开始时间
            startDate1 = new SimpleDateFormat("yyyy-MM-dd").parse(string1);
            //结束时间
            endDate1 = new SimpleDateFormat("yyyy-MM-dd").parse(string2);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        Date startDate = startDate1;
        Date endDate = endDate1;
        System.out.printf("startDate:"+startDate+"\n");
        System.out.printf("endDate:"+endDate+"\n");

        /**
         * 过滤出 时间在startDate到endDate 的数据
         */
        List<Map<String,Object>> liLiList = orderMapList.stream()
                //startDate小于date，endDate大于endDate的数据
                .filter(e -> startDate.before((Date)e.get("date")) && endDate.after((Date)e.get("date")))
                .collect(Collectors.toList());
        System.out.printf("liLiList:"+liLiList+"\n");
    }

结果如图：
在这里插入图片描述
3.对list集合里的某个字段进行降序排：

    public static void main(String[] args) {
        /**
         * 创建集合数据
         */
        List<Map<String,Object>> orderMapList = new ArrayList<>();
        Map<String,Object> orderMap1 = new HashMap<>();
        orderMap1.put("sore",12);
        orderMap1.put("name","LiLi");
        Map<String,Object> orderMap2 = new HashMap<>();
        orderMap2.put("sore",34);
        orderMap2.put("name","HaHa");
        Map<String,Object> orderMap3 = new HashMap<>();
        orderMap3.put("sore",38);
        orderMap3.put("name","LiLi");
        Map<String,Object> orderMap4 = new HashMap<>();
        orderMap4.put("sore",38);
        orderMap4.put("name","LiLiAA");
        orderMapList.add(orderMap1);
        orderMapList.add(orderMap2);
        orderMapList.add(orderMap3);
        orderMapList.add(orderMap4);
        System.out.print("orderMapList:"+orderMapList+"\n");

        /**
         * 对orderMapList集合的分数进行降序排序
         */
        Collections.reverse(orderMapList);
        System.out.printf("liLiList:"+orderMapList+"\n");

结果如图：
在这里插入图片描述
4.对list集合里的某个字段进行升序排：

    public static void main(String[] args) {
        /**
         * 创建集合数据
         */
        List<Map<String,Object>> orderMapList = new ArrayList<>();
        Map<String,Object> orderMap1 = new HashMap<>();
        orderMap1.put("sore",12);
        orderMap1.put("name","LiLi");
        Map<String,Object> orderMap2 = new HashMap<>();
        orderMap2.put("sore",34);
        orderMap2.put("name","HaHa");
        Map<String,Object> orderMap3 = new HashMap<>();
        orderMap3.put("sore",38);
        orderMap3.put("name","LiLi");
        Map<String,Object> orderMap4 = new HashMap<>();
        orderMap4.put("sore",38);
        orderMap4.put("name","LiLiAA");
        orderMapList.add(orderMap1);
        orderMapList.add(orderMap2);
        orderMapList.add(orderMap3);
        orderMapList.add(orderMap4);
        System.out.print("orderMapList:"+orderMapList+"\n");

        /**
         * 对list集合内的某个值进行排序处理
         */
        //Collections.sort(),排序默认sort()，但是要保证集合中的对象是 可比较的。
        //根据姓名unitName,fullName,customerName排序
        //Collections.sort(dataList, (o1, o2) -> {
        //    return (((String)o2.get( "unitName" ) + (String)o2.get( "name" )).compareTo(
        //            (String)o1.get( "unitName" ) + (String)o1.get( "name" )));
        //});
        Collections.sort(orderMapList, Comparator.comparingInt(a -> Integer.valueOf(a.get("sore").toString()) ));
        System.out.printf("liLiList:"+orderMapList+"\n");
    }

结果如图：
在这里插入图片描述

5.按照集合中的某个key分组计算其它数据之和，并把计算的和写在每组同类key的最后面，效果如下图：
在这里插入图片描述

public static void main(String[] args) throws IOException, ClassNotFoundException {
        //存放所有数据
        List<Map<String, Object>> dataList = new ArrayList<Map<String, Object>>();

        Map<String, Object> m1 = new HashMap<String, Object>();
        m1.put("name", "张三");
        m1.put("afterSaleProfit", 1.3);
        m1.put("sore", 1.3);
        dataList.add(m1);

        Map<String, Object> m2 = new HashMap<String, Object>();
        m2.put("name", "李四");
        m2.put("afterSaleProfit", 2);
        m2.put("sore", 2);
        dataList.add(m2);

        Map<String, Object> m3 = new HashMap<String, Object>();
        m3.put("name", "李四");
        m3.put("afterSaleProfit", 1.2);
        m3.put("sore", 1.2);
        dataList.add(m3);

        Map<String, Object> m4 = new HashMap<String, Object>();
        m4.put("name", null);
        m4.put("afterSaleProfit", 0);
        m4.put("sore", 1.2);
        dataList.add(m4);
        System.out.printf("原数据 dataList：" + dataList + "\n");

        //过滤,保留name的值不为空的数据
        dataList = dataList.stream().filter(e -> Objects.nonNull(e.get("name"))).collect(Collectors.toList());
        System.out.printf("原过滤数据 dataList：" + dataList + "\n");

        //过滤,保留name的值不为空的数据
        dataList = dataList.stream().filter(e -> Objects.nonNull(e.get("name"))).collect(Collectors.toList());
        System.out.printf("原过滤数据 dataList：" + dataList + "\n");


        //dataList深度拷贝:必须先赋值给一个新集合，防止下面的stream处理中，影响（改变）原数据dataList
        List<Map<String, Object>> oldDataList = (List<Map<String, Object>>)deepCopy(dataList);
        System.out.printf("原数据 oldDataList：" + oldDataList + "\n");

        //根据姓名name分组计算afterSaleProfit，sore的和，并按照name的名称加（小计）来显示每组的和
        dataList = dataList.stream().collect(Collectors.groupingBy(d -> d.get("name"))).values().stream().map(d -> {
            Map<String, Object> sampleData = d.get(0);
            sampleData.put("name", d.get(0).get("name") + "(小计)");
            sampleData.put("afterSaleProfit", d.stream().map(s -> new BigDecimal(s.get("afterSaleProfit").toString())).reduce(BigDecimal.ZERO, BigDecimal::add));
            sampleData.put("sore", d.stream().map(s -> new BigDecimal(s.get("sore").toString())).reduce(BigDecimal.ZERO, BigDecimal::add));
            return sampleData;
        }).collect(Collectors.toList());
        System.out.printf("分组合计 dataList：" + dataList + "\n");
        System.out.printf("原数据 oldDataList：" + oldDataList + "\n");

        //合并集每组数据的小计集合dataListByName到集合dataList中
        dataList.addAll(oldDataList);
        System.out.printf("合并 dataList：" + dataList + "\n");

        //根据姓名name排序
        dataList.sort(Comparator.comparing(e -> String.valueOf(e.get("name"))));
        System.out.printf("排序 dataList：" + dataList + "\n");
    }

	//对象的深拷贝方法
    public static Object deepCopy(Object src) throws IOException, ClassNotFoundException {
        ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
        ObjectOutputStream out = new ObjectOutputStream(byteOut);
        out.writeObject(src);
        ByteArrayInputStream byteIn = new ByteArrayInputStream(byteOut.toByteArray());
        ObjectInputStream in = new ObjectInputStream(byteIn);
        @SuppressWarnings("unchecked")
        Object dest =  in.readObject();
        return dest;
    }

结果如下：

原数据 dataList：[{name=张三, afterSaleProfit=1.3, sore=1.3}, {name=李四, afterSaleProfit=2, sore=2}, {name=李四, afterSaleProfit=1.2, sore=1.2}, {name=null, afterSaleProfit=0, sore=1.2}]
原过滤数据 dataList：[{name=张三, afterSaleProfit=1.3, sore=1.3}, {name=李四, afterSaleProfit=2, sore=2}, {name=李四, afterSaleProfit=1.2, sore=1.2}]
原过滤数据 dataList：[{name=张三, afterSaleProfit=1.3, sore=1.3}, {name=李四, afterSaleProfit=2, sore=2}, {name=李四, afterSaleProfit=1.2, sore=1.2}]
原数据 oldDataList：[{name=张三, afterSaleProfit=1.3, sore=1.3}, {name=李四, afterSaleProfit=2, sore=2}, {name=李四, afterSaleProfit=1.2, sore=1.2}]
分组合计 dataList：[{name=李四(小计), afterSaleProfit=3.2, sore=3.2}, {name=张三(小计), afterSaleProfit=1.3, sore=1.3}]
原数据 oldDataList：[{name=张三, afterSaleProfit=1.3, sore=1.3}, {name=李四, afterSaleProfit=2, sore=2}, {name=李四, afterSaleProfit=1.2, sore=1.2}]
合并 dataList：[{name=李四(小计), afterSaleProfit=3.2, sore=3.2}, {name=张三(小计), afterSaleProfit=1.3, sore=1.3}, {name=张三, afterSaleProfit=1.3, sore=1.3}, {name=李四, afterSaleProfit=2, sore=2}, {name=李四, afterSaleProfit=1.2, sore=1.2}]
排序 dataList：[{name=张三, afterSaleProfit=1.3, sore=1.3}, {name=张三(小计), afterSaleProfit=1.3, sore=1.3}, {name=李四, afterSaleProfit=2, sore=2}, {name=李四, afterSaleProfit=1.2, sore=1.2}, {name=李四(小计), afterSaleProfit=3.2, sore=3.2}]

6.根据list的某个属性值分组。List<Map<String, Object>> 转换为Map<Integer, List<Map<String, Object>>> typeIdGroupMap

public static void main(String[] args) {
        List<Map<String, Object>> list = new ArrayList<>();
        Map<String,Object> map1 = new HashMap<>();
        Map<String,Object> map2 = new HashMap<>();
        Map<String,Object> map3 = new HashMap<>();
        map1.put("id",1);
        map1.put("typeId",353);
        map1.put("name","杨康");
        map2.put("id",2);
        map2.put("name","杨过");
        map2.put("typeId",353);
        map3.put("id",3);
        map3.put("name","杨中");
        map3.put("typeId",351);
        list.add(map1);
        list.add(map2);
        list.add(map3);
        Map<Integer, List<Map<String, Object>>> typeIdGroupMap = list
                .stream()
                .collect(Collectors.groupingBy(e  -> MapUtils.getInteger(e,"typeId")));
        Integer a = 1;
    }

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

7.获取list中第一条数据。 List<Map<String, Object>> 转Map<String,Object>

public static void main(String[] args) {
        List<Map<String, Object>> list = new ArrayList<>();
        Map<String,Object> map1 = new HashMap<>();
        Map<String,Object> map2 = new HashMap<>();
        Map<String,Object> map3 = new HashMap<>();
        map1.put("id",1);
        map1.put("typeId",353);
        map1.put("name","杨康");
        map2.put("id",2);
        map2.put("name","杨过");
        map2.put("typeId",353);
        map3.put("id",3);
        map3.put("name","杨中");
        map3.put("typeId",351);
        list.add(map1);
        list.add(map2);
        list.add(map3);
        Map<String,Object> typeIdOneMap = list.stream().filter(e -> Objects.equals(MapUtils.getInteger(e,"typeId"),351)).findFirst().get();
        Integer a = 1;
    }

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

8.获取list中某个属性的所有值。 List<Map<String, Object>>转 List

public static void main(String[] args) {
        List<Map<String, Object>> list = new ArrayList<>();
        Map<String,Object> map1 = new HashMap<>();
        Map<String,Object> map2 = new HashMap<>();
        Map<String,Object> map3 = new HashMap<>();
        map1.put("id",1);
        map1.put("typeId",353);
        map1.put("name","杨康");
        map2.put("id",2);
        map2.put("name","杨过");
        map2.put("typeId",353);
        map3.put("id",3);
        map3.put("name","杨中");
        map3.put("typeId",351);
        list.add(map1);
        list.add(map2);
        list.add(map3);
        List<String> nameList = list
                .stream().map(map -> MapUtils.getString(map, "name")).collect(Collectors.toList());
        Integer a = 1;
    }

在这里插入图片描述
在这里插入图片描述
9.根据list中的某个属性值整理成Map集合。List 转 Map<Integer,UserDTO>

public static void main(String[] args) {
        List<UserDTO> userAuthorizeList = new ArrayList<>();
        UserDTO userDTO = new UserDTO();
        userDTO.setId(1);
        userDTO.setRoleId(2);
        userDTO.setUserName("小风");
        userDTO.setPhoneNum("2233");
        UserDTO userDTO1 = new UserDTO();
        userDTO1.setId(2);
        userDTO1.setRoleId(3);
        userDTO1.setUserName("小云");
        userDTO1.setPhoneNum("2233");
        UserDTO userDTO2 = new UserDTO();
        userDTO2.setId(3);
        userDTO2.setRoleId(2);
        userDTO2.setUserName("小阳");
        userDTO2.setPhoneNum("2233");
        userAuthorizeList.add(userDTO);
        userAuthorizeList.add(userDTO1);
        userAuthorizeList.add(userDTO2);
        Map<Integer,UserDTO> userAuthorizeMap =
                userAuthorizeList
                .stream()
                .collect(Collectors.toMap(UserDTO::getRoleId, UserDTO -> UserDTO));
        Integer a = null;
    }

在这里插入图片描述
10.以list中的某个属性为属性，list中另一个属性为值，组合成 Map<Integer, List>。 List<Map<String, Object>>转 Map<Integer, List>

    public static void main(String[] args) {
        List<Map<String, Object>> list = new ArrayList<>();
        Map<String,Object> map1 = new HashMap<>();
        Map<String,Object> map2 = new HashMap<>();
        Map<String,Object> map3 = new HashMap<>();
        map1.put("id",1);
        map1.put("typeId",353);
        map1.put("name","杨康");
        map2.put("id",2);
        map2.put("name","杨过");
        map2.put("typeId",353);
        map3.put("id",3);
        map3.put("name","杨中");
        map3.put("typeId",351);
        list.add(map1);
        list.add(map2);
        list.add(map3);
        Map<Integer, List<Integer>> idAndTypeIdList =
                list
                .stream()
                .collect(
                        Collectors.groupingBy(
                                e -> MapUtils.getInteger(e,"id"),
                                Collectors.mapping(e -> MapUtils.getInteger(e,"typeId"),Collectors.toList())
                        )
                );
        Integer a = 1;
    }

在这里插入图片描述
在这里插入图片描述
11. 把List<Map<String,Object>> 中某个属性值合并成字符串：

public static void main(String[] args) {
        List<Map<String,Object>> mapList = new ArrayList<>();
        Map<String,Object> map1 = new HashMap<>();
        map1.put("key","现金");
        map1.put("money",23);
        mapList.add(map1);
        Map<String,Object> map2 = new HashMap<>();
        map2.put("key","微信");
        map2.put("money",64);
        mapList.add(map2);
        String mergedString = mapList
        	.stream()
        	.map(
                item -> "" +item.get("key")).collect(Collectors.joining(": ")
             );
        System.out.println(mergedString);

    }

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

12.List<Map<String, Object>>按照list的某个字段分组形成List

import com.smart.agriculture.util.MapperUtils;

@Autowired
private MapperUtils mapperUtils;

@GetMapping("/get_data")
    public void data() {
        List<Map<String, Object>> list = new ArrayList<>();
        Map<String, Object> map1 = new HashMap<>();
        map1.put("id",1);
        map1.put("amount",23);
        map1.put("type","苹果");
        Map<String, Object> map2 = new HashMap<>();
        map2.put("id",2);
        map2.put("amount",54);
        map2.put("type","雪梨");
        Map<String, Object> map3 = new HashMap<>();
        map3.put("id",3);
        map3.put("amount",66);
        map3.put("type","苹果");
        list.add(map1);
        list.add(map2);
        list.add(map3);
        NavigableMap<String,List<FruitVO>> listNavigableMap = list.stream()
                .map(e -> mapperUtils.convertValue(e,FruitVO.class))
                .collect(Collectors.groupingBy(FruitVO::getType,TreeMap::new,Collectors.toList()))
                .descendingMap();
        int size = listNavigableMap.size();
        List<FruitRespVO> rows = new ArrayList<>(size);
        for (Map.Entry<String,List<FruitVO>> entry : listNavigableMap.entrySet()) {
            FruitRespVO fruitRespVO = new FruitRespVO();
            fruitRespVO.setType(entry.getKey());
            fruitRespVO.setFruitVOList(entry.getValue());
            rows.add(fruitRespVO);
        }
    }

FruitRespVO.java:

package com.smart.agriculture.tally.api.vo;

import java.util.List;

public class FruitRespVO {

    private String type;

    private List<FruitVO> fruitVOList;

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public List<FruitVO> getFruitVOList() {
        return fruitVOList;
    }

    public void setFruitVOList(List<FruitVO> fruitVOList) {
        this.fruitVOList = fruitVOList;
    }
}

FruitVO.java

package com.smart.agriculture.tally.api.vo;

public class FruitVO {

    private Integer id;

    private Double amount;

    private String type;

    public Integer getId() {
        return id;
    }

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

    public Double getAmount() {
        return amount;
    }

    public void setAmount(Double amount) {
        this.amount = amount;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }
}

在这里插入图片描述
在这里插入图片描述
13.根据List<Map<String, Object>>集合中的某个BigDecimal属性求和：

    public static void main(String[] args) {
        List<Map<String, Object>> list = new ArrayList<>();
        Map<String, Object> map1 = new HashMap<>();
        map1.put("id",1);
        map1.put("amount",BigDecimal.valueOf(23));
        map1.put("type","苹果");
        Map<String, Object> map2 = new HashMap<>();
        map2.put("id",2);
        map2.put("amount",BigDecimal.valueOf(54));
        map2.put("type","雪梨");
        Map<String, Object> map3 = new HashMap<>();
        map3.put("id",3);
        map3.put("amount",null);
        map3.put("type","苹果");
        list.add(map1);
        list.add(map2);
        list.add(map3);
        BigDecimal amount = list.stream()
                .map(e ->
                        (BigDecimal)MapUtils.getNumber(e, "amount",BigDecimal.ZERO)
                ).reduce(BigDecimal.ZERO,BigDecimal::add);
    }

在这里插入图片描述

在这里插入图片描述

编程小飞侠
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java 8 新特性Stream流+lambda
hanbin1998的博客
08-03 717
一、什么是Stream Stream（流）是一个来自数据源的元素队列并支持聚合操作 元素是特定类型的对象，形成一个队列。 Java中的Stream并不会存储元素，而是按需计算。 数据源流的来源。 可以是集合，数组，I/O channel， 产生器generator 等。 聚合操作类似SQL语句一样的操作， 比如filter, map, reduce, find, match, sorted等。 Stream流中几种经常使用的API： 1.1Filter public class TestL..
Stream.findAny
06-21 7133
Optional<T>findAny() 其作用就是从Stream中取任意一个元素，正常情况下一般会取第一个元素，在并行流的情况下会随机取一个元素。 下面看一个例子： void stream_findAny() { List<String> list = Arrays.asList("a","b","c","d","e","f","g"); Optional<String> opt = list.stream().findAn...
Java-Stream流-概述、创建、使用：遍历/匹配、筛选、聚合、映射、归约、排序、提取/组合
最新发布
小孔靠得住的博客
05-28 1077
​ Java 8中的Stream流是一种全新的数据处理抽象，它革命性地改变了开发者处理集合数据的方式。Stream API并不是一个真正持有数据的集合，而是一种数据渠道，用于处理具有集合、数组等数据结构支持的数据序列。Stream的核心思想借鉴了函数式编程语言的处理数据方式，强调声明式编程风格，使得开发者能够以更高效、更简洁的方式表达数据处理逻辑。
lambda常见使用
我就是我的博客
11-06 806
Lambda 基本语法 流只能遍历一次 我们可以把流想象成一条流水线，流水线的源头是我们的数据源(一个集合)，数据源中的元素依次被输送到流水线上，我们可以在流水线上对元素进行各种操作。一旦元素走到了流水线的另一头，那么这些元素就被“消费掉了”，我们无法再对这个流进行操作。当然，我们可以从数据源那里再获得一个新的流重新遍历一遍。 stream是采用内部迭代方式 若要对集合进行处理，则需...
Java8 lambda表达式
jeikerxiao
04-28 442
1. 实现Runnable线程案例 可以使用下面语法实现Lambda: 1. (params) -&gt; expression 2. (params) -&gt; statement 3. (params) -&gt; { statements } 例如：方法接受两个方法参数。 (int even, int odd) -&gt; even + odd 推荐简写： (int...
lambda之Stream流式编程
yangzhe19931117的博客
12-08 627
lambda之Stream流式编程
Stream、Lambda表达式练习.doc
01-14
Stream和Lambda表达式实践 在Java中，Stream API是Java 8中引入的一种新的数据处理方式，它可以对集合进行各种操作，如过滤、映射、聚合等。Lambda表达式是Java 8中引入的一种新的函数式编程方式，它可以将函数作为...
Stream和Lambda表达式最佳实践
04-24
Stream和Lambda表达式是Java 8引入的两个重要特性，它们极大地简化了集合处理和函数式编程的复杂性。以下是关于Stream和Lambda表达式的最佳实践介绍： Lambda表达式 Lambda表达式允许我们以简洁的方式表示匿名函数...
Java8中的 Lambda表达式教程
08-31
Java 8 中的 Lambda 表达式是一种强大的编程特性，它...通过这些特性，Java 8的Lambda表达式让代码更加简洁、易读，特别是在处理高阶函数和函数式编程场景时。理解和熟练使用Lambda表达式是提升Java 8开发效率的关键。
详解Java8中的Lambda表达式
08-18
Lambda表达式与Java8的新特性 --------------------------- Lambda表达式是Java8的一大亮点，与Java8的新特性Stream()一起使用可以使代码变得更加简洁紧凑。 Lambda表达式是Java8中的一个非常重要的特性，它可以使...
详解Java中的Lambda表达式
08-26
Lambda表达式还增强了集合库，添加了2个对集合数据进行批量操作的包：java.util.function包和java.util.stream包。 Lambda表达式的来源于希腊字母λ，用于声明一个数学逻辑系统，表示根据XX的输入参数，会返回某个Y...
Stream流和lambda表达式
qq_51076413的博客
07-06 619
Stream流和lambda表达式
Stream API将对象中的某一字段取出转换为list或数组
IT小辉同学
07-21 2419
尚且年轻，就多吃点苦，多出去闯一闯，我们有很多的机会与时间，加油，我们一起！
stream 提取某字段_java8从list集合中取出某一属性的值的集合案例
热门推荐
易的博客
04-06 5万+
List orderNoList=list.stream().map(Order::getOrderNo).collect(Collectors.toList()); https://blog.csdn.net/weixin_39702400/article/details/111895006 我就废话不多说了，大家还是直接看代码吧~ List list = new ArrayList(); Order o1 = new Order("1","MCS-2019-1...
lambda表达式——Stream管道流的map操作
weixin_40277684的博客
05-14 5610
lambda表达式——Stream管道流的map操作一、回顾Stream管道流map的基础用法二、处理非字符串类型集合元素三、再复杂一点：处理对象数据格式转换四、flatMap 一、回顾Stream管道流map的基础用法 最简单的需求：将集合中的每一个字符串，全部转换成大写！ List<String> alpha = Arrays.asList("Monkey", "Lion", "Giraffe", "Lemur"); //不使用Stream管道流 List<String> al
Java Stream分组groupBy后，取某个字段值为字符串或者list
来一杯可乐
02-13 3397
某个字段值为字符串 List<User> userList = new ArrayList(); Map<String,String> collect = userList.stream().collect(Collectors.groupingBy( User::getRealname, Collectors.mapping(User...
二. Java8特性详解之Stream语法
xgb2018的博客
10-27 452
二. Java8特性详解之Stream语法前言1、Stream是什么？2、Stream语法剖析2.1、创建Stream2.2、转换Stream2.3、汇聚（Reduce）Stream 前言 本文主要介绍Java8另一个特性—Stream语法。 1、Stream是什么？ 官方解释 A sequence of elements supporting sequential and parallel aggregate operations. //Stream是元素的集合，这点让Stream看起来用些类似Iter
Stream流的基本运用&&集合和数组获取Stream流的方式
遇安的博客
04-02 1131
import java.util.*; //stream流基本概念 public class stream_1 { public static void main(String[] args) { Collection<String> c1=new ArrayList<>(); Collections.addAll(c1,"张三丰","张无忌","张某","周芷若"); System.out.println(c1); .
java lambda map用法_java – 如何调试stream() map(…)与lambda表达式？
weixin_42550597的博客
02-27 1207
在我们的项目中，我们正在迁移到java 8，我们正在测试它的新功能。在我的项目中，我使用Guava谓词和函数来使用Collections2.transform和Collections2.filter过滤和转换一些集合。在这个迁移我需要改变例如番石榴代码java 8更改。所以，我做的改变是那种：List naturals = Lists.newArrayList(1,2,3,4,5,6,7,8,9,...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值