Quelle est la meilleure façon de filtrer une collection Java ?

https://stackoverflow.com/questions/122105

02-07-2019
|

Question

Je veux filtrer un java.util.Collection basé sur un prédicat.

La solution

Java8 (2014) résout ce problème en utilisant des streams et des lambdas dans une seule ligne de code :

List<Person> beerDrinkers = persons.stream()
    .filter(p -> p.getAge() > 16).collect(Collectors.toList());

Voici un Didacticiel.

Utiliser Collection#removeIf pour modifier la collection en place.(Avis:Dans ce cas, le prédicat supprimera les objets qui satisfont au prédicat) :

persons.removeIf(p -> p.getAge() <= 16);

lambdaj permet de filtrer les collections sans écrire de boucles ou de classes internes :

List<Person> beerDrinkers = select(persons, having(on(Person.class).getAge(),
    greaterThan(16)));

Pouvez-vous imaginer quelque chose de plus lisible ?

Clause de non-responsabilité: Je suis un contributeur sur lambdaj

Autres conseils

En supposant que vous utilisez Java 1.5 , et que vous ne pouvez pas ajouter Collections Google , je ferais quelque chose de très similaire à ce que les gars de Google ont fait . C'est une légère variation des commentaires de Jon.

Ajoutez d'abord cette interface à votre base de code.

public interface IPredicate<T> { boolean apply(T type); }

Ses implémenteurs peuvent répondre lorsqu'un prédicat donné est vrai d'un certain type. Par exemple. Si T était User et que AuthorizedUserPredicate<User> implémentait IPredicate<T>, alors AuthorizedUserPredicate#apply indique si le contenu de get() est autorisé.

Ensuite, dans une classe d'utilitaires, vous pourriez dire

public static <T> Collection<T> filter(Collection<T> target, IPredicate<T> predicate) {
    Collection<T> result = new ArrayList<T>();
    for (T element: target) {
        if (predicate.apply(element)) {
            result.add(element);
        }
    }
    return result;
}

Donc, en supposant que vous utilisiez ce qui précède pourrait être

Predicate<User> isAuthorized = new Predicate<User>() {
    public boolean apply(User user) {
        // binds a boolean method in User to a reference
        return user.isAuthorized();
    }
};
// allUsers is a Collection<User>
Collection<User> authorizedUsers = filter(allUsers, isAuthorized);

Si les performances de la vérification linéaire sont un sujet de préoccupation, je souhaiterais peut-être avoir un objet de domaine contenant la collection cible. L'objet de domaine qui a la collection cible aurait une logique de filtrage pour les méthodes qui initialisent, ajoutent et définissent la collection cible.

MISE À JOUR:

Dans la classe utilitaire (disons Predicate), j'ai ajouté une méthode de sélection avec une option pour la valeur par défaut lorsque le prédicat ne renvoie pas la valeur attendue, ainsi qu'une propriété statique pour les paramètres à utiliser dans le nouvel IPredicate. .

public class Predicate {
    public static Object predicateParams;

    public static <T> Collection<T> filter(Collection<T> target, IPredicate<T> predicate) {
        Collection<T> result = new ArrayList<T>();
        for (T element : target) {
            if (predicate.apply(element)) {
                result.add(element);
            }
        }
        return result;
    }

    public static <T> T select(Collection<T> target, IPredicate<T> predicate) {
        T result = null;
        for (T element : target) {
            if (!predicate.apply(element))
                continue;
            result = element;
            break;
        }
        return result;
    }

    public static <T> T select(Collection<T> target, IPredicate<T> predicate, T defaultValue) {
        T result = defaultValue;
        for (T element : target) {
            if (!predicate.apply(element))
                continue;
            result = element;
            break;
        }
        return result;
    }
}

L'exemple suivant recherche les objets manquants entre les collections:

List<MyTypeA> missingObjects = (List<MyTypeA>) Predicate.filter(myCollectionOfA,
    new IPredicate<MyTypeA>() {
        public boolean apply(MyTypeA objectOfA) {
            Predicate.predicateParams = objectOfA.getName();
            return Predicate.select(myCollectionB, new IPredicate<MyTypeB>() {
                public boolean apply(MyTypeB objectOfB) {
                    return objectOfB.getName().equals(Predicate.predicateParams.toString());
                }
            }) == null;
        }
    });

L'exemple suivant recherche une instance dans une collection et renvoie le premier élément de la collection comme valeur par défaut lorsque l'instance est introuvable:

