【JAVA】List常用移除、过滤、去重、flatMap、peek等操作

本文链接：https://blog.csdn.net/qq_38397501/article/details/116494227

List常用移除，过滤，去重操作

ListItem.class

import lombok.Data;
import lombok.experimental.Accessors;

@Data
@Accessors(chain = true)
public class ListItem {
    private String item;
    private String qwe;
}

移除List中某个的元素

public static void main(String[] args) {
    List<ListItem> listItems = new ArrayList<>();
    listItems.add(new ListItem().setItem("111111").setQwe("222222"));
    listItems.add(new ListItem().setItem("111111").setQwe("222222"));
    listItems.add(new ListItem().setItem("123123").setQwe("321321"));
    listItems.add(new ListItem().setItem("qweqwe").setQwe("qweqwe"));

    //jdk8操作方式
    listItems.removeIf(listItem -> listItem.getItem().equals("111111"));
    listItems.forEach(System.out::println);

    //传统写法 1
    for (int i = 0; i < listItems.size(); i++) {
        if (listItems.get(i).getItem().equals("111111")) {
            listItems.remove(i);
            //索引回归，why? 因为这个元素移除了，上一个元素会顶上来，不回归就跳过了一个元素的判断
            i--;
        }
    }
    listItems.forEach(System.out::println);

    //传统写法 2
    Iterator<ListItem> iterator = listItems.iterator();
    while (iterator.hasNext()) {
        if (iterator.next().getItem().equals("111111")) {
            iterator.remove();
        }
    }
    listItems.forEach(System.out::println);
}

List排序

public static void main(String[] args) {
    ReCandidate reCandidate = new ReCandidate();
    reCandidate.setAge(1);
    reCandidate.setId(15L);

    ReCandidate reCandidate2 = new ReCandidate();
    reCandidate2.setAge(2);
    reCandidate2.setId(100L);

    ReCandidate reCandidate3 = new ReCandidate();
    reCandidate3.setAge(2);
    reCandidate3.setId(88L);

    ReCandidate reCandidate4 = new ReCandidate();
    reCandidate4.setAge(3);
    reCandidate4.setId(1L);

    List<ReCandidate> list = Arrays.asList(reCandidate, reCandidate2, reCandidate3, reCandidate4);

    List<ReCandidate> collect =
            list.stream()
                    .sorted(
                            //按照年龄从小倒大排列
                            Comparator.comparingInt(ReCandidate::getAge)
                                    //倒转，也就是变成了从大到小排列
                                    .reversed()
                                    //根据年龄倒序排完后，年龄相同再根据ID从小到大排
                                    .thenComparingLong(ReCandidate::getId)
                    )
                    .collect(Collectors.toList());


    for (ReCandidate candidate : collect) {
        System.out.println(candidate.getAge() + "----" + candidate.getId());
    }
    /* 
        3----1
        2----88
        2----100
        1----15
        
        Process finished with exit code 0
     */
}

List去重(如有特殊去重需求，自行重写equals方法)

public static void main(String[] args) {
    List<ListItem> listItems = new ArrayList<>();
    listItems.add(new ListItem().setItem("111111").setQwe("222222"));
    listItems.add(new ListItem().setItem("111111").setQwe("222222"));
    listItems.add(new ListItem().setItem("123123").setQwe("321321"));
    listItems.add(new ListItem().setItem("qweqwe").setQwe("qweqwe"));

    List<ListItem> removeRepeatList = listItems.stream().distinct().collect(Collectors.toList());
    removeRepeatList.forEach(System.out::println);
}

List查找指定元素

public static void main(String[] args) {
    List<ListItem> listItems = new ArrayList<>();
    listItems.add(new ListItem().setItem("111111").setQwe("222222"));
    listItems.add(new ListItem().setItem("111111").setQwe("222222"));
    listItems.add(new ListItem().setItem("123123").setQwe("321321"));
    listItems.add(new ListItem().setItem("qweqwe").setQwe("qweqwe"));

    List<ListItem> collect = listItems.stream().filter(item -> item.getItem().equals("111111")).collect(Collectors.toList());
    collect.forEach(System.out::println);
}

取出List中对象的某个属性构造出新List

public static void main(String[] args) {
    List<ListItem> listItems = new ArrayList<>();
    listItems.add(new ListItem().setItem("111111").setQwe("222222"));
    listItems.add(new ListItem().setItem("111111").setQwe("222222"));
    listItems.add(new ListItem().setItem("123123").setQwe("321321"));
    listItems.add(new ListItem().setItem("qweqwe").setQwe("qweqwe"));

    List<String> collect = listItems.stream().map(ListItem::getItem).collect(Collectors.toList());
	collect.forEach(System.out::println);
}

处理某个字符分隔的List属性，将其拆分构造为新List

public static void main(String[] args) {
    List<String> separateList = new ArrayList<>();
    separateList.add("aaa,bbb,ccc");
    separateList.add("ddd,eee,fff");
    separateList.add("ggg,hhh,iii");
    //flatMap将流中的每一个元素 T 映射为一个流，再把每一个流连接成为一个流
    List<String> collect = separateList.stream().map(item -> item.split(",")).flatMap(Arrays::stream).collect(Collectors.toList());
    collect.forEach(System.out::println);
}

List转数组

public static void main(String[] args) {
    List<String> list = new ArrayList<>(2);
    list.add("123123");
    list.add("321321");
    String[] array = list.toArray(new String[0]);
    for (String s : array) {
        System.out.println(s);
    }   
}

两个List的交集，并集，差集操作

