jdk8新特性之stream流

w_t_y_y

已于 2024-09-19 11:05:10 修改

阅读量254

点赞数

分类专栏： # 集合文章标签： java 开发语言

于 2020-07-21 10:38:05 首次发布

本文链接：https://blog.youkuaiyun.com/w_t_y_y/article/details/107483119

版权

集合专栏收录该内容

8 篇文章

订阅专栏

本文详细介绍Java Stream API的应用，包括基本运算、集合操作如求交集、差集，以及集合到Map的转换。通过实例演示如何利用Stream API进行数据处理，提高代码效率。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、类型转换

List、Map之间转换，常见的用法有：

1、toMap将List转成Map

注意使用toMap最好加mergeFunction重复处理方法，否则对于重复的key会抛异常。即使用

Collector<T, ?, Map<K,U>> toMap(Function<? super T, ? extends K> keyMapper,
                                    Function<? super T, ? extends U> valueMapper,
                                    BinaryOperator<U> mergeFunction)

demo：

List<User> users;
Map<String, String> idMap = users.stream().collect(Collectors.toMap(User::getParentUserId, User::getId, (o, n) -> n));

Map<String, Asset> assetMap = assetList.stream().collect(Collectors.toMap(Asset::getId, Asset -> Asset, (v1, v2) -> v2));

2、 List<?>转成Map<Key,List<?>>

Map<String, List<UserFile>>  userFilesMap = userFileList.stream().collect(Collectors.groupingBy(UserFile::getUserId));

3、从对象集合中获取字段集合

List<Account> accounts;
        List<String> accountIds =
                accounts.stream().map(Account::getId).collect(Collectors.toList());

一、集合的基本运算：

import com.alibaba.fastjson.JSON;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
 
public class StreamDemo {
 
    public static void main(String[] args) {
        List<User> userList = new ArrayList<>();
        User user = new User();
        user.setId("1");
        user.setName("张一");
        userList.add(user);
        user = new User();
        user.setId("4");
        user.setName("张四");
        userList.add(user);
        user = new User();
        user.setId("2");
        user.setName("张二");
        userList.add(user);
        user = new User();
        user.setId("3");
        user.setName("张三");
        userList.add(user);
        user = new User();
        user.setId("5");
        user.setName("张二");
        userList.add(user);
 
        // 获取名称的集合 (stream 串行流)
//        List<String> collect = userList.stream().map(User::getName).collect(Collectors.toList());
//        System.out.println("获取名称的集合:" + collect);
//        //parallelStream() − 为集合创建并行流    并行流是多线程的结果，速度比stream快很多，可能会和stream结果不一致，但是效率很高
//        collect = userList.parallelStream().map(User::getName).collect(Collectors.toList());
//        System.out.println("获取名称的集合:" + collect);
 
        // 限制输出
//        List<String> collect = userList.stream().map(User::getName).limit(3).collect(Collectors.toList());
//        System.out.println("限制输出三个:" + collect);
 
        // 获取排序的集合
//        List<String> collect = userList.stream().map(User::getId).sorted().collect(Collectors.toList());
//        System.out.println("获取排序的集合:"+collect);
 
        // 获取去除重复的集合
//        List<String> collect = userList.stream().map(User::getName).distinct().collect(Collectors.toList());
//        System.out.println("获取去除重复的集合:"+collect);
 
        // 过滤
//        List<String> collect = userList.stream().map(User::getName).filter(str -> !str.isEmpty()).collect(Collectors.toList());
//        System.out.println("过滤:"+collect);
 
        // 获取集合装字符串
//        String mergedString = userList.stream().map(User::getName).filter(str -> !str.isEmpty()).collect(Collectors.joining(", "));
//        System.out.println("直接获取字符串:"+mergedString);
 
        // 获取空字符串的数量
//        List<String>strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
//        long count = strings.stream().filter(string -> string.isEmpty()).count();
//        System.out.println("获取空字符串的数量:"+count);
 
        // 统计 (总数量，总和，最小值，最大值，平均值)
//        List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
//        IntSummaryStatistics stats = numbers.stream().mapToInt((x) -> x).summaryStatistics();
//        System.out.println("统计:"+stats);
 
        // 获取对应的平方数
//        List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
//        List<Integer> squaresList = numbers.stream().map( i -> i*i).distinct().collect(Collectors.toList());
//        System.out.println("去重获取平方:"+ JSON.toJSONString(squaresList));


      //字符串转整形
  //public static Consumer> lambdaConversion() {
     //   return list -> Lists.newArrayList(list.stream()
     //           .mapToInt(Integer::valueOf)
     //           .iterator());
   // }
 
    }
}