MyType myObject = Predicate.select(collectionOfMyType, new IPredicate<MyType>() {
public boolean apply(MyType objectOfMyType) {
    return objectOfMyType.isDefault();
}}, collectionOfMyType.get(0));

UPDATE (après la publication de Java 8):

Cela fait plusieurs années que j'ai (Alan) posté pour la première fois cette réponse, et je ne peux toujours pas croire que je collectionne SO points pour cette réponse. Quoi qu'il en soit, maintenant que Java 8 a introduit des fermetures de langage, ma réponse serait maintenant considérablement différente et plus simple. Avec Java 8, une classe d’utilitaires statiques distincte n’est plus nécessaire. Donc, si vous voulez trouver le 1er élément qui correspond à votre prédicat.

final UserService userService = ... // perhaps injected IoC
final Optional<UserModel> userOption = userCollection.stream().filter(u -> {
    boolean isAuthorized = userService.isAuthorized(u);
    return isAuthorized;
}).findFirst();

L'API JDK 8 pour les options a la capacité de isPresent(), orElse(defaultUser), orElseGet(userSupplier), orElseThrow(exceptionSupplier), map et flatMap, ainsi que d'autres fonctions "monadiques" telles que filter, Collectors et <=>.

Si vous souhaitez simplement collecter tous les utilisateurs qui correspondent au prédicat, utilisez <<> pour mettre fin au flux de la collection souhaitée.

final UserService userService = ... // perhaps injected IoC
final List<UserModel> userOption = userCollection.stream().filter(u -> {
    boolean isAuthorized = userService.isAuthorized(u);
    return isAuthorized;
}).collect(Collectors.toList());

Voir ici pour plus d'exemples sur la manière Les flux Java 8 fonctionnent.

Utilisez CollectionUtils.filter (Collection, Predicate) , dans Apache Commons.

& "Meilleur &"; manière est une demande trop large. Est-ce & "Le plus court &"; " Le plus rapide " " lisible " Filtrer à la place ou dans une autre collection?

La méthode la plus simple (mais pas la plus lisible) consiste à la parcourir et à utiliser la méthode Iterator.remove ():

Iterator<Foo> it = col.iterator();
while( it.hasNext() ) {
  Foo foo = it.next();
  if( !condition(foo) ) it.remove();
}

Maintenant, pour le rendre plus lisible, vous pouvez l’envelopper dans une méthode utilitaire. Puis inventez une interface IPredicate, créez une implémentation anonyme de cette interface et faites quelque chose comme:

CollectionUtils.filterInPlace(col,
  new IPredicate<Foo>(){
    public boolean keepIt(Foo foo) {
      return foo.isBar();
    }
  });

où filterInPlace () itère la collection et appelle Predicate.keepIt () pour savoir si l'instance doit être conservée dans la collection.

Je ne vois pas vraiment de raison d'introduire une bibliothèque tierce uniquement pour cette tâche.

Envisagez de Collections Google pour un cadre de collections mis à jour prenant en charge les génériques.

UPDATE : la bibliothèque de collections Google est désormais obsolète. Vous devez utiliser la dernière version de Goyaut . Il a toujours toutes les mêmes extensions au cadre des collections, y compris un mécanisme de filtrage basé sur un prédicat.

Attendez Java 8:

List<Person> olderThan30 = 
  //Create a Stream from the personList
  personList.stream().
  //filter the element to select only those with age >= 30
  filter(p -> p.age >= 30).
  //put those filtered elements into a new List.
  collect(Collectors.toList());

Depuis la première version de Java 8, vous pouvez essayer quelque chose comme:

Collection<T> collection = ...;
Stream<T> stream = collection.stream().filter(...);

Par exemple, si vous aviez une liste d'entiers et que vous vouliez filtrer les nombres qui sont > 10 puis imprimez ces numéros sur la console, vous pouvez faire quelque chose comme:

List<Integer> numbers = Arrays.asList(12, 74, 5, 8, 16);
numbers.stream().filter(n -> n > 10).forEach(System.out::println);

Je jetterai RxJava dans l'anneau, qui est également disponible sur Android . RxJava n'est peut-être pas toujours la meilleure option, mais cela vous donnera plus de flexibilité si vous souhaitez ajouter davantage de transformations à votre collection ou gérer les erreurs lors du filtrage.

Observable.from(Arrays.asList(1, 2, 3, 4, 5))
    .filter(new Func1<Integer, Boolean>() {
        public Boolean call(Integer i) {
            return i % 2 != 0;
        }
    })
    .subscribe(new Action1<Integer>() {
        public void call(Integer i) {
            System.out.println(i);
        }
    });

