Stream流的常用方法大全

已于 2023-08-22 15:22:02 修改
阅读量7.3k 收藏 117
点赞数 26
分类专栏： 技术栈 文章标签： java 算法
于 2022-07-18 13:34:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35160479/article/details/125844291
版权

目录

一、遍历

1.属性遍历

2.对象遍历

3.遍历设值

二、过滤

1.简单过滤

2.多条件过滤 

三、去重

四、统计

五、截取

六、跳过

七、排序

1.普通排序

2.指定排序

八、最值

1.集合确定不为空

2.集合可能为空

九、统计

十、List结构转换Map结构

1.map值是对象

2.map值是字段

十一、判断

1.anyMatch(只要有一个匹配则返回true)​编辑

2.allMatch(需要全部匹配条件则返回true)

3.noneMatch(需要全部不匹配条件则返回true)

十二、转换

1.对象转成字段

2.对象转成对象

3.对象转成字符串

十三、分组

1.list结构分组成map结构（值是对象）

2.list结构分组成map结构（值是集合）

3.list结构分组成map结构（值是字段）

4.list结构分组成map结构（多条件分组）

5.list结构分组成二级list结构

一、遍历

1.属性遍历

package com.saas.demo;


import java.util.ArrayList;
import java.util.List;

/**
 * Stream流遍历
 */
public class StreamDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("小明");
        list.add("小红");
        list.add("小兰");
        list.stream().forEach(s -> System.out.println("value:"+s));
    }
}

2.对象遍历

package com.saas.demo;

import lombok.AllArgsConstructor;
import lombok.Data;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;

/**
 * Stream流遍历
 */
public class StreamDemo {
    public static void main(String[] args) {
        List<People> peopleList = new ArrayList<People>();
        peopleList.add(new People("小明",23,new BigDecimal("3000")));
        peopleList.add(new People("小红",24,new BigDecimal("2800")));
        peopleList.add(new People("小兰",22,new BigDecimal("3200")));
        //遍历对象
        peopleList.stream().forEach(s -> System.out.println("value:"+s));
        System.out.println("------------------------------------------------");
        //遍历属性
        peopleList.stream().forEach(s -> System.out.println("value:"+s.getName()));
    }
}

@Data
@AllArgsConstructor
class People {
    //姓名
    private String name;
    //年龄
    private Integer age;
    //工资
    private BigDecimal salary;
}

3.遍历设值

package com.saas.demo;

import lombok.AllArgsConstructor;
import lombok.Data;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;

/**
 * Stream设值
 */
public class StreamDemo {
    public static void main(String[] args) {
        List<People> peopleList = new ArrayList<People>();
        peopleList.add(new People("小明",23,new BigDecimal("3000")));
        peopleList.add(new People("小红",24,new BigDecimal("2800")));
        peopleList.add(new People("小兰",22,new BigDecimal("3200")));
        //遍历对象
        peopleList.stream().forEach(s -> System.out.println("value:"+s));
        System.out.println("------------------------------------------------");
        //统一更改年龄成25
        peopleList.stream().forEach(s -> s.setAge(25));
        //判断如果姓名叫小明的,则工资加100
        peopleList.stream().forEach(s ->{
            if("小明".equals(s.getName())){
                s.setSalary(s.getSalary().add(new BigDecimal("100")));
            }
        });
        //遍历对象
        peopleList.stream().forEach(s -> System.out.println("value:"+s));
    }
}

@Data
@AllArgsConstructor
class People {
    //姓名
    private String name;
    //年龄
    private Integer age;
    //工资
    private BigDecimal salary;
}

二、过滤

1.简单过滤

package com.saas.demo;

import lombok.AllArgsConstructor;
import lombok.Data;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

/**
 * Stream 过滤
 */
public class StreamDemo {
    public static void main(String[] args) {
        List<People> peopleList = new ArrayList<People>();
        peopleList.add(new People("小明",23,new BigDecimal("3000")));
        peopleList.add(new People("小红",24,new BigDecimal("2800")));
        peopleList.add(new People("小兰",22,new BigDecimal("3200")));
        //查找年龄大于等于23岁的人
        List<People> newPeopleList = peopleList.stream().filter(s ->s.getAge()>=23).collect(Collectors.toList());
        System.out.println("value:"+newPeopleList);

    }
}

@Data
@AllArgsConstructor
class People {
    //姓名
    private String name;
    //年龄
    private Integer age;
    //工资
    private BigDecimal salary;
}

2.多条件过滤 

package com.saas.demo;

import lombok.AllArgsConstructor;
import lombok.Data;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

/**
 * Stream 多条件过滤
 */
