关于java:Java-8-数据过滤removeIf-和-filter-别用错了

filter 是 Java8 Stream 的办法：

Stream filter(Predicate<? super T> predicate)

返回由与此给定谓词匹配的此流的元素组成的流。

removeIf 是 Java8 Collecttion 的一个默认办法。

default boolean removeIf(Predicate<? super E> filter)

删除满足给定谓词的这个汇合的所有元素。

removeIf 和 filter 办法都能达到过滤 / 删除元素的作用。

从性能是实现上，removeIf 是条件为 true 则过滤此元素，false 则保留。而 filter 则是条件为 false 过滤此元素，而 true 则保留。

从工夫上，要看场景，因为 removeIf 返回的是 boolean，而 filter 是个 intermediate operation，须要terminal operation 最终来解决流，如果只是单单只做删除 / 过滤操作，removeIf 会快些。

示例：

public static void main(String[] args) {List list = new ArrayList(Arrays.asList(1,2,3,4,5));
        long last = System.currentTimeMillis();
        list.removeIf(a -> a.equals(2));
        System.out.println(System.currentTimeMillis() - last);//37~38
    }
public static void main(String[] args) {List list = new ArrayList(Arrays.asList(1,2,3,4,5));
        long last = System.currentTimeMillis();
        list.stream().filter(a -> !a.equals(2)).collect(Collectors.toList());
        System.out.println(System.currentTimeMillis() - last);//41~44
    }

来看看源码实现：

removeIf 是 Collection 接口的默认办法（Java8 新增），底层实现是通过取得迭代器迭代每一个元素，满足条件的通过 remove() 办法删除，直到迭代完返回 true，迭代完都没有满足条件的元素则返回 false。如果是多个两头流参加，那么还是举荐应用 filter 不便。

default boolean removeIf(Predicate<? super E> filter) {
  // 判断是否为 null
        Objects.requireNonNull(filter);
        boolean removed = false;
        final Iterator<E> each = iterator();
        while (each.hasNext()) {
         // 迭代呈现运行时异样或者谬误由由 Predicate 被转发给调用者
            if (filter.test(each.next())) {
             //remove 底层调用的是 System.arraycopy 办法，是个 C ++ 编写的 native 办法，操作的是指针，所有比拟快
                each.remove();
                removed = true;
            }
        }
        return removed;
    }

每次 filter 都产生一个新的 StatelessOp，也就新的流，通过 opWrapSink 一直匹配条件，当为 false 时则标记此流元素可过滤

 @Override
    public final Stream<P_OUT> filter(Predicate<? super P_OUT> predicate) {
     // 判断是否为 null
        Objects.requireNonNull(predicate);
        // 将无状态的两头操作附加到现有流中来结构新流。StreamOpFlag.NOT_SIZED 示意要革除的位值
        return new StatelessOp<P_OUT, P_OUT>(this, StreamShape.REFERENCE,
                                     StreamOpFlag.NOT_SIZED) {
            @Override
            Sink<P_OUT> opWrapSink(int flags, Sink<P_OUT> sink) {return new Sink.ChainedReference<P_OUT, P_OUT>(sink) {
                    @Override
                    public void begin(long size) {downstream.begin(-1);
                    }

                    @Override
                    public void accept(P_OUT u) {if (predicate.test(u))
                            downstream.accept(u);
                    }
                };
            }
        };
    }
// 要革除的位值
static final int NOT_SIZED = SIZED.clear;

SIZED(3,
          set(Type.SPLITERATOR).set(Type.STREAM).clear(Type.OP)),

起源：blog.csdn.net/Butterfly_resting/article/details/100045181

近期热文举荐：

1.1,000+ 道 Java 面试题及答案整顿(2021 最新版)

2. 别在再满屏的 if/ else 了，试试策略模式，真香！！

3. 卧槽！Java 中的 xx ≠ null 是什么新语法？

4.Spring Boot 2.5 重磅公布，光明模式太炸了！

5.《Java 开发手册（嵩山版）》最新公布，速速下载！

感觉不错，别忘了顺手点赞 + 转发哦！