Moyen facile de filtrer les éléments d'une collection en Java?

Je veux écrire une méthode qui supprime tous les éléments d'une collection qui suivent un certain rythme. Dans les langages fonctionnels, je voudrais utiliser filtre() avec une expression lambda. Toutefois, en Java, il semble que je suis coincé avec ce:

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

La suppression des éléments de la cause directe d'une ConcurrentModificationException. Est-il une meilleure façon de le faire sans recourir à Google Collections?

Et vous ne voulez pas utiliser google collections pourquoi? BTW, code.google.com/p/guava-libraries est le nouveau google collections...
J'aime Google Collections/Goyave, cependant ma question était justement de ne trouver comment faire cela sans avoir recours à des bibliothèques.
Je me suis amusé ou perturbés par cette notion que lourdement testé et massivement utilisé les bibliothèques sont des choses que nous "le recours à", sans doute en larmes moment de faiblesse. 🙂
Je pense qu'il veut "BAISER".

InformationsquelleAutor Frederik | 2010-09-07

collections java

13

Vous pourriez parcourir la liste à l'aide d'un ListIterator, qui a un supprimer méthode.

Btw, vous devez déclarer votre liste List<Car> - programme pour les interfaces, pas de mise en œuvre.
- Iterator a déjà un remove méthode.
- correct. À première lecture rapide, j'ai perçu que ListIterator.remove offre des garanties supplémentaires sur l'interface de base de la méthode, mais à la deuxième case, je vois que j'ai mal compris. Si vous êtes de droite, un Iterator suffirait.
InformationsquelleAutor Péter Török
16

Avec Java 8, vous pourrez filtrer avec une lambda expression à l'aide de de la Collection.removeIf.
```
cars.removeIf(c -> c.getCarColor() == Color.BLUE);
```
InformationsquelleAutor Jeffrey Bosboom

Vous pourriez peut-être utiliser des itérateurs, qui sont un peu plus efficace:

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

Aussi, si vous souhaitez rendre cette solution plus générique, je vous suggère quelque chose comme:

public interface Filter<T> {

    public boolean shouldRemove(T t);

}

Et vous pouvez l'utiliser comme ceci:

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

Votre méthode est appelée comme ceci:

removeCars(new Filter<Car>() {

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

});

Belle façon si vous ne souhaitez pas utiliser google collections ou lmbadaj

InformationsquelleAutor Vivien Barousse

Vous pouvez utiliser CollectionUtils.filtre(). Il fonctionne avec une Iterator, donc il devrait pas avoir de problèmes de supprimer des éléments directement à partir de la Collection. C'est une autre dépendance bien. Si vous voulez le code autonome, il serait:

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; }
});

InformationsquelleAutor gpeche

3

Voir si lambdajs'option de filtre peut vous aider.

InformationsquelleAutor Alberto Zaccagni
2

Vous pouvez toujours revenir en arrière et supprimer les éléments..
```
    for (int i = array.size() - 1; i >= 0; i--) {
       if (array.get(i).getCarColor() == Color.BLUE)
                array.remove(i);
    }
```
edit: Remarqué qu'il était un LinkedList qui pourrait rendre ma réponse un peu non pertinents.
- Non, Une linkedlist peut avoir des indices et n'importe quoi. votre solution est correcte et court
- mais sa performance est terrible pour les grandes listes de O(n^2).
- Ah ouais, maintenant, je remarque qu'il est O(n^2) parce que la méthode remove prend une autre O(n), et la boucle est O(n) déjà.
- C'était ce que je pensais. 🙂 C'est (n2) pour les deux LinkedLists et ArrayLists, mais si vous voulez juste à court, facile à lire le code, cela pourrait être un "bon" choix.
- À l'aide de l'itérateur semble que la bonne chose à faire sans avoir recours à des bibliothèques. Merci!
InformationsquelleAutor Marcus Johansson
2

Je suis un grand fan de l'Itérateur solution fournie par Vivien Barousse et gpeche. Mais je tenais à préciser que vous n'avez pas à supprimer des éléments de la collection, vous avez juste besoin d'éviter que le filtre de retour. De cette façon, en gros, vous avez plusieurs vues de la même collection, qui peut être très pratique et efficace. L'objet de Filtre est en fait votre lamda expression, ou aussi près que vous allez obtenir en Java jusqu'à la version 7...

InformationsquelleAutor romacafe

C'est vraiment un vieux post mais comment abt à l'aide de la façon donnée dans Oracle Java tutoriel.

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

InformationsquelleAutor Popinjoy

Ici est le Android manière de mettre en œuvre une solution générique pour cette:

Utilisation:

Supprimer toutes les chaînes vides de ma liste

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

Source:

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();
            }
        }
    }
}

InformationsquelleAutor Ilya Gazman

Avec Java8 l'introduction de les expressions lambda, il est beaucoup plus facile à mettre en œuvre le filtrage sur une collection dans une approche plus fonctionnelle.

J'ai écrit un exemple pour vous. Veuillez également noter comment le plus agréable c'est d'imprimer au contenu de la Collection en utilisant forEach:

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
}

InformationsquelleAutor Johnny

0

Pour ceux d'entre vous qui viennent à travers ce fil et peut-être travailler sur Android avec RxJava/RxAndroid, il existe un moyen rapide de le faire sans l'ajout de l'Apache Commons Collections de dépendance:
```
cars = Observable.from(cars).filter(car -> {
if (car.getCarColor() == Color.BLUE) {
return false;
}
return true;
}).toList().toBlocking().first();
```
Noter que j'ai aussi arriver à être en utilisant les expressions lambda avec Retrolambda. Si vous n'utilisez pas Retrolambda, vous pouvez exprimer la même chose en utilisant les éléments suivants:
```
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();
```
InformationsquelleAutor jwir3

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();
}
}

Passer d'une liste de certains de type générique de cette fonction avec un prédicat pour supprimer les éléments indésirables.

InformationsquelleAutor Brandon Bahret

Vous devez vous connecter pour publier un commentaire.