public class StreamDemo {
    public static void main(String[] args) {
        List<People> peopleList = new ArrayList<People>();
        peopleList.add(new People("小明",23,new BigDecimal("3000")));
        peopleList.add(new People("小红",24,new BigDecimal("2800")));
        peopleList.add(new People("小兰",22,new BigDecimal("3200")));
        //查找工资低于3000,年龄大于23岁的人
        List<People> newPeopleList1 = peopleList.stream().filter(s ->
                s.getSalary().compareTo(new BigDecimal("3000"))<0 && s.getAge()>23
        ).collect(Collectors.toList());
        System.out.println("value:"+newPeopleList1);
        //查找年龄大于等于23岁并且工资不低于3000的人
        List<People> newPeopleList2 = peopleList.stream().filter(s ->{
            if(s.getAge()>=23 && s.getSalary().compareTo(new BigDecimal("3000"))>=0){
                return true;
            }
            return false;
        }).collect(Collectors.toList());
        System.out.println("value:"+newPeopleList2);
    }
}

@Data
@AllArgsConstructor
class People {
    //姓名
    private String name;
    //年龄
    private Integer age;
    //工资
    private BigDecimal salary;
}

三、去重

package com.saas.demo;

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

/**
 * Stream 去重
 */
public class StreamDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("小明");
        list.add("小红");
        list.add("小兰");
        list.add("小红");
        list = list.stream().distinct().collect(Collectors.toList());
        System.out.println("value:"+list);
    }
}

四、统计

package com.saas.demo;

import java.util.ArrayList;
import java.util.List;

/**
 * Stream 统计
 */
public class StreamDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("小明");
        list.add("小红");
        list.add("小兰");
        long count = list.stream().count();
        System.out.println("count:"+count);
    }
}

五、截取

package com.saas.demo;

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

/**
 * Stream 截取
 */
public class StreamDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("小明");
        list.add("小红");
        list.add("小兰");
        list = list.stream().limit(2).collect(Collectors.toList());
        System.out.println("value:"+list);
    }
}

六、跳过

 

package com.saas.demo;

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

/**
 * Stream 跳过
 */
public class StreamDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("小明");
        list.add("小红");
        list.add("小兰");
        //跳过前面两个
        list = list.stream().skip(2).collect(Collectors.toList());
        System.out.println("value:"+list);
    }
}

七、排序

1.普通排序

package com.saas.demo;

import lombok.AllArgsConstructor;
import lombok.Data;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;

/**
 * Stream 排序
 */
public class StreamDemo {
    public static void main(String[] args) {
        List<People> peopleList = new ArrayList<People>();
        peopleList.add(new People("小明",23,new BigDecimal("3000")));
        peopleList.add(new People("小红",24,new BigDecimal("2800")));
        peopleList.add(new People("小兰",22,new BigDecimal("3200")));
        //根据年龄从小到大排序
        peopleList =peopleList.stream()
                .sorted(Comparator.comparing(People::getAge))
                .collect(Collectors.toList());
        System.out.println("value:"+peopleList);
        System.out.println("------------------------------------------------");
        //根据年龄从大到小排序
        peopleList =peopleList.stream()
                .sorted(Comparator.comparing(People::getAge).reversed())
                .collect(Collectors.toList());
        System.out.println("value:"+peopleList);

    }
}

@Data
@AllArgsConstructor
class People {
    //姓名
    private String name;
    //年龄
    private Integer age;
    //工资
    private BigDecimal salary;
}

2.指定排序

package com.saas.demo;

import lombok.AllArgsConstructor;
import lombok.Data;
import java.math.BigDecimal;
import java.util.*;
import java.util.stream.Collectors;

/**
 * Stream 排序
 */
public class StreamDemo {
    public static void main(String[] args) {
        List<People> peopleList = new ArrayList<People>();
        peopleList.add(new People("小明",23,new BigDecimal("3000")));
        peopleList.add(new People("小红",24,new BigDecimal("2800")));
        peopleList.add(new People("小兰",22,new BigDecimal("3200")));
        System.out.println("value:"+peopleList);
        System.out.println("------------------------------------------------");
        //根据名称指定排序
        List<String> nameList = Arrays.asList("小红","小明","小兰");
        peopleList = peopleList.stream().sorted(Comparator.comparing(People::getName,(x,y)->{
            for (String name : nameList) {
                if (name.equals(x) || name.equals(y)){
                    if (x.equals(y)){
                        return 0;
                    }else if (name.equals(x)){
                        return -1;
                    }else {
                        return 1;
                    }
                }
            }
            return 0;
        })).collect(Collectors.toList());
        System.out.println("value:"+peopleList);
        //根据年龄指定排序
        List<Integer> ageList = Arrays.asList(24,22,23);
        Collections.sort(peopleList, new Comparator<People>() {
            public int compare(People p1, People p2) {
                int x = ageList.indexOf(p1.getAge());
                int y = ageList.indexOf(p2.getAge());
                return x - y;
            }
        });
        System.out.println("value:"+peopleList);

    }
}

