学习集合工具类CollectionUtils——List对象案例

小咪咪 2024-04-06 14:19 200阅读 0赞

#### 学习集合工具类CollectionUtils——List对象案例 ####

*  一、依赖
 *  二、案例
 *  三、结果展示

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

## 一、依赖 ##

<dependency>
                <groupId>org.apache.commons</groupId>
                <artifactId>commons-collections4</artifactId>
                <version>4.1</version>
            </dependency>

## 二、案例 ##

@Test
        void test17() {
        
            People[] peopleArray = new People[2];
            for (int i = 0; i < peopleArray.length; i++) {
        
                peopleArray[i] = new People(i, String.valueOf(i), i);
            }
    
            List<People> peopleList1 = Lists.newArrayList();
            peopleList1.add(new People(1, "小李", 3));
            peopleList1.add(new People(2, "小张", 2));
    
            List<People> peopleList2 = Lists.newArrayList();
            peopleList2.add(new People(1, "小李", 3));
            peopleList2.add(new People(3, "小皇", 1));
    
            List<People> peopleList3 = Lists.newArrayList();
    
            log.info("判断集合是否为空，只对Collection及子类有效");
            boolean isEmpty = CollectionUtils.isEmpty(peopleList1);
            log.info(String.valueOf(isEmpty));
    
            log.info("判断集合是否不为空，只对Collection及子类有效");
            boolean isNotEmpty = CollectionUtils.isNotEmpty(peopleList1);
            log.info(String.valueOf(isNotEmpty));
    
            log.info("如果参数2处不为null，把参数2添加到peopleList3集合中");
            boolean AddIgnoreNull = CollectionUtils.addIgnoreNull(peopleList3, new People(4, "小蓝", 0));
            log.info(String.valueOf(AddIgnoreNull));
            log.info(peopleList3.toString());
    
            log.info("从peopleList1中删除peopleList2");
            List<People> removeAll = CollectionUtils.removeAll(peopleList1, peopleList2).stream().collect(Collectors.toList());
            log.info(removeAll.toString());
    
            log.info("获取并集");
            List<People> union = CollectionUtils.union(peopleList1, peopleList2).stream().collect(Collectors.toList());
            log.info(union.toString());
    
            log.info("获取交集");
            List<People> intersection = CollectionUtils.intersection(peopleList1, peopleList2).stream().collect(Collectors.toList());
            log.info(intersection.toString());
    
            log.info("获取交集的补集");
            List<People> disjunction = CollectionUtils.disjunction(peopleList1, peopleList2).stream().collect(Collectors.toList());
            log.info(disjunction.toString());
    
            log.info("获取差集");
            List<People> subtract = CollectionUtils.subtract(peopleList1, peopleList2).stream().collect(Collectors.toList());
            log.info(subtract.toString());
    
            log.info("返回peopleList2在peopleList1中的数据");
            List<People> retainAll = CollectionUtils.retainAll(peopleList1, peopleList2).stream().collect(Collectors.toList());
            log.info(retainAll.toString());
    
            log.info("数组反转");
            CollectionUtils.reverseArray(peopleArray);
            log.info(Arrays.stream(peopleArray).collect(Collectors.toList()).toString());
    
            log.info("返回每个元素出现的个数");
            Map<People, Integer> cardinalityMap = CollectionUtils.getCardinalityMap(peopleList1);
            log.info(cardinalityMap.toString());
    
            log.info("返回对象在集合中出现的次数");
            int cardinality = CollectionUtils.cardinality(new People(1, "小李", 3), peopleList1);
            log.info(String.valueOf(cardinality));
    
            log.info("返回结合指定位置的数");
            People getPeople = CollectionUtils.get(peopleList1, 0);
            log.info(getPeople.toString());
    
            log.info("判断两个集合是否相等");
            boolean equalCollection = CollectionUtils.isEqualCollection(peopleList1, peopleList2);
            log.info(String.valueOf(equalCollection));
    
            log.info("判断集合1是否小于集合2");
            boolean properSubCollection = CollectionUtils.isProperSubCollection(peopleList1, peopleList2);
            log.info(String.valueOf(properSubCollection));
    
            log.info("判断是否是子集");
            boolean subCollection = CollectionUtils.isSubCollection(peopleList1, peopleList2);
            log.info(String.valueOf(subCollection));
    
    
            log.info("判断是否存在交集");
            boolean containsAny = CollectionUtils.containsAny(peopleList1, peopleList2);
            log.info(String.valueOf(containsAny));
    
            log.info("根据条件筛选集合元素");
            List<People> collect = CollectionUtils.select(peopleList1, new Predicate<People>() {
        
                @Override
                public boolean evaluate(People people) {
        
                    if (people.getId() % 2 == 0) {
        
                        return true;
                    }
                    return false;
                }
            }).stream().collect(Collectors.toList());
            log.info(collect.toString());
    
            log.info("根据指定方法处理集合元素，类似List的map()");
            CollectionUtils.transform(peopleList1, new Transformer<People, People>() {
        
                @Override
                public People transform(People people) {
        
                    people.setName(people.getName() + "_update");
                    return people;
                }
            });
            log.info(peopleList1.toString());
    
            log.info("基本和select一样");
            People findPeople = CollectionUtils.find(peopleList1, new Predicate<People>() {
        
                @Override
                public boolean evaluate(People people) {
        
                    if (people.getId() % 2 != 0) {
        
                        return true;
                    }
                    return false;
                }
            });
            log.info(findPeople.toString());
    
            log.info("调用每个元素的指定方法");
            CollectionUtils.forAllDo(peopleList1, new Closure<People>() {
        
                @Override
                public void execute(People people) {
        
                    people.setName(people.getName() + "_update");
                }
            });
            log.info(peopleList1.toString());
        }

