List.removeIf()：删除集合中满足给定条件的所有元素

谁借莪１个温暖的怀抱￠ 2023-09-30 15:03 36阅读 0赞

今天偶然间发现了Collection在1.8新增了一个removeIf(Predicate<? super E> filter)方法，能够实现面试官们常问的：如何一边遍历，一边删除。  
首先是源码

/**
         * Removes all of the elements of this collection that satisfy the given
         * predicate.  Errors or runtime exceptions thrown during iteration or by
         * the predicate are relayed to the caller.
         *
         * @implSpec
         * The default implementation traverses all elements of the collection using
         * its {@link #iterator}.  Each matching element is removed using
         * {@link Iterator#remove()}.  If the collection's iterator does not
         * support removal then an {@code UnsupportedOperationException} will be
         * thrown on the first matching element.
         *
         * @param filter a predicate which returns {@code true} for elements to be
         *        removed
         * @return {@code true} if any elements were removed
         * @throws NullPointerException if the specified filter is null
         * @throws UnsupportedOperationException if elements cannot be removed
         *         from this collection.  Implementations may throw this exception if a
         *         matching element cannot be removed or if, in general, removal is not
         *         supported.
         * @since 1.8
         */
    default boolean removeIf(Predicate<? super E> filter) {
        
            Objects.requireNonNull(filter);
            boolean removed = false;
            final Iterator<E> each = iterator();
            while (each.hasNext()) {
        
                if (filter.test(each.next())) {
        
                    each.remove();
                    removed = true;
                }
            }
            return removed;
        }

源码中注释很长，但是相信大家就能看出新增方法的作用了。**删除集合中满足给定条件的所有元素**  
接下来模拟需求是：**筛选掉所有没给我点赞的用户**  
上代码：

import java.util.*;
    import java.util.function.Predicate;
    
    public class Demo {
        
        Demo(){
        }
    
        class User{
        
            private int id;
            private String name;
            private boolean like;
            public User(){
        }
            public User(int id,String name,boolean like){
        
                this.id = id;
                this.name = name;
                this.like = like;
            }
    
            public int getId() {
        
                return id;
            }
    
            public void setId(int id) {
        
                this.id = id;
            }
    
            public String getName() {
        
                return name;
            }
    
            public void setName(String name) {
        
                this.name = name;
            }
    
            public boolean getLike() {
        
                return like;
            }
    
            public void setLike(boolean like) {
        
                this.like = like;
            }
    
            @Override
            public String toString(){
        
                return "User{" +
                        "id=" + id +
                        ", name='" + name + '\'' +
                        ", like=" + like +
                        '}';
            }
        }
    
        public static void main(String[] args) {
        
            Demo demo = new Demo();
            List<User> list = new ArrayList<>();
            list.add(demo.new User(1,"张三",true));
            list.add(demo.new User(2,"李四",false));
            list.add(demo.new User(3,"王五",true));
            list.add(demo.new User(4,"赵六",false));
            // 1.常规方式
           /* list.removeIf(new Predicate<User>(){
                @Override
                public boolean test(User user){
                    return false == user.getVip();
                }
            });*/
            // 2.使用lambda表达式(推荐)
            list.removeIf(user -> false == user.getLike());
            System.out.println(list.toString());
        }
    }

> \[User\{id=1, name=‘张三’, like=true\}, User\{id=3, name=‘王五’, like=true\}\]