it-swarm-eu.dev

Jaký je nejlepší způsob filtrování kolekce Java?

Chci filtrovat Java.util.Collection na základě predikátu.

624
Kevin Wong

Java 8 ( 2014 ) řeší tento problém pomocí streamů a lambdas v jednom řádku kódu:

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

Zde je tutorial .

Použijte Collection#removeIf k úpravě kolekce na místě. (Poznámka: V tomto případě predikát odstraní objekty, které splňují predikát):

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

lambdaj umožňuje filtrování sbírek bez psaní smyček nebo vnitřních tříd:

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

Dokážete si představit něco čitelnějšího?

Prohlášení: Jsem přispěvatel na lambdaj

621
Mario Fusco

Za předpokladu, že používáte Java 1.5 , a že nemůžete přidat Google Sbírky , udělal bych něco velmi podobného tomu, co dělali Google kluci. Toto je nepatrná variace na Jonových komentářích.

Nejprve přidejte toto rozhraní do své databáze kódů.

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

Její realizátoři mohou odpovědět, když určitý predikát platí pro určitý typ. Např. Pokud T bylo User a AuthorizedUserPredicate<User> implementuje IPredicate<T>, pak AuthorizedUserPredicate#apply vrací, zda je předaný soubor User autorizován.

Pak v nějaké užitné třídě, můžete říct

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

Tak, za předpokladu, že máte použití výše uvedených by mohlo být

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

Pokud se týká výkonu na lineární kontrole, pak bych chtěl mít objekt domény, který má cílovou kolekci. Objekt domény, který má cílovou kolekci, by měl mít filtrační logiku pro metody, které inicializují, přidávají a nastavují cílovou kolekci.

AKTUALIZACE:

Ve třídě nástrojů (řekněme Predikát) jsem přidal metodu select s možností pro výchozí hodnotu, když predikát nevrátí očekávanou hodnotu, a také statickou vlastnost pro parametry, které mají být použity v novém IPredikátu.

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

Následující příklad hledá chybějící objekty mezi kolekcemi:

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

Následující příklad vyhledá instanci v kolekci a vrátí první prvek kolekce jako výchozí hodnotu při nenalezení instance:

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

UPDATE (po vydání Java 8):

Je to již několik let, co jsem já (Alan) tuto odpověď poprvé poslal, a já stále nemůžu uvěřit, že sbírat SObody za tuto odpověď. V každém případě, nyní, když Java 8 zavedla zavření jazyka, bude moje odpověď nyní značně odlišná a jednodušší. S aplikací Java 8 není nutná samostatná třída statických nástrojů. Pokud tedy chcete najít první prvek, který odpovídá vašemu predikátu.

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

JDK 8 API pro volitelné doplňky má schopnost get(), isPresent(), orElse(defaultUser), orElseGet(userSupplier) a orElseThrow(exceptionSupplier), stejně jako další 'monadické' funkce jako map, flatMap a filter.

Pokud chcete jednoduše shromáždit všechny uživatele, kteří odpovídají predikátu, pak pomocí Collectors ukončete tok v požadované kolekci.

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

Viz zde pro více příkladů o tom, jak pracují Java 8 streamy.

218
Alan

Použít CollectionUtils.filter (Kolekce, Predikát) , z Apache Commons.

90
Kevin Wong

"Nejlepší" způsob je příliš široký požadavek. Je to "nejkratší"? "Nejrychlejší"? "Čitelný"? Filtrujte na místě nebo do jiné sbírky?

Nejjednodušší (ale ne čitelný) způsob je iterovat a používat metodu Iterator.remove ():

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

Nyní, aby bylo lépe čitelné, můžete ho zabalit do utility utility. Potom vytvořte rozhraní IPredicate, vytvořte anonymní implementaci tohoto rozhraní a proveďte něco jako:

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

kde filterInPlace () iteruje kolekci a zavolá Predicate.keepIt (), aby zjistil, zda instance, která má být uchovávána ve sbírce.

Ve skutečnosti nevidím důvod pro to, abych do této knihovny vložil knihovnu třetích stran.

65
Vladimir Dyuzhev

Zvažte Kolekce Google pro aktualizovaný rámec kolekcí, který podporuje generika.

UPDATE: Knihovna kolekcí Google je nyní zastaralá. Místo toho byste měli použít nejnovější verzi Guava . Má stále všechna stejná rozšíření pro rámec sbírek, včetně mechanismu pro filtrování na základě predikátu.