@Data
@AllArgsConstructor
class People {
    //姓名
    private String name;
    //年龄
    private Integer age;
    //工资
    private BigDecimal salary;
}

八、最值

1.集合确定不为空

package com.saas.demo;

import lombok.AllArgsConstructor;
import lombok.Data;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

/**
 * Stream 获取最大值和最小值
 */
public class StreamDemo {
    public static void main(String[] args) {
        List<People> peopleList = new ArrayList<People>();
        peopleList.add(new People("小明",23,new BigDecimal("3000")));
        peopleList.add(new People("小红",24,new BigDecimal("2800")));
        peopleList.add(new People("小兰",22,new BigDecimal("3200")));
        //获取年龄最大的人
        People maxPeople =peopleList.stream().max(Comparator.comparing(People::getAge)).get();
        System.out.println("value:"+maxPeople);
        System.out.println("------------------------------------------------");
        //获取年龄最小的人
        People minPeople =peopleList.stream().min(Comparator.comparing(People::getAge)).get();
        System.out.println("value:"+minPeople);


    }
}

@Data
@AllArgsConstructor
class People {
    //姓名
    private String name;
    //年龄
    private Integer age;
    //工资
    private BigDecimal salary;
}

2.集合可能为空

package com.saas.demo;

import lombok.AllArgsConstructor;
import lombok.Data;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Optional;

/**
 * Stream 获取最大值和最小值
 */
public class StreamDemo {
    public static void main(String[] args) {
        List<People> peopleList = new ArrayList<People>();
        peopleList.add(new People("小明",23,new BigDecimal("3000")));
        peopleList.add(new People("小红",24,new BigDecimal("2800")));
        peopleList.add(new People("小兰",22,new BigDecimal("3200")));
        //获取年龄最大的人
        Optional max =peopleList.stream().max(Comparator.comparing(People::getAge));
        if(max.isPresent()){
            System.out.println("value:"+max.get());
        }
        System.out.println("------------------------------------------------");
        //获取年龄最小的人
        Optional min =peopleList.stream().min(Comparator.comparing(People::getAge));
        if(min.isPresent()) {
            System.out.println("value:" + min.get());
        }
    }
}

@Data
@AllArgsConstructor
class People {
    //姓名
    private String name;
    //年龄
    private Integer age;
    //工资
    private BigDecimal salary;
}

九、统计

package com.saas.demo;

import lombok.AllArgsConstructor;
import lombok.Data;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Optional;

/**
 * Stream 统计
 */
public class StreamDemo {
    public static void main(String[] args) {
        List<People> peopleList = new ArrayList<People>();
        peopleList.add(new People("小明",23,new BigDecimal("3000"),new BigDecimal("1.1")));
        peopleList.add(new People("小红",24,new BigDecimal("2800"),new BigDecimal("1.2")));
        peopleList.add(new People("小兰",22,new BigDecimal("3200"),new BigDecimal("1.3")));
        //统计年龄总和
        int totalAge =peopleList.stream().mapToInt(People::getAge).sum();
        System.out.println("value:"+totalAge);
        System.out.println("------------------------------------------------");
        //统计工资总和
        BigDecimal totalSalary = peopleList.stream()
                .map(People::getSalary)
                .reduce(BigDecimal.ZERO,BigDecimal::add);
        System.out.println("value:"+totalSalary);
        //统计工资乘以各自系数的总和(向上保留两位)
        BigDecimal totalRatioSalary = peopleList.stream()
                .map(s->s.getSalary().multiply(s.getRatio()).setScale(2,BigDecimal.ROUND_HALF_UP))
                .reduce(BigDecimal.ZERO,BigDecimal::add);
        System.out.println("value:"+totalRatioSalary);
    }
}

@Data
@AllArgsConstructor
class People {
    //姓名
    private String name;
    //年龄
    private Integer age;
    //工资
    private BigDecimal salary;
    //比率
    private BigDecimal ratio;
}

十、List结构转换Map结构

1.map值是对象

package com.saas.demo;

import lombok.AllArgsConstructor;
import lombok.Data;
import java.math.BigDecimal;
import java.util.*;
import java.util.stream.Collectors;

/**
 * Stream list转map
 */
