Wat is die beste manier om 'n Java-versameling te filter?

https://stackoverflow.com/questions/122105

02-07-2019
|

Vra

Ek wil filter a java.util.Collection gebaseer op 'n predikaat.

Oplossing

Java 8 (2014) los hierdie probleem op deur strome en lambdas in een reël kode op te los:

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

Hier is 'n tutoriaal.

Gebruik Collection#removeIf om die versameling in plek te verander.(Kennisgewing:In hierdie geval sal die predikaat voorwerpe verwyder wat aan die predikaat voldoen):

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

lambdaj laat filterversamelings toe sonder om lusse of binneklasse te skryf:

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

Kan jy jou iets meer leesbaar voorstel?

Vrywaring: Ek is 'n bydraer op lambdaj

Ander wenke

As ons aanneem dat jy met behulp van Java 1.5 , en dat jy kan nie voeg Google versamelings , sou ek iets baie soortgelyk doen met wat die Google ouens het . Dit is 'n effense variasie op kommentaar Jon se.

voeg Eerste hierdie koppelvlak om jou kodebasis.

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

Die implementeerders kan beantwoord wanneer 'n sekere gesegde is waar van 'n sekere tipe. Bv As T was User en AuthorizedUserPredicate<User> implemente IPredicate<T>, dan AuthorizedUserPredicate#apply opbrengste of die geslaag in User gemagtig.

Toe ek in 'n paar nut klas, kan jy sê

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

So, in die veronderstelling dat jy die gebruik van die bogenoemde mag wees

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

As prestasie op die lineêre tjek is van kommer, dan het ek dalk 'n domein voorwerp wat die teiken versameling het nie. Die domein voorwerp wat die teiken versameling het sou hê filter logika vir die metodes wat inisialiseer, voeg en stel die teiken versameling.

UPDATE:

In die nut klas (kom ons sê Predikaat), het ek 'n uitgesoekte metode bygevoeg met 'n opsie vir verstek waarde wanneer die gesegde nie die verwagte waarde 'n statiese eiendom nie terugkeer nie, en ook vir params om gebruik te word in die nuwe 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;
    }
}

Die volgende voorbeeld lyk vir vermiste voorwerpe tussen versamelings:

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

Die volgende voorbeeld, kyk vir 'n geval in 'n versameling, en gee die eerste element van die versameling as verstek waarde wanneer die geval is nie gevind nie:

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

UPDATE (na Java 8 release):

Dit was 'n paar jaar sedert ek (Alan) eerste hierdie antwoord gepos, en ek kan steeds nie glo ek invordering SO punte vir hierdie antwoord. In elk geval, nou dat Java 8 sluitings om die taal ingestel, my antwoord sou nou wees aansienlik verskillende, en eenvoudiger. Met Java 8, daar is geen behoefte aan 'n duidelike statiese nut klas. So as jy wil hê dat die 1ste element wat ooreenstem met jou predikaat vind.

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

Die JDK 8 API vir-opsies het die vermoë om get(), isPresent(), orElse(defaultUser), orElseGet(userSupplier) en orElseThrow(exceptionSupplier), sowel as ander 'monad ische test' funksies soos map, flatMap en filter.

As jy wil net versamel al die gebruikers wat ooreenstem met die gesegde, gebruik dan die Collectors om die stroom te beëindig in die gewenste versameling.

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

hier vir meer voorbeelde van hoe Java 8 strome werk.

Gebruik CollectionUtils.filter (Collection, Predikaat) , vanaf Apache Commons.

"Beste" manier is te wyd 'n versoek. Is dit "kortste"? "Vinnigste"? "Leesbaar"? Filter in plaas of in 'n ander versameling?

Eenvoudigste (maar nie die meeste leesbare) manier is om dit te herhaal en gebruik Iterator.remove () metode:

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

Nou, om dit meer leesbaar te maak, kan jy dit draai in 'n nut metode. bedink dan 'n IPredicate koppelvlak, skep 'n anonieme implementering van daardie koppelvlak en iets soos te doen:

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

waar filterInPlace () herhaal die versameling en doen 'n beroep Predicate.keepIt () om te leer as die geval in die versameling gehou moet word.

Ek het nie regtig sien 'n regverdiging vir die totstandkoming van 'n derde party biblioteek net vir hierdie taak.

Oorweeg Google Versamelings vir 'n updated Versamelings raamwerk wat generiese ondersteun.