62
Heath Borders

Počkejte na 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());
25
gavenkoa

Hodím RxJava v ringu, který je také dostupný na Android . RxJava nemusí být vždy tou nejlepší volbou, ale dá vám větší flexibilitu, pokud si přejete přidat více transformací do vaší sbírky nebo zpracovat chyby při filtrování.

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

Výstup:

1
3
5

Více informací o filter RxJava lze nalézt zde .

11
anon

Od počátku vydání Java 8 můžete zkusit něco jako:

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

Pokud jste například měli seznam celých čísel a chtěli jste filtrovat čísla, která jsou> 10, a pak je vytisknout na konzolu, můžete něco udělat takto:

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

Opravdu chcete filtrovat samotnou sbírku, nikoli iterátor?

viz org.Apache.commons.collections.iterators.FilterIterator

nebo pomocí verze 4 Apache commons org.Apache.commons.collections4.iterators.FilterIterator

7
ykaganovich

Nastavení:

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

Použití:

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

A co nějaká prostá a přímočará Java

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

Jednoduché, čitelné a snadné (a funguje v Androidu!) Ale pokud používáte Java 8, můžete to udělat ve sladkém jednom řádku:

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

Všimněte si, že toList () je staticky importován

7

Podívejme se na to, jak filtrovat vestavěný seznam JDK a MutableList pomocí Eclipse Collection (dříve GS Collections ).

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

Pokud byste chtěli filtrovat čísla menší než 3, očekávali byste následující výstupy.

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

Zde je návod, jak můžete filtrovat pomocí anonymní vnitřní třídy jako 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));

Zde jsou některé alternativy k filtrování JDK seznamů a Eclipse Sbírky MutableLists pomocí Predikáty továrna.

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

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

Zde je verze, která nepřiděluje objekt pro predikát, místo toho pomocí metody Predicates2 factory namísto metody selectWith, která bere Predicate2.

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

Někdy chcete filtrovat na negativní stav. V kolekcích Eclipse existuje speciální metoda, která se nazývá reject.

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

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

Zde je návod, jak můžete filtrovat pomocí Java 8 lambda jako Predicate.

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

Metoda partition vrátí dvě kolekce obsahující prvky vybrané a odmítnuté Predicate.

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

Poznámka: Jsem příkazcem pro sbírky Eclipse.

6
Donald Raab
5
Kevin Wong

S ForEach DSL můžete psát

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

Daný sbírka [ rychlý, hnědý, liška, skoky, přes, líný, pes] toto vyústí v [rychlé, hnědé, skoky, přes, líný], tj. Všechny řetězce delší než tři charaktery.

Všechny iterační styly podporované ForEach DSL jsou

  • AllSatisfy
  • AnySatisfy
  • Collect
  • Counnt
  • CutPieces
  • Detect
  • GroupedBy
  • IndexOf
  • InjectInto
  • Reject
  • Select

Další podrobnosti naleznete na adrese https://www.iam.unibe.ch/scg/svn_repos/Sources/ForEach

5
akuhn

Protože Java 9 Collectors.filtering je povoleno:

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

Filtrování by tedy mělo být:

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

Příklad:

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

Toto, spolu s nedostatkem skutečných uzávěrů, je moje největší gripe pro Jávu. Upřímně řečeno, většina z výše uvedených metod je velmi snadno čitelná a opravdu efektivní; Nicméně, po strávení času s. Net, Erlang, atd ... seznam pochopení integrované na jazykové úrovni dělá všechno tak mnohem čistší. Bez dodatků na jazykové úrovni nemůže být Java v této oblasti tak čistá jako mnoho jiných jazyků.

Pokud je výkon obrovský zájem, Google sbírky je způsob, jak jít (nebo napsat svůj vlastní jednoduchý nástroj pro predikát). Lambdajská syntaxe je pro některé lidi srozumitelnější, ale není tak efektivní.

A pak je tu knihovna, kterou jsem napsal. Budu ignorovat jakékoli otázky, pokud jde o jeho efektivitu (ano, její špatné) ...... Ano, vím, že je to jasně založeno na úvahách, a ne, já to vlastně nepoužívám, ale funguje to:

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

NEBO

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

JFilter http://code.google.com/p/jfilter/ je pro váš požadavek nejvhodnější.

JFilter je jednoduchá a vysoce výkonná open source knihovna pro dotaz sběru fazolí Java.

