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

今天偶然间发现了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}]