zoukankan      html  css  js  c++  java
  • java 两个List集合各种情况对比处理

    Lambda作为函数式编程中的基础部分,在其他编程语言(例如:Scala)中早就广为使用,但在JAVA领域中发展较慢,直到java8,才开始支持Lambda。

    抛开数学定义不看,直接来认识Lambda。Lambda表达式本质上是匿名方法,其底层还是通过invokedynamic指令来生成匿名类来实现。它提供了更为简单的语法和写作方式,允许你通过表达式来代替函数式接口。在一些人看来,Lambda就是可以让你的代码变得更简洁,完全可以不使用——这种看法当然没问题,但重要的是lambda为Java带来了闭包。得益于Lamdba对集合的支持,通过Lambda在多核处理器条件下对集合遍历时的性能提高极大,另外我们可以以数据流的方式处理集合——这是非常有吸引力的。

    1. List去重:

    /**
         * java List Strasm去重
         * @param args
         */
        public static void main(String[] args) {
            List<String> list = new ArrayList<>();
            list.add("1");
            list.add("1");
            list.add("2");
            list.add("3");
            list.add("4");
            list.add("3");
            list.add("4");
            System.out.println("List去重前:" + list);
            
            list = list.stream().distinct().collect(Collectors.toList());
            System.out.println("List去重后:" + list);
        }

    测试结果:


    2. List根据对象某个字段去重:

    import java.util.ArrayList;
    import java.util.List;
    import java.util.stream.Collectors;
    
    /**
     * <p>测试user<p>
     * @version 1.0
     * @author li_hao
     * @date 2018年7月18日
     */
    public class User {
    
        private String userid;
        private String username;
        
        public User(String userid, String username) {
            super();
            this.userid = userid;
            this.username = username;
        }
        
        public String getUserid() {
            return userid;
        }
        public void setUserid(String userid) {
            this.userid = userid;
        }
        public String getUsername() {
            return username;
        }
        public void setUsername(String username) {
            this.username = username;
        }
        
        @Override
        public String toString() {
            return "User [userid=" + userid + ", username=" + username + "]";
        }
    
        /**
         * list Stream根据对象userid字段去重
         */
        public static void main(String[] args) {
            List<User> list = new ArrayList<User>();
            list.add(new User("1","张三"));
            list.add(new User("1","zhangsan"));
            list.add(new User("2","李四"));
            list.add(new User("2","李四"));
            list.add(new User("3","刘大壮"));
            
            System.out.println("根据userid去重前:" + list);
            
            List<User> listRmdup = new ArrayList<User>();
            list.stream()
                .collect(Collectors.groupingBy(User :: getUserid))  //把list中数据根据userid分组
                .forEach((String userid, List<User> ls) -> {  //遍历分组
                    listRmdup.add(ls.get(0));  //取分组中的首个userid的对象存入新的listlistRmdup中
                });
            
    //        分开写
    //        Map<String, List<User>> collect = list.stream().collect(Collectors.groupingBy(User :: getUserid));  //把list中数据根据userid分组
    //        collect.forEach((String userid, List<User> ls) -> {  //遍历分组
    //            listRmdup.add(ls.get(0));  //取分组中的首个userid的对象存入新的listlistRmdup中
    //        });
            
            System.out.println("根据userid去重后:" + listRmdup);
        }
    
    }

    测试结果:

    根据userid去重前:[User [userid=1, username=张三], User [userid=1, username=zhangsan], User [userid=2, username=李四], User [userid=2, username=李四], User [userid=3, username=刘大壮]]
    根据userid去重后:[User [userid=1, username=张三], User [userid=2, username=李四], User [userid=3, username=刘大壮]]


    3. 对比两个List,返回两个list中:合并后集合、合并去重后的集合、相同的集合、不同的集合、list1中不在list2中的集合、list2不在list1中的集合:

    import java.util.ArrayList;
    import java.util.List;
    import java.util.stream.Collectors;
    
    public class TestStream {
    
        /**
         * 对比两个list,返回两个list中:合并后集合、合并去重后的集合、相同的集合、不同的集合、list1中不在list2中的集合、list2不在list1中的集合
         * @param list1  集合1
         * @param list2  集合2
         * @param cmpType 比较类型返回:a:合并后集合;b:合并去重后的集合;c:相同的集合;d:不同的集合;e:list1中不在list2中的集合;f:list2不在list1中的集合;
         * @return List 返回处理后的集合
         * 例如:
         * list1  :[1, 2, 3, 3, 4, 5, 6]
         * list2  :[3, 4, 4, 7, 8]
         * a:合并后集合,listAll:[1, 2, 3, 3, 4, 5, 6, 3, 4, 4, 7, 8]
         * b:合并去重后的集合;[1, 2, 3, 4, 5, 6, 7, 8]
         * c:相同的集合;[3, 4]
         * d:不同的集合;[1, 2, 5, 6, 7, 8]
         * e:list1中不在list2中的集合;[1, 2, 5, 6]
         * f:list2不在list1中的集合;[7, 8]
         */
        public static List<String> compareList(List<String> list1, List<String> list2, String cmpType){
            List<String> retList = new ArrayList<String>();
            List<String> listAll = new ArrayList<String>();
            
            listAll.addAll(list1);
            listAll.addAll(list2);
            
            if("a".equals(cmpType)){
                //合并后的集合
                retList = listAll;
            }
            if("b".equals(cmpType)){
                //合并去重后的集合
                retList = listAll.stream().distinct().collect(Collectors.toList());
            }
            if("c".equals(cmpType) || "d".equals(cmpType) || "e".equals(cmpType) || "f".equals(cmpType)){
                //相同的集合
                List<String> listSameTemp = new ArrayList<String>();
                list1.stream().forEach(a -> {
                    if(list2.contains(a))
                        listSameTemp.add(a);
                });
                retList = listSameTemp.stream().distinct().collect(Collectors.toList());
                
                //不同的集合
                if("d".equals(cmpType)){
                    List<String> listTemp = new ArrayList<>(listAll);
                    listTemp.removeAll(retList);
                    retList = listTemp;
                }
                //list1中不在list2中的集合
                if("e".equals(cmpType)){
                    List<String> listTemp = new ArrayList<>(list1);
                    listTemp.removeAll(retList);
                    retList = listTemp;
                }
                //list2中不在list1中的集合
                if("f".equals(cmpType)){
                    List<String> listTemp = new ArrayList<>(list2);
                    listTemp.removeAll(retList);
                    retList = listTemp;
                }
            }
            return retList;
        }    
        
        /**
         * 测试
         */
        public static void main(String[] args) {
            List<String> list1 = new ArrayList<String>();
            list1.add(new String("1"));
            list1.add(new String("2"));
            list1.add(new String("3"));
            list1.add(new String("3"));
            list1.add(new String("4"));
            list1.add(new String("5"));
            list1.add(new String("6"));
            
            List<String> list2 = new ArrayList<String>();
            list2.add(new String("3"));
            list2.add(new String("4"));
            list2.add(new String("4"));
            list2.add(new String("7"));
            list2.add(new String("8"));
            
            System.out.println("list1:" + list1);
            System.out.println("list2:" + list2);
            System.out.println("合并后集合:" + compareList(list1, list2, "a"));
            System.out.println("合并去重后的集合:" + compareList(list1, list2, "b"));
            System.out.println("相同的集合:" + compareList(list1, list2, "c"));
            System.out.println("不同的集合:" + compareList(list1, list2, "d"));
            System.out.println("list1中不在list2中的集合:" + compareList(list1, list2, "e"));
            System.out.println("list2中不在list1中的集合:" + compareList(list1, list2, "f"));
            
        }
    }

    测试结果:


     4. 从一个对象集合中获取每个对象的某个值返回一个新的集合:

    import java.util.ArrayList;
    import java.util.List;
    import java.util.stream.Collectors;
    
    /**
     * <p>测试user<p>
     * @version 1.0
     * @author li_hao
     * @date 2018年7月18日
     */
    public class User {
    
        private String userid;
        private String username;
        
        public User(String userid, String username) {
            super();
            this.userid = userid;
            this.username = username;
        }
        
        public String getUserid() {
            return userid;
        }
        public void setUserid(String userid) {
            this.userid = userid;
        }
        public String getUsername() {
            return username;
        }
        public void setUsername(String username) {
            this.username = username;
        }
        
        @Override
        public String toString() {
            return "User [userid=" + userid + ", username=" + username + "]";
        }
    
        /**
         * 从一个对象集合中获取每个对象的某个值返回一个新的集合
         */
        public static void main(String[] args) {
            List<User> list = new ArrayList<User>();
            list.add(new User("1","张三"));
            list.add(new User("2","李四"));
            list.add(new User("3","刘大壮"));
            
            System.out.println("处理前:" + list);
            
            List<String> Useridlist = list.stream().map(User :: getUserid).collect(Collectors.toList());
            
            System.out.println("处理后:" + Useridlist);
        }
        
    }

    测试结果:

  • 相关阅读:
    类和对象
    数组
    随笔3
    设计把所有的奇数移动到所有偶数前面的算法
    选择排序
    队列的链式存储结构
    循环队列
    一起玩算法(把所有相同的数字后移)
    判断序列B是否是序列A的连续子序列
    power bi创建切片器导航
  • 原文地址:https://www.cnblogs.com/hooly/p/9328734.html
Copyright © 2011-2022 走看看