public class StreamDemo {
    public static void main(String[] args) {
        List<People> peopleList = new ArrayList<People>();
        peopleList.add(new People("小明",23,new BigDecimal("3000"),new BigDecimal("1.1")));
        peopleList.add(new People("小红",24,new BigDecimal("2800"),new BigDecimal("1.2")));
        peopleList.add(new People("小兰",22,new BigDecimal("3200"),new BigDecimal("1.3")));
        //根据姓名转map
        Map<String, People> map= peopleList.stream()
                .collect(Collectors.toMap(s-> s.getName(), object -> object,(oldValue, newValue) -> newValue));
        System.out.println("value:"+map);
    }
}

@Data
@AllArgsConstructor
class People {
    //姓名
    private String name;
    //年龄
    private Integer age;
    //工资
    private BigDecimal salary;
    //比率
    private BigDecimal ratio;
}

2.map值是字段

package com.saas.demo;

import lombok.AllArgsConstructor;
import lombok.Data;
import java.math.BigDecimal;
import java.util.*;
import java.util.stream.Collectors;

/**
 * Stream list转map
 */
public class StreamDemo {
    public static void main(String[] args) {
        List<People> peopleList = new ArrayList<People>();
        peopleList.add(new People("小明",23,new BigDecimal("3000"),new BigDecimal("1.1")));
        peopleList.add(new People("小红",24,new BigDecimal("2800"),new BigDecimal("1.2")));
        peopleList.add(new People("小兰",22,new BigDecimal("3200"),new BigDecimal("1.3")));
        //根据姓名转map
        Map<String, Integer> map = peopleList.stream().collect(Collectors.toMap(People::getName
                , People::getAge));
        System.out.println("value:"+map);
    }
}

@Data
@AllArgsConstructor
class People {
    //姓名
    private String name;
    //年龄
    private Integer age;
    //工资
    private BigDecimal salary;
    //比率
    private BigDecimal ratio;
}

十一、判断

1.anyMatch(只要有一个匹配则返回true)

package com.saas.demo;

import lombok.AllArgsConstructor;
import lombok.Data;
import java.math.BigDecimal;
import java.util.*;
import java.util.stream.Collectors;

/**
 * Stream 判断
 */
public class StreamDemo {
    public static void main(String[] args) {
        List<People> peopleList = new ArrayList<People>();
        peopleList.add(new People("小明",23,new BigDecimal("3000"),new BigDecimal("1.1")));
        peopleList.add(new People("小红",24,new BigDecimal("2800"),new BigDecimal("1.2")));
        peopleList.add(new People("小兰",22,new BigDecimal("3200"),new BigDecimal("1.3")));
        //判断集合里面是否超过23岁的人
        boolean flag= peopleList.stream().anyMatch(s -> s.getAge() > 23);
        System.out.println("value:"+flag);
    }
}

@Data
@AllArgsConstructor
class People {
    //姓名
    private String name;
    //年龄
    private Integer age;
    //工资
    private BigDecimal salary;
    //比率
    private BigDecimal ratio;
}

2.allMatch(需要全部匹配条件则返回true)

package com.saas.demo;

import lombok.AllArgsConstructor;
import lombok.Data;
import java.math.BigDecimal;
import java.util.*;
import java.util.stream.Collectors;

/**
 * Stream 判断
 */
public class StreamDemo {
    public static void main(String[] args) {
        List<People> peopleList = new ArrayList<People>();
        peopleList.add(new People("小明",23,new BigDecimal("3000"),new BigDecimal("1.1")));
        peopleList.add(new People("小红",24,new BigDecimal("2800"),new BigDecimal("1.2")));
        peopleList.add(new People("小兰",22,new BigDecimal("3200"),new BigDecimal("1.3")));
        //判断集合里面的人是否全部超过23岁
        boolean flag= peopleList.stream().allMatch(s -> s.getAge() > 23);
        System.out.println("value:"+flag);
    }
}

@Data
@AllArgsConstructor
class People {
    //姓名
    private String name;
    //年龄
    private Integer age;
    //工资
    private BigDecimal salary;
    //比率
    private BigDecimal ratio;
}

3.noneMatch(需要全部不匹配条件则返回true)

 

package com.saas.demo;

import lombok.AllArgsConstructor;
import lombok.Data;
import java.math.BigDecimal;
import java.util.*;
import java.util.stream.Collectors;

/**
 * Stream 判断
 */
public class StreamDemo {
    public static void main(String[] args) {
        List<People> peopleList = new ArrayList<People>();
        peopleList.add(new People("小明",23,new BigDecimal("3000"),new BigDecimal("1.1")));
        peopleList.add(new People("小红",24,new BigDecimal("2800"),new BigDecimal("1.2")));
        peopleList.add(new People("小兰",22,new BigDecimal("3200"),new BigDecimal("1.3")));
        //判断集合里面的人是否全部不超过23岁
        boolean flag= peopleList.stream().noneMatch(s -> s.getAge() > 23);
        System.out.println("value:"+flag);
    }
}

