在Java中过滤集合中的元素的简单方法？

Question

我想编写一个方法，从集合中删除遵循特定模式的所有元素。在函数式语言中，我会将 filter() 与 lambda 表达式结合使用。然而，在Java中，我似乎陷入了困境：

public void removeAllBlueCars() {
    LinkedList<Car> carsToRemove = new LinkedList<Car>();
    for (Car c : cars) {
        if (c.getCarColor() == Color.BLUE) {
            carsToRemove.add(c);
        }
    }
    cars.removeAll(carsToRemove );
}

删除元素直接导致ConcurrentModificationException。有没有更好的方法可以在不借助 Google 收藏集的情况下实现此目的？

Answer 1

对于那些遇到这个线程并且可能正在使用 RxJava/RxAndroid 处理 Android 的人来说，有一种快速方法可以做到这一点，而无需添加 Apache Commons Collections 依赖项：

cars = Observable.from(cars).filter(car -> {
  if (car.getCarColor() == Color.BLUE) {
    return false;
  }

  return true;
}).toList().toBlocking().first();

请注意，我也碰巧在 Retrolambda。如果您不使用 Retrolambda，您可以使用以下内容表达相同的内容：

cars = Observable.from(cars).filter(new Func1<Car, Boolean>() {
      @Override
      public Boolean call(Car car) {
        if (car.getCarColor() == Color.BLUE) {
          return false;
        }

        return true;
      }
}).toList().toBlocking().first();

Answer 2

随着Java8引入lambda表达式，实现过滤变得更加容易以更实用的方式构建集合。

我给你写了一个例子。另请注意使用 forEach 打印 Collection 内容是多么的好：

public class Java8Filtering {

    public static void main(String[] argc) {
        LinkedList<Car> cars = new LinkedList<>();
        cars.add(new Car("car 1", Color.BLUE));
        cars.add(new Car("car 2", Color.GREEN));
        cars.add(new Car("car 3", Color.RED));
        cars.add(new Car("car 4", Color.BLUE));

        List<Car> filteredCars = cars.stream()
                .filter(car -> car.getCarColor() != Color.BLUE)
                .collect(Collectors.toList());

        filteredCars.forEach(car -> System.out.println("Car: " + car.getCarName() + " with color: " + car.getCarColor()));
    }
}

class Car {

    private Color carColor;
    private String carName;

    public Car(String carName, Color carColor) {
        this.carName = carName;
        this.carColor = carColor;
    }

    public Color getCarColor() {
        return carColor;
    }

    public void setCarColor(Color carColor) {
        this.carColor = carColor;
    }

    public String getCarName() {
        return carName;
    }

    public void setCarName(String carName) {
        this.carName = carName;
    }
}

enum Color {
    BLUE, GREEN, RED
}

Answer 3

public static <T> void filter(List<T> list, Predicate<? super T> removeIf) {
    if(list == null) return;

    Iterator<T> iterator = list.iterator();
    while (iterator.hasNext()) {
        if (removeIf.apply(iterator.next())) iterator.remove();
    }
}

将某种泛型类型的列表传递给此函数，并使用谓词删除不需要的元素。

Answer 4

这确实是一篇旧文章，但是如何使用 Oracle Java 教程中给出的方法。

static void filter(Collection<?>c) {
    for (Iterator<?>it = c.iterator(); it.hasNext(); )
         if (!cond(it.next()))
             it.remove();
}

Answer 5

我非常喜欢 Vivien Barousse 和 gpeche 提供的迭代器解决方案。但我想指出的是，您不必实际从集合中删除任何元素，只需防止过滤器返回它们即可。这样，您基本上就可以拥有同一集合的多个视图，这非常方便和高效。 Filter 对象基本上是您的 lamda 表达式，或者与 Java 版本 7 之前的最接近的表达式...

Answer 6

您总是可以向后退并删除元素。

    for (int i = array.size() - 1; i >= 0; i--) {
       if (array.get(i).getCarColor() == Color.BLUE)
                array.remove(i);
    }

编辑：注意到它是一个 LinkedList，这可能使我的答案有点不相关。

Answer 7

了解 lambdaj 的过滤选项是否可以为您提供帮助。

Answer 8

以下是 Android 实现通用解决方案的方法：

用法：

从我的列表中删除所有空字符串

    LinkedList<String> list = ...
    ListUtils.filter(list, new ListUtils.Filter<String>() {
        @Override
        public boolean keepItem(String item) {
            return item != null;
        }
    });

来源：

public class ListUtils {
    public interface Filter<T>{
        boolean keepItem(T item);
    }

    public static <T> void filter(@NonNull List<T> items, @NonNull Filter<T> filter) {
        for (Iterator<T> iterator = items.iterator(); iterator.hasNext();){
            if(!filter.keepItem(iterator.next())){
                iterator.remove();
            }
        }
    }
}

Answer 9

您可以使用 CollectionUtils.filter()。它与Iterator配合使用，因此直接从Collection中删除项目应该没有问题。但这是另一种依赖。如果你想要独立的代码，那就是：

public interface Predicate {
    boolean evaluate(Object o);
}

public static void filter(Collection collection, Predicate predicate) {
if ((collection != null) && (predicate != null))
    for (Iterator it = collection.iterator(); it.hasNext(); )
        if (!predicate.evaluate(it.next()))
            it.remove();
}
...
filter(collection, new Predicate() {
    public boolean evaluate(Object o) { return whatever; }
});

Answer 10

您可以使用 ListIterator，它有一个 删除 方法。

顺便说一句，您应该将列表声明为 List - 接口程序，而不是实现程序。

Answer 11

也许你可以使用迭代器，它的效率更高一些：

public void removeAllBlueCars() {
    Iterator<Car> carsIterator = cars.iterator();
    while (carsIterator.hasNext()) {
        Car c = carsIterator.next();
        if (c.getCarColor() == Color.BLUE) {
            carsIterator.remove();
        }
    }
}

---

另外，如果你想让这个解决方案更通用，我建议你这样做：

public interface Filter<T> {

    public boolean shouldRemove(T t);

}

你可以这样使用它：

public void removeCars(Filter<Car> filter) {
    Iterator<Car> carsIterator = cars.iterator();
    while (carsIterator.hasNext()) {
        Car c = carsIterator.next();
        if (filter.shouldRemove(c)) {
            carsIterator.remove();
        }
    }
}

你的方法被这样调用：

removeCars(new Filter<Car>() {

    public boolean shouldRemove(Car car) {
        return car.getCarColor() == Color.BLUE;
    }

});

Answer 12

使用 Java 8，您可以使用 Collection.removeIf。

cars.removeIf(c -> c.getCarColor() == Color.BLUE);