Klíčové vlastnosti

  • Podpora vlastností kolekce (Java.util.Collection, Java.util.Map a Array).
  • Podpora sběru uvnitř sbírky jakékoli hloubky.
  • Podpora vnitřních dotazů.
  • Podpora parametrizovaných dotazů.
  • Lze filtrovat 1 milion záznamů za pár 100 ms.
  • Filtr (dotaz) je uveden v jednoduchém formátu json, jedná se o dotazy typu Mangodb. Následuje několik příkladů.
  • {"id": {"$ le": "10"}
    • kde vlastnost ID objektu je menší než 10.
  • {"id": {"$ in": ["0", "100"]}}
    • kde vlastnost id objektu je 0 nebo 100.
  • {"lineItems": {"lineAmount": "1"}}
    • kde vlastnost kolekce lineItems parametrizovaného typu má lineAmount roven 1.
  • {"$ a": [{"id": "0"}, {"billingAddress": {"city": "DEL"}}}
    • kde id vlastnost je 0 a vlastnost billingAddress.city je DEL.
  • {"lineItems": {"daně": {"key": {"code": "GST"}, "value": {"$ gt": "1.01"}}}}
    • kde vlastnost kolekce lineItems parametrizovaného typu, která má vlastnost typu mapy map typu parametiszed, má kód rovný hodnotě GST větší než 1,01.
  • {'$ nebo': [{'code': '10'}, {'skus': {'$ a': [{'price': {'$ in': ['20', '40']} }, {'code': 'RedApple'}]}}]}
    • Vyberte všechny produkty, kde je kód produktu 10 nebo cena sku v 20 a 40 a kód sku je "RedApple".
2
Kamran Ali Khan

Použít Sběrový dotazovací stroj (CQEngine) . Je to zdaleka nejrychlejší způsob, jak toho dosáhnout.

Viz také: Jak dotazujete objektové kolekce v jazyce Java (Kritéria/SQL)?

2
npgall

Napsal jsem rozšířená třída Iterable , která podporuje použití funkčních algoritmů bez kopírování obsahu kolekce.

Používání:

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

Výše uvedený kód bude skutečně vykonán

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

Pomocí Java 8, konkrétně lambda expression, můžete to udělat jednoduše jako v příkladu níže:

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

kde pro každou product uvnitř myProducts kolekce, pokud prod.price>10, přidejte tento produkt do nového filtrovaného seznamu.

1
hd84335

Potřeboval jsem filtrovat seznam v závislosti na hodnotách, které jsou již v seznamu. Například odeberte všechny následující hodnoty, které jsou menší než aktuální hodnota. {2 5 3 4 7 5} -> {2 5 7}. Nebo například pro odstranění všech duplikátů {3 5 4 2 3 5 6} -> {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;
    }
}

Takhle to bude použito.

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;
    }
});
1
Fredrik Metcalf

Moje odpověď staví na tom od Kevina Wonga, zde jako jeden liner používající CollectionUtils z spring a Java 8 lambda expression.

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

Toto je stručné a srozumitelné jako jakákoli alternativa, kterou jsem viděl (bez použití knihoven založených na aspektech)

Jaro CollectionUtils je k dispozici od jara verze 4.0.2.RELEASE a nezapomeňte, že potřebujete JDK 1.8 a jazykovou úroveň 8+.

1
vikingsteve

Jednoduché řešení pre-Java8:

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

Bohužel toto řešení není zcela obecné, výstupem je spíše seznam než typ dané kolekce. Také vnášení knihoven nebo psaní funkcí, které zabalují tento kód, mi připadá jako přehnané, pokud není podmínka složitá, ale pak můžete pro tuto podmínku napsat funkci.

1
Andrew McKnight

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

Podporuje různé možnosti,

Daný sběr,

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

typu,

class Dto
{
    private int id;
    private String text;

    public int getId()
    {
        return id;
    }

    public int getText()
    {
        return text;
    }
}

Filtr

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

Taky,

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

Třídění (dostupné i pro Java 7)

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

Seskupení (dostupné i pro Java 7)

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

Spojení (dostupné i pro Java 7)

Vzhledem k

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

Může být spojen jako,

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

Výrazy

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

S Guavou:

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
0
ZhekaKozlov

V jazyce Java 8 můžete přímo použít tuto metodu filtru a pak to provést.

 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); 
0
pramod_m