Sortie:

1
3
5

Plus de détails sur filter de RxJava peuvent être trouvés ici .

La configuration:

public interface Predicate<T> {
  public boolean filter(T t);
}

void filterCollection(Collection<T> col, Predicate<T> predicate) {
  for (Iterator i = col.iterator(); i.hasNext();) {
    T obj = i.next();
    if (predicate.filter(obj)) {
      i.remove();
    }
  }
}

L'utilisation:

List<MyObject> myList = ...;
filterCollection(myList, new Predicate<MyObject>() {
  public boolean filter(MyObject obj) {
    return obj.shouldFilter();
  }
});

Que diriez-vous d'un langage Java simple et direct

 List<Customer> list ...;
 List<Customer> newList = new ArrayList<>();
 for (Customer c : list){
    if (c.getName().equals("dd")) newList.add(c);
 }

Simple, lisible et facile (et fonctionne sous Android!) Mais si vous utilisez Java 8, vous pouvez le faire en une ligne:

List<Customer> newList = list.stream().filter(c -> c.getName().equals("dd")).collect(toList());

Notez que toList () est importé de manière statique

Êtes-vous sûr de vouloir filtrer la collection elle-même plutôt qu'un itérateur?

voir org.apache.commons.collections.iterators.FilterIterator

ou en utilisant la version 4 d’apache commons org.apache.commons.collections4.iterators.FilterIterator

Laissons & # 8217; s regarder comment filtrer une liste JDK intégrée et une MutableList avec Eclipse Collections (anciennement Collections GS ).

List<Integer> jdkList = Arrays.asList(1, 2, 3, 4, 5);
MutableList<Integer> ecList = Lists.mutable.with(1, 2, 3, 4, 5);

Si vous souhaitez filtrer les nombres inférieurs à 3, attendez-vous les résultats suivants.

List<Integer> selected = Lists.mutable.with(1, 2);
List<Integer> rejected = Lists.mutable.with(3, 4, 5);

Voici & # 8217; comment filtrer en utilisant une classe interne anonyme en tant que Predicate.

Predicate<Integer> lessThan3 = new Predicate<Integer>()
{
    public boolean accept(Integer each)
    {
        return each < 3;
    }
};

Assert.assertEquals(selected, Iterate.select(jdkList, lessThan3));

Assert.assertEquals(selected, ecList.select(lessThan3));

Voici quelques solutions de rechange au filtrage des listes JDK et des collections Eclipse MutableLists utilisant le Prédicte à l'usine.

Assert.assertEquals(selected, Iterate.select(jdkList, Predicates.lessThan(3)));

Assert.assertEquals(selected, ecList.select(Predicates.lessThan(3)));

Voici une version qui n'alloue pas d'objet pour le prédicat en utilisant Predicates2 à la place avec la méthode selectWith qui utilise un Predicate2.

Assert.assertEquals(
    selected, ecList.selectWith(Predicates2.<Integer>lessThan(), 3));

Parfois, vous souhaitez filtrer sur une condition négative. Il existe une méthode spéciale dans les collections Eclipse pour celle appelée reject.

Assert.assertEquals(rejected, Iterate.reject(jdkList, lessThan3));

Assert.assertEquals(rejected, ecList.reject(lessThan3));

Voici & # 8217; comment filtrer en utilisant un lambda Java 8 en tant que partition.

Assert.assertEquals(selected, Iterate.select(jdkList, each -> each < 3));
Assert.assertEquals(rejected, Iterate.reject(jdkList, each -> each < 3));

Assert.assertEquals(selected, gscList.select(each -> each < 3));
Assert.assertEquals(rejected, gscList.reject(each -> each < 3));

La méthode <=> renverra deux collections contenant les éléments sélectionnés et rejetés par <=>.

PartitionIterable<Integer> jdkPartitioned = Iterate.partition(jdkList, lessThan3);
Assert.assertEquals(selected, jdkPartitioned.getSelected());
Assert.assertEquals(rejected, jdkPartitioned.getRejected());

PartitionList<Integer> ecPartitioned = gscList.partition(lessThan3);
Assert.assertEquals(selected, ecPartitioned.getSelected());
Assert.assertEquals(rejected, ecPartitioned.getRejected());

Remarque: je suis un partisan des collections Eclipse.

Avec le ForEach DSL, vous pouvez écrire