UPDATE : Die Google versamelings biblioteek is nou afgekeur. Jy moet die nuutste weergawe van Koejawel plaas gebruik. Dit het nog almal dieselfde uitbreidings aan die versamelings raamwerk, insluitend 'n meganisme vir die filter gebaseer op 'n gesegde.

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

Sedert die vroeë vrylating van Java 8, kon jy so iets probeer:

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

Byvoorbeeld, as jy het 'n lys van heelgetalle en jy wil die getalle wat> 10 filtreer en dan druk die nommers op die konsole, jy kan iets soos te doen:

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

Ek sal gooi RxJava in die ring, wat beskikbaar is ook op Android . RxJava dalk nie altyd die beste opsie wees, maar dit sal jou meer buigsaamheid gee as jy wil voeg meer transformasies op jou versameling of hanteer foute terwyl filter.

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

Uitgawe:

1
3
5

Meer besonderhede oor filter RxJava se kan gevind word hier .

Die opstel:

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

Die gebruik:

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

Hoe gaan dit met 'n paar eenvoudige en straighforward Java

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

Eenvoudige, leesbare en maklik (en werke in Android!) Maar as jy die gebruik van Java 8 kan jy dit doen in 'n soet een lyn:

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

Let daarop dat toList () staties is ingevoer

Is jy seker jy wil die versameling self filter, eerder as om 'n iterator?

sien org.apache.commons.collections.iterators.FilterIterator

of met behulp van weergawe 4 van apache Commons org.apache.commons.collections4.iterators.FilterIterator

Kom ons kyk na hoe om te filtreer 'n ingeboude in JDK Lys en 'n MutableList behulp Eclipse versamelings (voorheen GS versamelings ).

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

As jy wil om te filter die getalle minder as 3, sal jy verwag dat die volgende uitsette.

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

Hier is hoe jy kan filter met behulp van 'n anonieme innerlike klas as die 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));

Hier is 'n paar alternatiewe vir filtrering JDK lyste en Eclipse Versamelings MutableLists met behulp van die gezegdes fabriek.

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

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

Hier is 'n weergawe wat nie 'n voorwerp vir die gesegde toewys, deur gebruik te maak van die Predicates2 fabriek plaas met die selectWith metode wat 'n Predicate2 neem.

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

Soms wil jy om te filter op 'n negatiewe toestand. Daar is 'n spesiale metode in Eclipse versamelings vir wat genoem reject.

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

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

Hier is hoe jy kan filter met behulp van 'n Java 8 lambda as die 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));

Die metode partition sal terugkeer twee versamelings, wat die elemente gekies deur en verwerp word deur die 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());

Let wel:. Ek is 'n committer vir Eclipse versamelings

Met die foreach DSL jy kan skryf

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

Gegewe 'n versameling van [Die, vinnige, bruin, jakkals, spring, oor, die, lui, hond] dit lei tot [vinnig, bruin, spring, oor, lui], dit wil sê alle stringe langer as drie karakters.

Alle iterasie style deur die foreach DSL is

AllSatisfy
AnySatisfy
Collect
Counnt
CutPieces
Detect
GroupedBy
IndexOf
InjectInto
Reject
Select

Vir meer besonderhede, verwys asseblief na https: //www.iam.unibe ch / SCG / svn_repos / Bronne / foreach

Die Collections2.filter (Collection, Predikaat) metode in Google se Koejawel biblioteek doen net wat jy soek.

Sedert java 9 Collectors.filtering geaktiveer is:

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

So filter moet wees:

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

Voorbeeld:

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

Dit, tesame met die gebrek aan werklike sluitings, is my grootste gripe vir Java. Eerlik, die meeste van die bogenoemde metodes is redelik maklik om te lees en regtig doeltreffend; egter na die tyd spandeer met Net, Erlang, ens ... lys begrip geïntegreer by die taalvlak maak alles soveel skoner. Sonder toevoegings by die taalvlak, Java net so skoon as baie ander tale in hierdie gebied kan nie wees nie.

As prestasie is 'n groot bekommernis, Google versamelings is die pad om te gaan (of skryf jou eie eenvoudige gesegde nut). Lambdaj sintaksis is meer leesbaar vir sommige mense, maar dit is nie heeltemal so doeltreffend te maak.

En dan is daar 'n biblioteek wat ek geskryf het.

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

JFilter http://code.google.com/p/jfilter/ is die beste geskik vir jou vereiste.

JFilter is 'n eenvoudige en 'n hoë prestasie open source biblioteek by versameling navraag van Java bone.