@Data
@AllArgsConstructor
class People {
    //姓名
    private String name;
    //年龄
    private Integer age;
    //工资
    private BigDecimal salary;
    //比率
    private BigDecimal ratio;
}

十二、转换

1.对象转成字段

package com.saas.demo;

import lombok.AllArgsConstructor;
import lombok.Data;
import java.math.BigDecimal;
import java.util.*;
import java.util.stream.Collectors;

/**
 * Stream 转换
 */
public class StreamDemo {
    public static void main(String[] args) {
        List<People> peopleList = new ArrayList<People>();
        peopleList.add(new People("小明",23,new BigDecimal("3000"),new BigDecimal("1.1")));
        peopleList.add(new People("小红",24,new BigDecimal("2800"),new BigDecimal("1.2")));
        peopleList.add(new People("小兰",22,new BigDecimal("3200"),new BigDecimal("1.3")));
        //获取姓名集合
        List<String> nameList = peopleList.stream().map(s-> s.getName()).collect(Collectors.toList());
        System.out.println("value:"+nameList);
    }
}

@Data
@AllArgsConstructor
class People {
    //姓名
    private String name;
    //年龄
    private Integer age;
    //工资
    private BigDecimal salary;
    //比率
    private BigDecimal ratio;
}

2.对象转成对象

package com.saas.demo;

import lombok.AllArgsConstructor;
import lombok.Data;
import java.math.BigDecimal;
import java.util.*;
import java.util.stream.Collectors;

/**
 * Stream 转换
 */
public class StreamDemo {
    public static void main(String[] args) {
        List<People> peopleList = new ArrayList<People>();
        peopleList.add(new People("小明",23,new BigDecimal("3000"),new BigDecimal("1.1")));
        peopleList.add(new People("小红",24,new BigDecimal("2800"),new BigDecimal("1.2")));
        peopleList.add(new People("小兰",22,new BigDecimal("3200"),new BigDecimal("1.3")));
        //对象转对象
        List<Student> studentList = peopleList.stream().map(s->{
            return new Student(s.getName(),s.getAge());
        }).collect(Collectors.toList());
        System.out.println("value:"+studentList);
    }
}

@Data
@AllArgsConstructor
class People {
    //姓名
    private String name;
    //年龄
    private Integer age;
    //工资
    private BigDecimal salary;
    //比率
    private BigDecimal ratio;
}

@Data
@AllArgsConstructor
class Student {
    //姓名
    private String name;
    //年龄
    private Integer age;
}

3.对象转成字符串

package com.saas.demo;

import lombok.AllArgsConstructor;
import lombok.Data;
import java.math.BigDecimal;
import java.util.*;
import java.util.stream.Collectors;

/**
 * Stream 转换
 */
public class StreamDemo {
    public static void main(String[] args) {
        List<People> peopleList = new ArrayList<People>();
        peopleList.add(new People("小明",23,new BigDecimal("3000"),new BigDecimal("1.1")));
        peopleList.add(new People("小红",24,new BigDecimal("2800"),new BigDecimal("1.2")));
        peopleList.add(new People("小兰",22,new BigDecimal("3200"),new BigDecimal("1.3")));
        //获取姓名字符串,逗号隔开
        String name = peopleList.stream().map(s-> s.getName()).collect(Collectors.joining(","));
        System.out.println("value:"+name);
    }
}

@Data
@AllArgsConstructor
class People {
    //姓名
    private String name;
    //年龄
    private Integer age;
    //工资
    private BigDecimal salary;
    //比率
    private BigDecimal ratio;
}

十三、分组

1.list结构分组成map结构（值是对象）

package com.saas.demo;

import lombok.AllArgsConstructor;
import lombok.Data;
import java.math.BigDecimal;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * Stream 分组
 */
public class StreamDemo {
    public static void main(String[] args) {
        List<People> peopleList = new ArrayList<People>();
        peopleList.add(new People("小明",23,new BigDecimal("3200"),new BigDecimal("1.1"),"开发"));
        peopleList.add(new People("小明",23,new BigDecimal("3100"),new BigDecimal("1.1"),"开发"));
        peopleList.add(new People("小明",23,new BigDecimal("3000"),new BigDecimal("1.1"),"开发"));
        peopleList.add(new People("小红",24,new BigDecimal("2800"),new BigDecimal("1.2"),"产品"));
        peopleList.add(new People("小兰",22,new BigDecimal("3200"),new BigDecimal("1.3"),"开发"));
        //根据名称分组(前提是名称是唯一的,要不然获取的是重复名称的最后一条)
        Map<String, People> studentMap = peopleList.stream().collect(Collectors.toMap(People::getName, Function.identity(), (key1, key2) -> key2));
        System.out.println("value:"+studentMap);
    }
}

