List stream流方式，根据条件修改list中的内容或者过滤（filter，map,flatMap）

小徐敲java

已于 2023-01-29 11:49:32 修改

阅读量1.7w

点赞数 4

文章标签： java stream flatMap filter

于 2022-09-24 20:44:01 首次发布

本文链接：https://blog.csdn.net/qq_19891197/article/details/127030616

版权

** 注意** ：list.stream()中的.stream()是将list集合展开，分割成一个一个

1：中间操作
一个流可以后面跟随零个或多个中间操作。其目的主要是打开流，做出某种程度的数据映射/过滤，然后返回一个新的流，交给下一个操作使用。这类操作都是惰性化的，仅仅调用到这类方法，并没有真正开始流的遍历，真正的遍历需等到终端操作时，常见的中间操作有下面即将介绍的 filter、map 等。
2：终端操作
一个流有且只能有一个终端操作，当这个操作执行后，流就被关闭了，无法再被操作，因此一个流只能被遍历一次，若想在遍历需要通过源数据在生成流。终端操作的执行，才会真正开始流的遍历。如下面即将介绍的 count、collect 等。

1:list.stream().filter(dto-> 筛选条件(是一个布尔值)).forEach(dto2-> dto2.setId(“1”));

2：list.stream() .filter(d -> d.getVegitarian()).collect(Collectors.toList());

3：list.stream().filter(Dish::getVegitarian).collect(Collectors.toList());

4：map 流映射（所谓流映射就是将接受的元素映射成另外一个元素）

public static void main(String[] args) {

        List<Map<String, Integer>> list = new ArrayList<>();
        Map<String, Integer> map1 = new HashMap<>();
        map1.put("aa", 1);
        map1.put("bb", 2333);
        map1.put("cc", 3);
        list.add(map1);
        Map<String, Integer> map2 = new HashMap<>();
        map2.put("aa", 1);
        map2.put("bb", 22);
        map2.put("cc", 23);
        list.add(map2);
        Map<String, Integer> map3 = new HashMap<>();
        map3.put("aa", 31);
        map3.put("bb", 32);
        map3.put("cc", 33);
        list.add(map3);
        System.out.println(list);

        Set<String> chartSet=list.stream().filter(a->a.get("aa").equals(1)).map(d->d.get("bb").toString()).collect(Collectors.toSet());
        System.out.println(chartSet);
}

打印结果是

[{aa=1, bb=2333, cc=3}, {aa=1, bb=22, cc=23}, {aa=31, bb=32, cc=33}]
[22, 2333]

4-1：对list操作修改里面的值（类似SQL的select功能）


List<<Map<String, Object>> newList = list.stream().map(d -> {
            d.put("user","李四");
            d.put("age", "18");
            return d;
        }).collect(Collectors.toList());

4-2：筛选list中需要的字段

List<Map<String, Object>> collect = listData.stream().map(dd -> {
            dd.get("name");
            dd.get("chanel");
            return dd;
        }).collect(Collectors.toList());
        System.out.println(collect);

6：distinct 去重

通过distinct方法快速去除重复的元素

		List<Integer> integerList = Arrays.asList(1, 1, 2, 3, 4, 5);

        List<Integer> stream = integerList.stream().distinct().collect(Collectors.toList());

        System.out.println(stream);

打印结果是

[1, 2, 3, 4, 5]

7：实际开发中Stream流式编程flatMap的使用（两层for循环）

flatMap()的作用是对流中的元素进行1对多的转换，然后将结果元素展开为新的流。

这句话的含义是什么？你可以理解为flatMap就是两层for循环处理数据。而返回结果就是flatMap展开的流。

数据准备

/**
 * 玩具类
 */
@Data
@AllArgsConstructor
public class Toy {

    private String name;

    private double price;
}

-----------------------------------------------------------------------------------------------------------------

@Data
@AllArgsConstructor
public class Boy {
    private String name;

    private int age;

    private List<Toy> toys;
}

-----------------------------------------------------------------------------------------------------------------

@Data
@AllArgsConstructor
public class Student {

    private String name;
    private String schoolName;
    private String className;
}

-----------------------------------------------------------------------------------------------------------------


public class TestStream {
    private static List<Boy> boys = new ArrayList<>();
    private static List<Student> stus = new ArrayList<>();
    static {


        boys.add(new Boy("tom", 12,
                Arrays.asList(
                        new Toy("飞机", 9.1),
                        new Toy("坦克", 7.0),
                        new Toy("小熊", 14.0))));

        boys.add(new Boy("tony", 19,
                Arrays.asList(
                        new Toy("玩具枪", 13.1),
                        new Toy("小汽车", 12.2))));


        stus.add(new Student("tom", "衡水中学", "尖子班"));
        stus.add(new Student("jerry", "黄冈中学", "普通班"));
        stus.add(new Student("dom", "衡水一中", "文科班"));
    }
}

对元素内部的集合进行处理
第一个Stream是将boys集合展开，而在flatMap()内部，会将boys集合内部集合再次展开。

其等效于两层for循环，最终得到的结果是n*m给元素。（注：n是外层循环次数，m是内层循环次数）