import static ch.akuhn.util.query.Query.select;
import static ch.akuhn.util.query.Query.$result;
import ch.akuhn.util.query.Select;

Collection<String> collection = ...

for (Select<String> each : select(collection)) {
    each.yield = each.value.length() > 3;
}

Collection<String> result = $result();

Avec une collection de [The, quick, brown, renard, sauts, over, the, paresseux, chien], il en résulte [quick, brown, sauts, over, paresseux], c'est-à-dire toutes les chaînes plus longues que trois caractères.

Tous les styles d'itération pris en charge par DSL ForEach sont

AllSatisfy
AnySatisfy
Collect
Counnt
CutPieces
Detect
GroupedBy
IndexOf
InjectInto
Reject
Select

Pour plus de détails, veuillez vous reporter à https: //www.iam.unibe. .ch / scg / svn_repos / Sources / ForEach

Le Collections2.filter (Collection, Predicate) dans la méthode La bibliothèque Google de Google de Google fait exactement ce que vous cherchez.

Étant donné que Java 9 Collectors.filtering est activé:

public static <T, A, R>
    Collector<T, ?, R> filtering(Predicate<? super T> predicate,
                                 Collector<? super T, A, R> downstream)

Le filtrage devrait donc être:

collection.stream().collect(Collectors.filtering(predicate, collector))

Exemple:

List<Integer> oddNumbers = List.of(1, 19, 15, 10, -10).stream()
            .collect(Collectors.filtering(i -> i % 2 == 1, Collectors.toList()));

Ceci, combiné au manque de véritables fermetures, est mon plus grand reproche pour Java. Honnêtement, la plupart des méthodes mentionnées ci-dessus sont assez faciles à lire et vraiment efficaces; Cependant, après avoir passé du temps avec .Net, Erlang, etc., la compréhension de la liste intégrée au niveau de la langue rend le tout beaucoup plus propre. Sans ajouts au niveau de la langue, Java ne peut tout simplement pas être aussi propre que de nombreuses autres langues de ce domaine.

Si les performances sont une préoccupation majeure, les collections Google sont la solution (ou écrivez votre propre utilitaire de prédicat simple). La syntaxe Lambdaj est plus lisible pour certaines personnes, mais elle n’est pas aussi efficace.