@Data
@AllArgsConstructor
class People {
    //姓名
    private String name;
    //年龄
    private Integer age;
    //工资
    private BigDecimal salary;
    //比率
    private BigDecimal ratio;
    //职业
    private String occupation;
}

2.list结构分组成map结构（值是集合）

package com.saas.demo;

import lombok.AllArgsConstructor;
import lombok.Data;
import java.math.BigDecimal;
import java.util.*;
import java.util.stream.Collectors;

/**
 * Stream 分组
 */
public class StreamDemo {
    public static void main(String[] args) {
        List<People> peopleList = new ArrayList<People>();
        peopleList.add(new People("小明","开发"));
        peopleList.add(new People("小红","产品"));
        peopleList.add(new People("小兰","开发"));
        //根据职业分组无序
        Map<String, List<People>> studentMap = peopleList.stream().collect(Collectors.groupingBy(People::getOccupation));
        System.out.println("value:"+studentMap);
        //根据职业分组有序
        Map<String,List<People>> studentSortMap = peopleList.stream().collect(Collectors.groupingBy(People::getOccupation, LinkedHashMap::new,Collectors.toList()));
        System.out.println("value:"+studentSortMap);

    }
}

@Data
@AllArgsConstructor
class People {
    //姓名
    private String name;
    //职业
    private String occupation;
}

3.list结构分组成map结构（值是字段）

package com.saas.demo;

import lombok.AllArgsConstructor;
import lombok.Data;
import java.math.BigDecimal;
import java.util.*;
import java.util.stream.Collectors;

/**
 * Stream 分组
 */
public class StreamDemo {
    public static void main(String[] args) {
        List<People> peopleList = new ArrayList<People>();
        peopleList.add(new People(1,"小明",23,new BigDecimal("3000"),new BigDecimal("1.1"),"开发"));
        peopleList.add(new People(2,"小红",24,new BigDecimal("2800"),new BigDecimal("1.2"),"产品"));
        peopleList.add(new People(3,"小兰",22,new BigDecimal("3200"),new BigDecimal("1.3"),"开发"));
        //根据id分组
        Map<Integer, String> map = peopleList.stream().collect(Collectors.toMap(People::getId, People::getName,(oldValue, newValue) -> newValue));
        System.out.println("value:"+map);
    }
}

@Data
@AllArgsConstructor
class People {
    //主键id
    private Integer id;
    //姓名
    private String name;
    //年龄
    private Integer age;
    //工资
    private BigDecimal salary;
    //比率
    private BigDecimal ratio;
    //职业
    private String occupation;
}

4.list结构分组成map结构（多条件分组）

package com.saas.demo;

import lombok.AllArgsConstructor;
import lombok.Data;
import java.util.*;
import java.util.stream.Collectors;

/**
 * Stream 分组
 */
public class StreamDemo {
    public static void main(String[] args) {
        List<People> peopleList = new ArrayList<People>();
        peopleList.add(new People("小明",23,"开发"));
        peopleList.add(new People("小红",24,"产品"));
        peopleList.add(new People("小兰",22,"开发"));
        peopleList.add(new People("小紫",22,"开发"));
        //根据年龄和职业分组
        Map<String, List<People>> map = peopleList.stream().collect(Collectors.groupingBy(People::getAgeAndOccupation));
        System.out.println("value:"+map);
    }
}

@Data
@AllArgsConstructor
class People {
    //姓名
    private String name;
    //年龄
    private Integer age;
    //职业
    private String occupation;

    public static String getAgeAndOccupation(People people){
        return people.getAge() + "#" + people.getOccupation();
    }
}

5.list结构分组成二级list结构

package com.saas.demo;

import lombok.AllArgsConstructor;
import lombok.Data;
import java.math.BigDecimal;
import java.util.*;
import java.util.stream.Collectors;

/**
 * Stream 分组
 */