Belangrike kenmerke

Ondersteuning van versameling (java.util.Collection, java.util.Map en Array) eienskappe.
Ondersteuning van versameling binnekant versameling van enige diepte.
Ondersteuning van innerlike navrae.
Ondersteuning van parameters navrae.
Kan filter 1000000 rekords in 'n paar 100 ms.
Filter (query) word in eenvoudige JSON-formaat, is dit soos Mangodb navrae. Hier volg 'n paar voorbeelde.
{ "id": { "$ le": "10"}
- waar id voorwerp eiendom is minder as gelyk aan 10.
{ "id": { "$ in": [ "0", "100"]}}
- waar id voorwerp eiendom is 0 of 100.
{ "lineItems": { "lineAmount": "1"}}
- waar lineItems versameling eiendom van parameters tipe het lineAmount gelyk aan 1.
{ "$ en": [{ "id": "0"}, { "Rekening Adres": { "stad": "DEL"}}]}
- waar id eiendom is 0 en billingAddress.city eiendom is DEL.
{ "lineItems": { "belasting": { "sleutel": { "kode": "GST"}, "waarde": { "$ gt": "1.01"}}}}
- waar lineItems versameling eiendom van parameters tipe wat belastings kaart tipe eiendom het van parameteriszed tipe het kode gelyk aan GST waarde groter as 1.01.
{ '$ of': [{ "kode": "10"}, { "SKU": { "$ en ': [{" prys ": {" $ in': [ '20', '40 ']}}, { "kode":' RedApple '}]}}]}
- Kies al die produkte waar die produk kode is 10 of sku prys in 20 en 40 en sku kode is "RedApple".

Ek het 'n uitgebreide Iterable klas wat ondersteun die toepassing van funksionele algoritmes sonder die kopiëring van die versameling inhoud.

Gebruik:

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

Die kode hierbo sal eintlik voer

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

Versameling Query Engine (CQEngine) . Dit is by verre die vinnigste manier om dit te doen.

Sien ook:? Hoe doen jy navraag voorwerp versamelings in Java (Kriteria / SQL-agtige)

Sommige werklik 'n groot groot antwoorde hier. My, ek hou daarvan om dinge so eenvoudig en leesbare te hou as moontlik:

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

Die eenvoudige pre-Java8 oplossing:

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

Ongelukkig hierdie oplossing is nie ten volle generiese, uitdruk n lys plaas van die tipe van die gegewe versameling. Ook, bring in biblioteke of skriftelik funksies wat hierdie kode draai lyk soos overkill vir my nie, tensy die toestand is kompleks, maar dan kan jy 'n funksie vir die toestand te skryf.

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

Ondersteun verskillende moontlikhede,

Gegewe versameling,

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

van tipe,

class Dto
{
    private int id;
    private String text;

    public int getId()
    {
        return id;
    }

    public int getText()
    {
        return text;
    }
}

Filter

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

Ook,

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

Sortering (ook beskikbaar vir die Java 7)

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

Groepering (ook beskikbaar vir die Java 7)

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

Bundelt (ook beskikbaar vir die Java 7)

Gegewe,

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

Kan geword soos,

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

My antwoord bou voort op wat van Kevin Wong, hier as 'n one-liner met behulp van CollectionUtils van lente en 'n Java 8 lambda uitdrukking.

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

Dit is so bondig en leesbaar as enige alternatiewe ek gesien het (sonder die gebruik van-aspek gebaseer biblioteke)

Spring CollectionUtils beskikbaar vanaf lente weergawe 4.0.2.RELEASE is, en onthou wat jy nodig het JDK 1.8 en taalvlak 8 +.

Die gebruik van java 8, spesifiek lambda expression, jy kan dit doen net soos die voorbeeld hieronder:

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

waar vir elke product binne myProducts versameling, indien prod.price>10, en voeg dan die produk na die nuwe gefiltreer lys.

Ek benodig 'n lys te filtreer, afhangende van die waardes wat reeds teenwoordig in die lys. Byvoorbeeld, verwyder alle waardes volgende wat minder as die huidige waarde. {2 5 3 4 7 5} -> {2 5 7}. Of byvoorbeeld al duplikate verwyder {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;
    }
}

Dit word SEB gebruik soos hierdie.

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

Met Koejawel:

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

In Java 8, Jy kan direk hierdie filter metode gebruik en dan dit te doen.

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

Gelisensieer onder: CC-BY-SA met toeskrywing

Nie verbonde aan StackOverflow