Et puis il y a une bibliothèque que j'ai écrite. J'ignorerai toutes les questions concernant son efficacité (oui, c'est si mauvais) ...... Oui, je sais qu'il est clairement basé sur la réflexion, et non, je ne l'utilise pas réellement, mais cela fonctionne:

LinkedList<Person> list = ......
LinkedList<Person> filtered = 
           Query.from(list).where(Condition.ensure("age", Op.GTE, 21));

LinkedList<Person> list = ....
LinkedList<Person> filtered = Query.from(list).where("x => x.age >= 21");

JFiltre http://code.google.com/p/jfilter/ est le mieux adapté à vos besoins.

JFilter est une bibliothèque open source simple et haute performance pour interroger la collection de beans Java.

Principales caractéristiques

Prise en charge des propriétés de collection (java.util.Collection, java.util.Map et Array).
Prise en charge de la collection à l’intérieur d’une collection de n’importe quelle profondeur.
Prise en charge des requêtes internes.
Prise en charge des requêtes paramétrées.
Peut filtrer 1 million d'enregistrements en quelques 100 ms.
Le filtre (requête) est donné au format json simple, c'est comme les requêtes Mangodb.Voici quelques exemples.
{ "id":{"$le":"10"}
- où la propriété id de l'objet est inférieure à 10.
{ "identifiant":{"$in":["0", "100"]}}
- où la propriété id de l'objet est 0 ou 100.
{"lineItems":{"lineAmount":"1"}}
- où la propriété de collection lineItems de type paramétré a lineAmount égal à 1.
{ "$et":[{"id":"0"}, {"billingAddress":{"city":"DEL"}}]}
- où la propriété id est 0 et la propriété billingAddress.city est DEL.
{"lineItems":{"taxes":{ "key":{"code":"GST"}, "value":{"$gt":"1.01"}}}}
- où la propriété de collection lineItems de type paramétré qui a une propriété de type de carte de taxes de type paramétré a un code égal à une valeur de TPS supérieure à 1,01.
{'$or':[{'code':'10'},{'skus' :{'$and':[{'price':{'$in':['20', '40']}}, {'code':'RedApple'}]}}]}
- Sélectionnez tous les produits dont le code produit est 10 ou le prix sku en 20 et 40 et le code sku est « RedApple ».

J'ai écrit une classe Iterable étendue prenant en charge l’application d’algorithmes fonctionnels sans copier le contenu de la collection.

Utilisation:

List<Integer> myList = new ArrayList<Integer>(){ 1, 2, 3, 4, 5 }

Iterable<Integer> filtered = Iterable.wrap(myList).select(new Predicate1<Integer>()
{
    public Boolean call(Integer n) throws FunctionalException
    {
        return n % 2 == 0;
    }
})

for( int n : filtered )
{
    System.out.println(n);
}

Le code ci-dessus sera effectivement exécuté

for( int n : myList )
{
    if( n % 2 == 0 ) 
    {
        System.out.println(n);
    }
}

Utilisez le moteur de recherche de collection (CQEngine) . C’est de loin le moyen le plus rapide de le faire.

Voir aussi: Comment interroger des collections d'objets en Java (de type Critère / SQL)?

Quelques très bonnes réponses ici. Moi, j'aimerais que les choses restent aussi simples et lisibles que possible:

public abstract class AbstractFilter<T> {

    /**
     * Method that returns whether an item is to be included or not.
     * @param item an item from the given collection.
     * @return true if this item is to be included in the collection, false in case it has to be removed.
     */
    protected abstract boolean excludeItem(T item);

    public void filter(Collection<T> collection) {
        if (CollectionUtils.isNotEmpty(collection)) {
            Iterator<T> iterator = collection.iterator();
            while (iterator.hasNext()) {
                if (excludeItem(iterator.next())) {
                    iterator.remove();
                }
            }
        }
    }
}

La solution simple pré-Java8:

ArrayList<Item> filtered = new ArrayList<Item>(); 
for (Item item : items) if (condition(item)) filtered.add(item);

Malheureusement, cette solution n'est pas totalement générique, elle génère une liste plutôt que le type de la collection donnée. De plus, importer des bibliothèques ou écrire des fonctions qui encapsulent ce code me parait excessif à moins que la condition ne soit complexe, mais vous pouvez alors écrire une fonction pour la condition.

https://code.google.com/p/joquery/

prend en charge différentes possibilités,

Collection donnée,

Collection<Dto> testList = new ArrayList<>();

de type,

class Dto
{
    private int id;
    private String text;

    public int getId()
    {
        return id;
    }

    public int getText()
    {
        return text;
    }
}

Filtre

Java 7

Filter<Dto> query = CQ.<Dto>filter(testList)
    .where()
    .property("id").eq().value(1);
Collection<Dto> filtered = query.list();

Java 8

Filter<Dto> query = CQ.<Dto>filter(testList)
    .where()
    .property(Dto::getId)
    .eq().value(1);
Collection<Dto> filtered = query.list();

En outre,

Filter<Dto> query = CQ.<Dto>filter()
        .from(testList)
        .where()
        .property(Dto::getId).between().value(1).value(2)
        .and()
        .property(Dto::grtText).in().value(new string[]{"a","b"});

Tri (également disponible pour Java 7)

Filter<Dto> query = CQ.<Dto>filter(testList)
        .orderBy()
        .property(Dto::getId)
        .property(Dto::getName)
    Collection<Dto> sorted = query.list();

Regroupement (également disponible pour Java 7)

GroupQuery<Integer,Dto> query = CQ.<Dto,Dto>query(testList)
        .group()
        .groupBy(Dto::getId)
    Collection<Grouping<Integer,Dto>> grouped = query.list();

Jointures (également disponible pour Java 7)

Donné,

class LeftDto
{
    private int id;
    private String text;

    public int getId()
    {
        return id;
    }

    public int getText()
    {
        return text;
    }
}

class RightDto
{
    private int id;
    private int leftId;
    private String text;

    public int getId()
    {
        return id;
    }

    public int getLeftId()
        {
            return leftId;
        }

    public int getText()
    {
        return text;
    }
}

class JoinedDto
{
    private int leftId;
    private int rightId;
    private String text;

    public JoinedDto(int leftId,int rightId,String text)
    {
        this.leftId = leftId;
        this.rightId = rightId;
        this.text = text;
    }

    public int getLeftId()
    {
        return leftId;
    }

    public int getRightId()
        {
            return rightId;
        }

    public int getText()
    {
        return text;
    }
}

Collection<LeftDto> leftList = new ArrayList<>();

Collection<RightDto> rightList = new ArrayList<>();

Peut être rejoint comme,

Collection<JoinedDto> results = CQ.<LeftDto, LeftDto>query().from(leftList)
                .<RightDto, JoinedDto>innerJoin(CQ.<RightDto, RightDto>query().from(rightList))
                .on(LeftFyo::getId, RightDto::getLeftId)
                .transformDirect(selection ->  new JoinedDto(selection.getLeft().getText()
                                                     , selection.getLeft().getId()
                                                     , selection.getRight().getId())
                                 )
                .list();

Expressions

Filter<Dto> query = CQ.<Dto>filter()
    .from(testList)
    .where()
    .exec(s -> s.getId() + 1).eq().value(2);

Ma réponse s’appuie sur celle de Kevin Wong, présentée ici sous la forme d’une ligne unique utilisant CollectionUtils de spring et d’une expression Java 8 lambda .

CollectionUtils.filter(list, p -> ((Person) p).getAge() > 16);

C’est aussi concis et lisible que toutes les alternatives que j’ai déjà vues (sans utiliser de bibliothèques basées sur les aspects)

Printemps CollectionUtils est disponible à partir de la version de printemps 4.0.2.RELEASE. N'oubliez pas que vous avez besoin de JDK 1.8 et du niveau de langue 8 +.

En utilisant java 8, plus précisément lambda expression, vous pouvez le faire simplement comme dans l'exemple ci-dessous:

myProducts.stream().filter(prod -> prod.price>10).collect(Collectors.toList())

où pour chaque product collection myProducts, si prod.price>10, ajoutez ce produit à la nouvelle liste filtrée.

Je devais filtrer une liste en fonction des valeurs déjà présentes dans la liste. Par exemple, supprimez toutes les valeurs suivantes qui sont inférieures à la valeur actuelle. {2 5 3 4 7 5} - & Gt; {2 5 7}. Ou par exemple, pour supprimer tous les doublons {3 5 4 2 3 5 6} - & Gt; {3 5 4 2 6}.

public class Filter {
    public static <T> void List(List<T> list, Chooser<T> chooser) {
        List<Integer> toBeRemoved = new ArrayList<>();
        leftloop:
        for (int right = 1; right < list.size(); ++right) {
            for (int left = 0; left < right; ++left) {
                if (toBeRemoved.contains(left)) {
                    continue;
                }
                Keep keep = chooser.choose(list.get(left), list.get(right));
                switch (keep) {
                    case LEFT:
                        toBeRemoved.add(right);
                        continue leftloop;
                    case RIGHT:
                        toBeRemoved.add(left);
                        break;
                    case NONE:
                        toBeRemoved.add(left);
                        toBeRemoved.add(right);
                        continue leftloop;
                }
            }
        }

        Collections.sort(toBeRemoved, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });

        for (int i : toBeRemoved) {
            if (i >= 0 && i < list.size()) {
                list.remove(i);
            }
        }
    }

    public static <T> void List(List<T> list, Keeper<T> keeper) {
        Iterator<T> iterator = list.iterator();
        while (iterator.hasNext()) {
            if (!keeper.keep(iterator.next())) {
                iterator.remove();
            }
        }
    }

    public interface Keeper<E> {
        boolean keep(E obj);
    }

    public interface Chooser<E> {
        Keep choose(E left, E right);
    }

    public enum Keep {
        LEFT, RIGHT, BOTH, NONE;
    }
}

Ceci sera utilisé comme ceci.

List<String> names = new ArrayList<>();
names.add("Anders");
names.add("Stefan");
names.add("Anders");
Filter.List(names, new Filter.Chooser<String>() {
    @Override
    public Filter.Keep choose(String left, String right) {
        return left.equals(right) ? Filter.Keep.LEFT : Filter.Keep.BOTH;
    }
});

Avec la goyave:

Collection<Integer> collection = Lists.newArrayList(1, 2, 3, 4, 5);

Iterators.removeIf(collection.iterator(), new Predicate<Integer>() {
    @Override
    public boolean apply(Integer i) {
        return i % 2 == 0;
    }
});

System.out.println(collection); // Prints 1, 3, 5

Sous Java 8, vous pouvez directement utiliser cette méthode de filtrage, puis le faire.

 List<String> lines = Arrays.asList("java", "pramod", "example");

 List<String> result = lines.stream()              
         .filter(line -> !"pramod".equals(line))     
         .collect(Collectors.toList());              

 result.forEach(System.out::println);

Licencié sous: CC-BY-SA avec attribution

Non affilié à StackOverflow