public class StreamDemo {
    public static void main(String[] args) {
        List<People> peopleList = new ArrayList<People>();
        peopleList.add(new People("小明","开发"));
        peopleList.add(new People("小红","产品"));
        peopleList.add(new People("小兰","开发"));
        //根据职业分组无序
        List<List<People>> newList = new ArrayList<>();
        peopleList.stream().collect(Collectors.groupingBy(People::getOccupation, Collectors.toList()))
                .forEach((occupation, listOccupation) -> {
                    newList.add(listOccupation);
                });
        System.out.println("value:"+newList);
        //根据职业分组有序
        List<List<People>> newSortList = new ArrayList<>();
        peopleList.stream().collect(Collectors.groupingBy(People::getOccupation, LinkedHashMap::new, Collectors.toList()))
                .forEach((occupation, listOccupation) -> {
                    newSortList.add(listOccupation);
                });
        System.out.println("value:"+newSortList);
    }
}

@Data
@AllArgsConstructor
class People {
    //姓名
    private String name;
    //职业
    private String occupation;
}

这人很懒没留下什么
关注
  • 26
    点赞
  • 踩
  • 117
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java8 Stream详解
HappyHeng的博客
10-16 2万+
Java8中提供了Stream对集合操作作出了极大的简化，学习了Stream之后，我们以后不用使用for循环就能对集合作出很好的操作。 一、流的初始化与转换：   Java中的Stream的所有操作都是针对流的，所以，使用Stream必须要得到Stream对象：   1、初始化一个流：     Stream stream = Stream.of("a", "b", "c");
Stream流常用方法
12-22
1. 获取Stream流 1. 所有的Collection集合都有对应的Stream(); 2. 可以通过Stream类中的static Stream of()获取 static Stream of(T... t); static Stream of(T t); package com.qfedu.first.streamget; ...
stream流的常用方法
weixin_44702189的博客
08-04 1万+
Stream将要处理的元素集合看作一种流，在流的过程中，借助Stream API对流中的元素进行操作，比如：筛选、排序、聚合等。Stream中间操作：·每次返回一个新的流，可以有多个。终端操作：每个流只能进行一次终端操作，终端操作结束后流无法再次使用。终端操作会产生一个新的集合或值。Streamstream不存储数据，而是按照特定的规则对数据进行计算，一般会输出结果。stream不会改变数据源，通常情况下会产生一个新的集合或一个值。......
Stream流常用操作
最新发布
码砖师傅的博客
05-19 908
Java Stream流
Stream流的常用方法
m0_57232638的博客
06-14 182
它提供了一种高效、便捷的方式来处理集合中的元素，使得数据操作更简洁、可读性更强，并且可以通过并行处理提高性能。以上的这些只是流中的一部分常用方法，流还提供了更多的操作，如flatMap、skip、min、max等。（2）函数式风格：流使用函数式编程的思想，以操作数据流为核心，避免了显式的迭代和条件判（3）断，使代码更加清晰。（1）简洁：通过使用流，可以用更少的代码实现复杂的数据操作，提高代码的可读性和简洁性。（4）惰性求值：流的操作是惰性的，只有在终端操作被调用时才会执行，这样可以提高效率。
Stream：常用方法总结
程序员无羡的博客
04-25 428
Stream：常用方法总结
java8 List的Stream流操作 (常用篇 一)
DJyzh的博客
06-08 4130
java8 List的Stream流操作 (常用篇 一) 1、Stream流 遍历(forEach) 2、Stream流 过滤(filter) 3、Stream流 排序(sortAndReversed) 4、Stream流 去重(distinct) 5、Stream流 分组(Collectors.groupingBy) 6、Stream流 toMap()获取、转化map 关键字groupingBy、distinct、count、anyMatch、noneMatch、allMatch、thenCompar
Stream流的三类方法
m0_72971266的博客
11-19 231
获取Stream流：创建一条流水线，并把数据放到流水线上准备进行操作中间方法：流水线上的操作。一次操作完毕之后，还可以继续进行其他操作。终结方法：一个Stream流只能有一个终结方法，流水线上的最后一个操作stream操作集合或者数组的第一步是先得到Stream流，然后才能使用流的功能。集合获取stream流的方式。
详解JAVA Stream流
08-18
Stream流提供了多种方法来处理数据，以下是一些常用的方法： 1. void forEach(Consumer<? super T> action)：该方法接收一个Consumer接口函数，会将每一个流元素交给该函数进行处理。此方法为终结方法，遍历后不能...
Java Stream流知识总结
08-19
Java Stream流的常用方法： 1. filter()：用于对流元素进行过滤，例如 filter(s -> s.startsWith("张"))。 2. map()：用于对流元素进行转换，例如 map(s -> s.toUpperCase())。 3. sorted()：用于对流元素进行排序...
详解java8中的Stream数据流
08-29
Stream 的常用方法 * filter：筛选元素，返回满足条件的元素流。 * distinct：筛选重复的元素，返回一个元素流。 * skip：跳过指定数量的元素，返回一个流。 * limit：限制元素数量，返回一个流。 * map：将元素...
Java8Test.java_java8_almosttog_stream流_
09-29
4. **Stream API的常用方法** - `filter(Predicate predicate)`: 根据给定的条件过滤元素。 - `map(Function function)`: 将每个元素转换为另一个对象。 - `flatMap(Function function)`: 将每个元素映射为一个...
stream流详解
weixin_45785893的博客
11-17 2万+
Stream流 一 ：Stream流的介绍 stream不存储数据，而是按照特定的规则对数据进行计算，一般会输出结果； stream不会改变数据源，通常情况下会产生一个新的集合； stream具有延迟执行特性，只有调用终端操作时，中间操作才会执行。 对stream操作分为终端操作和中间操作，那么这两者分别代表什么呢？ 终端操作：会消费流，这种操作会产生一个结果的，如果一个流被消费过了，那它就不能被重用的。 中间操作：中间操作会产生另一个流。因此中间操作可以用来创建执行一系列动作的管道。一个特别需要注意的点
【JAVA】使用Java8 stream流对List进行遍历、过滤、查询、去重、排序、分组等
小朋友的博客
10-18 6万+
使用Java8 stream流对List进行遍历、过滤、查询、去重、排序、分组等
Java8新特性：stream流应用，丢掉for循环实现复杂遍历功能
鳄鱼儿
12-02 2659
到此，基础Stream用户就已经说完了，看到这里我们会发现，所以的stream其实都可以用for循环来实现，而我们全篇都没有使用for循环来实现，这些如果用for循环实现，你会发现实现的语句变得复杂了很多，不信的话，你可以试试。我们也可以看到stream带来的好处，包括代码更简洁、解耦等。
java8 .stream().anyMatch / allMatch / noneMatch用法
热门推荐
Java牛马的博客
08-19 8万+
java8 stream接口终端操作 anyMatch，allMatch，noneMatch anyMatch：判断的条件里，任意一个元素成功，返回true allMatch：判断条件里的元素，所有的都是，返回true noneMatch：与allMatch相反，判断条件里的元素，所有的都不是，返回true count方法，跟List接口中的 .size() 一样，返回的都是这个集合流的元素的长度，不同的是，流是集合的一个高级工厂，中间操作是工厂里的每一道工序，我们对这个流操作完成后，可以进行元素的数量的
【Java 8】手把手教你 Stream 类
sco5282的博客
09-07 718
1. Stream 概述 Stream 是 Java8 中处理集合的关键抽象概念（将要处理的集合元素看作一种流），它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。 总之，Stream API 提供了一种高效且易于使用的处理数据的方式。 它的特点： 它不是数据结构，所以，不会保存数据，只是按照特定的规则对数据进行计算，一般会输出结果 不会修改原来的数据源，它会将操作后的数据保存到另外一个对象中（保留意见：毕竟peek方法可以修改流中元素） 惰性求值，流在中间处理过程中，只是对
stream常用方法及用例
weixin_43838068的博客
06-20 760
stream常用方法及用例
Stream流及其常用方法
weixin_52308754的博客
01-17 629
Stream流 用Stream进行优化 package Study; import java.util.ArrayList; import java.util.List; public class DemoStream { public static void main(String[] args) { List<String> list=new ArrayList<>(); list.add("张无忌"); list.add
stream流常用方法大全
09-14
1. `filter`: 用于筛选符合条件的元素。 2. `map`: 对流中的每个元素执行指定操作，并返回操作结果组成的流。 3. `flatMap`: 将流中的每个元素转换为一个流，并将所有流连接成一个流。 4. `distinct`: 去除流中重复的元素。 5. `sorted`: 对流中的元素进行排序。 6. `limit`: 限制流的大小，截取前指定数量的元素。 7. `skip`: 跳过指定数量的元素，返回剩余的元素组成的流。 8. `forEach`: 对流中的每个元素执行指定操作。 9. `toArray`: 将流中的元素转换为数组。 10. `reduce`: 根据指定的操作将流中的元素进行归约，返回归约结果。 11. `collect`: 将流中的元素收集到一个容器中，如列表、集合等。 12. `max`: 返回流中的最大元素。 13. `min`: 返回流中的最小元素。 14. `count`: 返回流中元素的数量。 15. `anyMatch`: 检查流中是否存在满足指定条件的元素。 16. `allMatch`: 检查流中的所有元素是否都满足指定条件。 17. `noneMatch`: 检查流中是否不存在满足指定条件的元素。 18. `findFirst`: 返回流中的第一个元素。 19. `findAny`: 返回流中的任意一个元素。 这些是常用的流操作方法，可以根据具体需求选择适合的方法来处理流。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值