public static void main(String[] args) {
    List<String> list1 = new ArrayList<>();
    list1.add("qwe1");
    list1.add("qwe2");
    list1.add("qwe3");
    list1.add("qwe4");
    list1.add("qwe5");

    List<String> list2 = new ArrayList<>();
    list2.add("qwe5");
    list2.add("qwe6");
    list2.add("qwe7");
    list2.add("qwe8");
    list2.add("qwe9");

    // 交集
    List<String> collect = list1.stream().filter(list2::contains).collect(Collectors.toList());
    collect.forEach(System.out::println);
    // 差集 List1和List2的差，也就是List1-List2,反之类比即可
    List<String> collect1 = list1.stream().filter(item -> !list2.contains(item)).collect(Collectors.toList());
    collect1.forEach(System.out::println);
    //去重复并集
    List<String> all = new ArrayList<>();
    all.addAll(list1);
    all.addAll(list2);
    List<String> collect = all.stream().distinct().collect(Collectors.toList());
    collect.forEach(System.out::println); 
}

flatMap的作用以及使用方式

其主要作用就是将几个小List中内容提取，合并成大List

public static void main(String[] args) {

        List<String> list1 = Arrays.asList("张三", "李四");
        List<String> list2 = Arrays.asList("王五", "赵六");

        List<List<String>> list = new ArrayList<>();
        list.add(list1);
        list.add(list2);

        //使用flatmap
        List<String> collect = list.stream()
                .flatMap(Collection::stream)
                .collect(Collectors.toList());
        System.out.println(collect.toString());

        /* 
            [张三, 李四, 王五, 赵六]
            Process finished with exit code 0   
         */
    }

当然，这不仅仅局限于一种类型之上，多种类型也是完全可以的

public static void main(String[] args) {
        ReCandidate reCandidate  = new ReCandidate();
        reCandidate.setCandidateName("asdasdasda");
        reCandidate.setId(1111L);
        reCandidate.setAge(111);
        
        ReCandidate reCandidate2  = new ReCandidate();
        reCandidate2.setCandidateName("12312123123");
        reCandidate2.setId(33333L);
        reCandidate2.setAge(33333);
        
        //Long 类型List
        List<Long> list1 = Arrays.asList(111L, 222L);
        //String 类型List
        List<String> list2 = Arrays.asList("王五", "赵六");
        //实体类 类型List
        List<ReCandidate> list3 = Arrays.asList(reCandidate,reCandidate2);

        List<List<?>> list = new ArrayList<>();
        list.add(list1);
        list.add(list2);
        list.add(list3);
        
        List<?> collect = list.stream()
					       .flatMap(Collection::stream)
					        .collect(Collectors.toList());
        System.out.println(collect);
        /*
            [111, 222, 王五, 赵六, ReCandidate(id=1111, candidateName=asdasdasda)]
            
            Process finished with exit code 0
         */
    }

peek()方法的作用及例子

主要是操作流经管道的数据，未流经管道的数据不做操作


import lombok.Data;

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

public class Test {

    public static void main(String[] args) {
        List<A> list = new ArrayList<>();
        A a1 = new A();
        a1.setId("11");
        a1.setName("zhangsan11");
        a1.setAge("11");
        list.add(a1);

        A a2 = new A();
        a2.setId("22");
        a2.setName("lisi22");
        a2.setAge("22");
        list.add(a2);

        A a3 = new A();
        a3.setId("33");
        a3.setName("zhangsan33");
        a3.setAge("33");
        list.add(a3);

        list.forEach(System.out::println);
        System.out.println("----------------------");
        //先按照id 倒序 排序，在过滤出包含zhangsan的，在把过滤出的数据age替换成666，再输出
        list.stream().sorted(Comparator.comparing(item -> Integer.parseInt(item.getId()), (a, b) -> {
                    return b.compareTo(a);
                }))
                .filter(item -> item.getName().contains("zhangsan"))
                //对流经管道的数据进行操作，为流经管道的不做修改
                .peek(item -> item.setAge("666"))
                .forEach(System.out::println);
        System.out.println("----------------------");
        list.forEach(System.out::println);
        /* 
            A(id=11, name=zhangsan11, age=11)
            A(id=22, name=lisi22, age=22)
            A(id=33, name=zhangsan33, age=33)
            ----------------------
            A(id=33, name=zhangsan33, age=666)
            A(id=11, name=zhangsan11, age=666)
            ----------------------
            A(id=11, name=zhangsan11, age=666)
            A(id=22, name=lisi22, age=22)
            A(id=33, name=zhangsan33, age=666)
            
            Process finished with exit code 0
         */
    }
}

@Data
class A {
    private String id;
    private String name;
    private String age;
}

collect()的补充

public class Test {
    public static void main(String[] args) {

        List<Kusch> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            list.add(Kusch.builder().id("10000" + i).name("zhangsan" + i).age(i).build());
        }
        System.out.println("-----------------------------------------------------------------------------");
        //按照age分组组成list
        Map<Integer, List<Kusch>> collect = list.stream()
                .collect(Collectors.groupingBy(Kusch::getAge));
        collect.forEach((k, v) -> System.out.println(k + "----" + v));
        System.out.println("-----------------------------------------------------------------------------");

        //取特定的值作为新的Map
        Map<String, String> idKeyNameValue = list.stream()
                .filter(item -> item.getAge() > 5)
                .collect(Collectors.toMap(Kusch::getId, Kusch::getName, (k1, k2) -> k1));
        idKeyNameValue.forEach((k, v) -> System.out.println(k + "----" + v));
        System.out.println("-----------------------------------------------------------------------------");

    }

    @Data
    @Builder
    static class Kusch {
        private String id;
        private String name;
        private Integer age;
    }

}