## 三、结果展示 ##

判断集合是否为空，只对Collection及子类有效
            false
            
            判断集合是否不为空，只对Collection及子类有效
            true
            
            如果参数2处不为null，把参数2添加到peopleList3集合中
            true
            [People(id=4, name=小蓝, jgId=0)]
            
            从peopleList1中删除peopleList2
            [People(id=2, name=小张, jgId=2)]
            
            获取并集
            [People(id=1, name=小李, jgId=3), People(id=2, name=小张, jgId=2), People(id=3, name=小皇, jgId=1)]
            
            获取交集
            [People(id=1, name=小李, jgId=3)]
            
            获取交集的补集
            [People(id=2, name=小张, jgId=2), People(id=3, name=小皇, jgId=1)]
            
            获取差集
            [People(id=2, name=小张, jgId=2)]
            
            返回peopleList2在peopleList1中的数据
            [People(id=1, name=小李, jgId=3)]
            
            数组反转
            [People(id=1, name=1, jgId=1), People(id=0, name=0, jgId=0)]
            
            返回每个元素出现的个数
            {
        People(id=1, name=小李, jgId=3)=1, People(id=2, name=小张, jgId=2)=1}
            
            返回对象在集合中出现的次数
            1
            
            返回结合指定位置的数
            People(id=1, name=小李, jgId=3)
            
            判断两个集合是否相等
            false
            
            判断集合1是否小于集合2
            false
            
            判断是否是子集
            false
            
            判断是否存在交集
            true
            
            根据条件筛选集合元素
            [People(id=2, name=小张, jgId=2)]
            
            根据指定方法处理集合元素，类似List的map()
            [People(id=1, name=小李_update, jgId=3), People(id=2, name=小张_update, jgId=2)]
            
            基本和select一样
            People(id=1, name=小李_update, jgId=3)
            
            调用每个元素的指定方法
            [People(id=1, name=小李_update_update, jgId=3), People(id=2, name=小张_update_update, jgId=2)]

*  即使慢也要驰而不息。
 *  为梦想追逐，随时可以上路。
 *  走上坡的时候要对别人好一点，因为你走下坡的时候会碰到他。
 *  宁愿失败地做你爱做的事情，也不要成功地做你恨做的事情。
 *  即使走的慢也决不后退。
 *  有人像家雀儿不愿意挪窝，有人像候鸟永远在路上。
 *  用自己的双脚在这土地上占据一个位置，无论是踩在泥泞里还是荆棘上。
 *  不说什么强强联手，不谈什么1+1> 2。
 *  不是为了已经改写的历史。
 *  更不是为了将要开创的未来。
 *  唯一值得庆祝的。
 *  不是纸上的两个签名，而是找到一个千杯少的知己。
 *  我才华横溢，前途光明，有着足以改变世界的想法。
 *  投资我一定是您最一本万利的投资，这是您当年说的。
 *  我的一切努力都是为了兑现它。
 *  贵人，就是那个我不想令他失望的人。
 *  不问初心，方得始终。