public static void main(String[] args) {

        //此时是处理第二个循环
        List<Toy> toys = boys.stream().flatMap(
                //将流中元素的数据再次展开
                b -> b.getToys().stream()).
                    collect(Collectors.toList());
        System.out.println(JSON.toJSONString(toys));
//        等效于
        //因为是1:n的关系，所以最终会产生n记录
        List<Toy> tls = new ArrayList<>();
        for (Boy boy : boys) {
            for (Toy toy : boy.getToys()) {
                tls.add(toy);
            }
        }
        //打印数据
        System.out.println(JSON.toJSONString(tls));
  }

当然在flatMap方法内部，可以利用这两个流的元素进行操作。

public static void main(String[] args) {
        List<String> collect1 = boys.stream().flatMap(b -> b.getToys().stream().
                filter(t -> t.getPrice() > 12).
                map(t -> {
                    //即可以操作外层元素也可以操作内层元素
                    return b.getName() + ":" + t.getName();
                })).collect(Collectors.toList());

        System.out.println(JSON.toJSONString(collect1));
        //等效于：
        List<String> tls1 = new ArrayList<>();
        for (Boy boy : boys) {
            for (Toy toy : boy.getToys()) {
                if (toy.getPrice() > 12) {
                    tls1.add(boy.getName() + ":" + toy.getName());
                }
            }
        }
        System.out.println(JSON.toJSONString(tls1));
    }
}

用于两个集合的合并
将两个集合合并为一个集合，一般写法需要得借助两层for循环。

而flatMap()操作的一个作用就是将两个集合合并为一个集合，相当于join操作，若没有filter操作，会产生笛卡尔积现象

public static void main(String[] args) {
        List<String> collect = boys.stream().flatMap(b -> stus.stream().
                        //第二层for循环中处理数据
                                filter(s -> b.getName().equals(s.getName())).
                        //将数据放入到一个新的集合中
                                map(Student::getName)
                //结束第二层循环
        ).collect(Collectors.toList());
        System.out.println(JSON.toJSONString(collect));


       //等效于
        List<String> data=new ArrayList<>();
        //双层for循环处理数据
        for (Boy boy : boys) {
            for (Student student : stus) {
                //filter条件
                if(boy.getName().equals(student.getName())){
                    //map子句，将元素放入到新集合中
                    data.add(student.getName());
                }
            }
        }
        System.out.println(JSON.toJSONString(data));
    }

总结：JDK1.8提供了Stream提供的流式操作可以使得开发人员像操作数据库一样操作集合。Map相当于select映射，而flatMap更像join连接

8：实际开发中Stream流式编程flatMap的使用

 
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
 
 
public class FlatMap {
    public static void main(String[] args) {
        //扁平化流
        //找出数组中唯一的字符
        String[] strArray = {"hello", "world"};
 
        //具体实现
        List<String> res = Arrays.stream(strArray)
                .map(w -> w.split(""))
                .flatMap(Arrays::stream)
                .distinct()
                .collect(Collectors.toList());
        System.out.println(res);
 
        //TODO 案例
        System.out.println("--------------------------------");
        //Demo1:给定数组，返回数组平方和(直接使用映射)
        //[1,2,3,4]=>[1,4,9,16]
        Integer[] nums1 = {1, 2, 3, 4};
        List<Integer> nums1List = Arrays.asList(nums1);
        List<Integer> res1 = nums1List.stream().map(i -> i * i).collect(Collectors.toList());
        System.out.println(res1);
 
        System.out.println("--------------------------------");
        //Demo2:给定两数组，返回数组对
        //[1,2,3],[3,4]=>[1,3],[1,4],[2,3],[2,4],[3,3],[3,4]
        Integer[] nums2 = {1, 2, 3};
        Integer[] nums3 = {3, 4};
        List<Integer> nums2List = Arrays.asList(nums2);
        List<Integer> nums3List = Arrays.asList(nums3);
 
        //使用2个map嵌套过滤
        List<int[]> res2 = nums2List.stream().flatMap(i -> nums3List.stream().map(j -> new int[]{i, j})).collect(Collectors.toList());
        System.out.println(res2.size());
 
        System.out.println("--------------------------------");
        //Demo3:针对Demo2和Demo1组合返回总和能被3整除的数对
        //(2,4)和(3,3)是满足条件的
        List<int[]> res3 = nums2List.stream().flatMap(i -> nums3List.stream().filter(j -> (i + j) % 3 == 0).map(j -> new int[]{i, j})).collect(Collectors.toList());
        System.out.println(res3.size());
 
 
    }
}

9： map和flatmap实现一样的效果

		List<String> fun1 = Arrays.asList("one", "two", "three");
        List<String> fun2 = Arrays.asList("four", "five", "six");
        List<List<String>> nestedList = Arrays.asList(fun1, fun2);
        
        nestedList.stream().map(x -> {
            return x.stream().map(a -> a.toUpperCase());
        }).forEach(x ->x.forEach(a->output(a)));

List<String> fun1 = Arrays.asList("one", "two", "three");
        List<String> fun2 = Arrays.asList("four", "five", "six");
        List<List<String>> nestedList = Arrays.asList(fun1, fun2);
        
        nestedList.stream().flatMap(x -> x.stream()).map(x->x.toUpperCase()).forEach(x -> output(x));