还可以做条件合并查询，如：

 List<SchoolProject> schoolTemProjects = temporarySchoolProjects.stream().filter(
                        r -> currSchoolId == r.getSchoolId() &&
                                currProjectCode() == r.getProjectCode()).collect(Collectors.toList());

二、集成求交集、差集：info : ['A' ,'B' ,'C' ,'D' , 'E', 'F'] ; list : ['A' ,'B' ,'C' ,'D' , 'G', 'H']

List<TbBaseinfo> differenceSet1 = info.stream().filter(item -> !list.stream().map(e -> e.getId()).collect(Collectors.toList()).contains(item.getId())).collect(Collectors.toList());//已有数据和提交数据的差集,得到差集['E', 'F']
List<TbBaseinfo> differenceSet2 = list.stream().filter(item -> !info.stream().map(e -> e.getId()).collect(Collectors.toList()).contains(item.getId())).collect(Collectors.toList());//提交数据和已有数据的差集，得到差集['G', 'H']
List<TbBaseinfo> differenceSet = new ArrayList<TbBaseinfo>(differenceSet1);
differenceSet.addAll(differenceSet2);//两个差集合并在一起
differenceSet = differenceSet.stream().distinct().collect(Collectors.toList());//合并后的差集去重 [ 'E', 'F' ,'G', 'H' ]

//2.已经存在的集合，和本次提交的集合，求交集
List<TbBaseinfo> intersection = info.stream().filter(item -> list.stream().map(e -> e.getId()).collect(Collectors.toList()).contains(item.getId())).collect(Collectors.toList()); //得到交集：['A' ,'B' ,'C' ,'D']

//3.本次保存的集合，和交集，的差集
List<TbBaseinfo> allDifferenceSet1 = info.stream().filter(item -> !intersection.stream().map(e -> e.getId()).collect(Collectors.toList()).contains(item.getId())).collect(Collectors.toList());

//['A' ,'B' ,'C' ,'D' , 'G', 'H']和 ['A' ,'B' ,'C' ,'D']的差集,得到差集：['G', 'H']
List<TbBaseinfo> allDifferenceSet2 = intersection.stream().filter(item -> !info.stream().map(e -> e.getId()).collect(Collectors.toList()).contains(item.getId())).collect(Collectors.toList());

//['A' ,'B' ,'C' ,'D']和 ['A' ,'B' ,'C' ,'D' , 'G', 'H']的差集,得到差集：[]
List<TbBaseinfo> allDifferenceSet = new ArrayList<EcBaseinfo>(allDifferenceSet1);
allDifferenceSet.addAll(allDifferenceSet2); //合并差集为：['G', 'H']
allDifferenceSet = allDifferenceSet.stream().distinct().collect(Collectors.toList()); //去重还是['G', 'H']

List<TbBaseinfo> allDifference = allDifferenceSet;

//4.最终的差集，和第一次的差集,的交集，即是要添加的，差集即是要删除的
List<TbBaseinfo> addList = differenceSet.stream().filter(item -> !allDifference.stream().map(e -> e.getId()).collect(Collectors.toList()).contains(item.getId())).collect(Collectors.toList());

//['G', 'H']和[ 'E', 'F' ,'G', 'H' ]的交集：['G', 'H']，即是要添加的，插入
List<TbBaseinfo> delList = differenceSet.stream().filter(item -> allDifference.stream().map(e -> e.getId()).collect(Collectors.toList()).contains(item.getId())).collect(Collectors.toList());

//['G', 'H']和[ 'E', 'F' ,'G', 'H' ]的差集：['E', 'F']，即是要删除的

三、集合转化为Map：

List转换为Map，使用Collectors.toMap方法进行转换：User类，分别有id，name,age三个属性。List集合,userList，存储User对象

1、指定key-value，value是对象中的某个属性值。

Map<Integer,String> userMap1 = userList.stream().collect(Collectors.toMap(User::getId,User::getName));

2、指定key-value，value是对象本身，User->User 是一个返回本身的lambda表达式

Map<Integer,User> userMap2 = userList.stream().collect(Collectors.toMap(User::getId,User->User));

3、指定key-value，value是对象本身，Function.identity()是简洁写法，也是返回对象本身

Map<Integer,User> userMap3 = userList.stream().collect(Collectors.toMap(User::getId, Function.identity()));

4、指定key-value，value是对象本身，Function.identity()是简洁写法，也是返回对象本身，key 冲突的解决办法，这里选择第二个key覆盖第一个key。

Map<Integer,User> userMap4 = userList.stream().collect(Collectors.toMap(User::getId, Function.identity(),(key1,key2)->key2));

5、Map<String, List<User>> userMap = sList.stream().collect(Collectors.groupingBy(User::getSchoolId));
User::getSchoolId可以用user->user.getSchoolId()来代替