Java8 Stream
    接口文档:
    filter是Java8 Stream的方法:

    1. Stream filter(Predicate<? super T> predicate)

    返回由与此给定谓词匹配的此流的元素组成的流。
    removeIf是Java8 Collecttion的一个默认方法。

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

    删除满足给定谓词的这个集合的所有元素。
    removeIffilter方法都能达到过滤/删除元素的作用。
    从功能是实现上,removeIf是条件为true则过滤此元素,false则保留。而filter则是条件为false过滤此元素,而true则保留。
    从时间上,要看场景,因为removeIf返回的是boolean,而filter是个intermediate operation,需要terminal operation最终来处理流,如果只是单单只做删除/过滤操作, removeIf会快些。
    示例:

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

    来看看源码实现:
    removeIfCollection接口的默认方法(Java8新增),底层实现是通过获得迭代器迭代每一个元素,满足条件的通过remove()方法删除,直到迭代完返回true,迭代完都没有满足条件的元素则返回false。如果是多个中间流参与,那么还是推荐使用filter方便。

    1. default boolean removeIf(Predicate<? super E> filter) {
    2. //判断是否为null
    3. Objects.requireNonNull(filter);
    4. boolean removed = false;
    5. final Iterator<E> each = iterator();
    6. while (each.hasNext()) {
    7. //迭代出现运行时异常或者错误由由Predicate被转发给调用者
    8. if (filter.test(each.next())) {
    9. //remove底层调用的是System.arraycopy方法,是个C++编写的native方法,操作的是指针,所有比较快
    10. each.remove();
    11. removed = true;
    12. }
    13. }
    14. return removed;
    15. }

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

    1. @Override
    2. public final Stream<P_OUT> filter(Predicate<? super P_OUT> predicate) {
    3. //判断是否为null
    4. Objects.requireNonNull(predicate);
    5. //将无状态的中间操作附加到现有流中来构造新流。StreamOpFlag.NOT_SIZED表示要清除的位值
    6. return new StatelessOp<P_OUT, P_OUT>(this, StreamShape.REFERENCE,
    7. StreamOpFlag.NOT_SIZED) {
    8. @Override
    9. Sink<P_OUT> opWrapSink(int flags, Sink<P_OUT> sink) {
    10. return new Sink.ChainedReference<P_OUT, P_OUT>(sink) {
    11. @Override
    12. public void begin(long size) {
    13. downstream.begin(-1);
    14. }
    15. @Override
    16. public void accept(P_OUT u) {
    17. if (predicate.test(u))
    18. downstream.accept(u);
    19. }
    20. };
    21. }
    22. };
    23. }
    24. //要清除的位值
    25. static final int NOT_SIZED = SIZED.clear;
    26. SIZED(3, set(Type.SPLITERATOR).set(Type.STREAM).clear(Type.OP)),