Kas yra geriausias būdas filtruoti „Java“ kolekciją?

Noriu filtruoti java.util.Collection pagal predikatą.

596
23 сент. nustatė Kevinas Wongas rugsėjo 23 d 2008-09-23 19:26 '08, 19:26 pm 2008-09-23 19:26
@ 27 atsakymai

„Java 8“ ( 2014 ) šią problemą išsprendžia naudodama srautus ir lambdas vienoje kodo eilutėje:

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

Čia yra pamoka .

Naudokite Collection#removeIf norite pakeisti rinkinį. (Pastaba: šiuo atveju predikatas ištrins predikato reikalavimus atitinkančius objektus):

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

lambdaj leidžia filtruoti kolekcijas be kilpų ar vidinių klasių:

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

Ar galite įsivaizduoti kažką aiškesnį?

Atsakomybės apribojimas: aš esu lambdaj autorius

586
06 сент. Mario Fusco atsakymas 06 Sep 2009-09-06 16:37 '09 at 16:37 2009-09-06 16:37

Darant prielaidą, kad naudojate „ Java 1.5“ ir kad negalite pridėti „ Google“ kolekcijų , norėčiau padaryti kažką labai panašaus į tai, ką padarė „Google“ vaikinai. Tai yra nedidelis Johno komentarų pakeitimas.

Pirmiausia pridėkite šią sąsają prie kodo bazės.

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

Jos kūrėjai gali atsakyti, kai konkretus predikatas yra teisingas. Pavyzdžiui. Jei „ T buvo „ User ir „ AuthorizedUserPredicate<User> įgyvendinamas „ IPredicate<T> , tada „ AuthorizedUserPredicate#apply jei leidžiama perduoti User .

Tada galite pasakyti tam tikroje naudingumo klasėje

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

Taigi, darant prielaidą, kad naudojate pirmiau minėtą, galbū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); 

Jei linijinio tikrinimo našumas kelia susirūpinimą, galbūt norėčiau turėti domeno objektą, turintį tikslinę kolekciją. Domeno objektas, turintis tikslinę kolekciją, turės filtravimo logiką metodams, kurie inicijuoja, prideda ir įdiegia tikslinę kolekciją.

UPDATE:

Naudingumo klasėje (tarkim, „Predicate“) pridėjau pasirinkimo metodą su galimybe numatytai reikšmei, kai predikatas negrąžina tikėtinos vertės, taip pat statinio turto parametrams, kurie bus naudojami naujojo IPredicate viduje.

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

Šis pavyzdys apima trūkstamus objektus tarp kolekcijų:

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

Toliau pateiktas pavyzdys ieško pavyzdžio kolekcijoje ir grąžina pirmąjį kolekcijos elementą kaip numatytąjį, kai pavyzdys nerastas:

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

UPDATE (po „Java 8“ išleidimo):

Praėjus keleriems metams nuo to laiko, kai aš (Alanas) pirmą kartą paskelbiau šį atsakymą, ir aš vis dar negaliu patikėti, kad surinksiu tašką už šį atsakymą. Bet kuriuo atveju, dabar, kai „Java 8“ įvedė kalbos uždarymą, mano atsakymas dabar bus labai skirtingas ir paprastesnis. Naudojant „Java 8“, nereikia atskiros statinės naudingumo klasės. Todėl, jei norite rasti pirmąjį elementą, kuris atitinka jūsų predikatą.

 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 parinktims suteikiama galimybė get() , isPresent() , orElse(defaultUser) , orElseGet(userSupplier) ir orElseThrow(exceptionSupplier) , taip pat kitas „monadines“ funkcijas, pvz., flatMap , flatMap ir filter .

Jei norite surinkti visus vartotojus, atitinkančius predikatą, naudokite Collectors norėdami užbaigti srautą norimoje kolekcijoje.

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

Čia rasite daugiau pavyzdžių, kaip veikia „Java 8“ siūlai.

218
23 сент. atsakymas pateikiamas Alan 23 sep. 2008-09-23 19:41 '08 at 7:41 pm 2008-09-23 19:41

Naudokite „Apache Commons“ „ CollectionUtils.filter“ (rinkinys, rinkinys) .

89
23 сент. Kevino Wong atsakymas, rugsėjo 23 d 2008-09-23 19:28 '08, 19:28, 2008-09-23 19:28

Apsvarstykite „ Google“ kolekcijas atnaujinamai surinkimo struktūrai, kuri palaiko bendrus failus.

UPDATE . „Google“ kolekcijos biblioteka dabar pasenusi. Vietoj to turėtumėte naudoti naujausią Guava versiją. Jis vis dar turi tą patį rinkimo struktūros išplėtimą, įskaitant predikato filtravimo mechanizmą.

62
23 сент. Heath Borders atsakymas, pateiktas rugsėjo 23 d 2008-09-23 19:29 '08 at 7:29 pm 2008-09-23 19:29

„Geriausias“ būdas yra per platus prašymas. Ar tai trumpiausias? „Greičiausias“? „Skaityta“? Filtruoti vietoje arba kitoje kolekcijoje?

Paprasčiausias (bet ne labiausiai skaitomas) metodas yra pakartoti ir naudoti Iterator.remove () metodą:

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

Dabar, kad ją būtų lengviau skaityti, galite apvynioti jį naudingumo metodu. Tada sugalvokite IPredicate sąsają, sukurkite anoniminį šios sąsajos įgyvendinimą ir atlikite kažką panašaus:

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

kur filterInPlace () pakartoja kolekciją ir skambina „Predicate.keepIt“ (), kad sužinotų, ar egzempliorius turi būti saugomas kolekcijoje.

Aš tikrai nematau jokio pasiteisinimo pareikšti trečiosios šalies biblioteką tik šiai užduočiai.

62
23 сент. Atsakymą pateikė Vladimir Dyuzhev 23 sep . 2008-09-23 19:41 '08 at 7:41 pm 2008-09-23 19:41

Palaukite „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
29 авг. atsakymas duotas gavenkoa 29 rug . 2013-08-29 13:50 '13, 13:50, 2013-08-29 13:50

Aš mesti RxJava į žiedą, kuris taip pat yra „ Android“ . RxJava ne visada gali būti geriausias variantas, tačiau jis suteiks jums daugiau lankstumo, jei norite pridėti daugiau kolekcijos pakeitimų ar tvarkyti filtravimo klaidas.

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

Išvada:

 1 3 5 

Daugiau informacijos apie filter RxJava rasite čia .

11
24 июля '14 в 5:13 2014-07-24 05:13 atsakymas pateikiamas anonimiškai, liepos 24 d., 14 d., 05:13 2014-07-24 05:13

Nuo ankstyvo „Java 8“ išleidimo galite pabandyti kažką panašaus:

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

Pvz., Jei turite sveikų skaičių sąrašą ir norite filtruoti numerius, kurie yra> 10, ir tada spausdinti šiuos numerius konsolėje, galite padaryti kažką panašaus:

 List<Integer> numbers = Arrays.asList(12, 74, 5, 8, 16); numbers.stream().filter(n -> n > 10).forEach(System.out::println); 
11
28 окт. Josh M spalio 28 d. atsakymas . 2013-10-28 00:41 '13 prie 0:41 2013-10-28 00:41

Sąranka:

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

Naudoti:

 List<MyObject> myList = ...; filterCollection(myList, new Predicate<MyObject>() { public boolean filter(MyObject obj) { return obj.shouldFilter(); } }); 
7
23 сент. atsakymas pateikiamas jon 23 Sep. 2008-09-23 19:41 '08 at 7:41 pm 2008-09-23 19:41

Kaip apie kažką paprasto ir paslėpto java

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

Paprasta, suprantama ir paprasta (ir veikia „Android“!) Tačiau, jei naudojate „Java 8“, galite tai padaryti saldžioje vienoje eilutėje:

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

Atkreipkite dėmesį, kad toList () yra statiškai importuotas

7
12 мая '14 в 8:03 2014-05-12 08:03 atsakymą pateikė Nestoras Hernandezas Loli , gegužės 12 d. 14 d. 8:03 2014-05-12 08:03

Ar tikrai norite filtruoti savo kolekciją, o ne iteratorių?

žr. org.apache.commons.collections.iterators.FilterIterator

arba naudojant 4 apache commons org.apache.commons.collections4.iterators.FilterIterator versiją

7
23 сент. Atsakymas, kurį pateikė ykaganovich Sep 23 2008-09-23 19:41 '08 at 7:41 pm 2008-09-23 19:41

Pažiūrėkime, kaip filtruoti integruotą JDK ir MutableList sąrašą naudojant „ Eclipse Collection“ (anksčiau GS kolekcija ).

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

Jei norite filtruoti mažiau nei 3 numerius, galite tikėtis šių rezultatų.

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

Štai kaip galite filtruoti naudojant anoniminę vidinę klasę, pvz., „ 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)); 

Štai keletas alternatyvų JDK sąrašų ir „ Eclipse MutableLists“ rinkinių filtravimui naudojant „ Predicate“ gamyklą.

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

Čia yra versija, kuri neišskiria objekto predikatui, naudodama „ Predicate2“ gamyklą, naudodama „ selectWith , kuri priima „ Predicate2 .

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

Kartais norite filtruoti neigiamą būseną. „Eclipse“ kolekcijose yra specialus metodas, vadinamas reject .

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

Štai kaip galite filtruoti naudojant lambda java 8, pavyzdžiui, 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)); 

partition metodas grąžins dvi kolekcijas, kuriose yra elementų, kuriuos pasirinko ir atmetė „ 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()); 

Pastaba Aš esu „Eclipse“ kolekcijų pardavėjas.

6
25 сент. Atsakymas duotas Donaldui Raabui 25 sep. 2012-09-25 01:28 '12 at 1:28 2012-09-25 01:28

Su „ForEach“ DSL galite rašyti

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

Dėl šios kolekcijos [Greitas, rudas, lapė, šokinėjimas, per, tingus, šuo] atsiranda [greitas, rudas, šokinėjimas, per, tingus], ty visos eilutės, ilgesnės nei trys simboliai.

Visi iteracijos stiliai, palaikomi „ForEach DSL“,

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

Daugiau informacijos rasite https://www.iam.unibe.ch/scg/svn_repos/Sources/ForEach

5
03 дек. atsakymą pateikė akuhn 03 dec. 2008-12-03 16:45 '08 at 4:45 pm 2008-12-03 16:45
5
23 сент. Kevino Wong atsakymas, rugsėjo 23 d 2008-09-23 21:21 '08, 9:21 val. 2008-09-23 21:21

Nuo java 9 Collectors.filtering įtrauktas:

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

Taigi filtravimas turėtų būti:

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

Pavyzdys:

 List<Integer> oddNumbers = List.of(1, 19, 15, 10, -10).stream() .collect(Collectors.filtering(i -> i % 2 == 1, Collectors.toList())); 
3
24 мая '18 в 16:59 2018-05-24 16:59 atsakymą pateikė fbokovikovas, gegužės 24 d., 18 val., 18:59, 2018-05-24 16:59

Tai, kartu su tikrųjų uždarymo stoka, yra didžiausia „Java“ problema. Tiesą sakant, dauguma pirmiau minėtų metodų yra gana lengvai skaitomi ir tikrai veiksmingi; tačiau, praleidžiant laiką su .Net, Er>

Jei našumas yra didžiulis, „Google“ kolekcijos yra būdas eiti (arba parašyti savo paprastą predikato įrankį). „Lambdaj“ sintaksė kai kuriems žmonėms yra lengviau skaitoma, bet ne tokia veiksminga.

Ir tada yra biblioteka, kurią parašiau. Aš ignoruosiu visus klausimus apie jo veiksmingumą (taip, tai yra blogai) ...... Taip, žinau, kad tai aiškiai atspindi pagrindą, ir ne, aš iš tikrųjų nenaudojau, bet ji veikia:

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

Or

 LinkedList<Person> list = .... LinkedList<Person> filtered = Query.from(list).where("x => x.age >= 21"); 
3
21 янв. atsakymas duotas jdc0589 21 sausis 2010-01-21 07:35 '10, 7:35, 2010-01-21 07:35

JFilter http://code.google.com/p/jfilter/ geriausiai tinka jūsų reikalavimui.

JFilter yra paprasta ir efektyvi atvirojo kodo biblioteka, skirta Java pupelių kolekcijai.

Pagrindinės funkcijos

  • Parama rinkimo savybėms (java.util.Collection, java.util.Map ir Array).
  • Kolekcijos palaikymas bet kokio gylio rinkinyje.
  • Palaikykite vidines užklausas.
  • Parama parametruojamoms užklausoms.
  • Per kelias minutes jis gali filtruoti 1 mln. Įrašų.
  • Filtras (užklausa) nustatytas paprastu „json“ formatu, panašus į „Mangodb“ užklausas. Toliau pateikiami keli pavyzdžiai.
  • {"id": {"$ le": "10"}
    • kur objekto savybė yra mažesnė nei 10.
  • {"id": {"$ į": ["0", "100"]}}
    • kur objekto savybės yra 0 arba 100.
  • {"lineItems": {"lineAmount": "1"}}
    • kur parametrų tipo kolekcijaItems savybė yra lineAmount yra 1.
  • {"$ ir": [{"id": "0"}, {"billingAddress": {"city": "DEL"}}]}
    • kur ID yra 0, o atsiskaitymo adresai.city yra DEL.
  • {"lineItems": {"tax": {"key": {"code": "GST"}, "value": {"$ gt": "1.01"}}}}
    • kur parametrų tipo kolekcijaItems, turinti parametrų tipą turinčio mokesčio žemėlapio tipo savybės, turi kodą, lygų GST vertei, didesnei nei 1,01.
  • {'$ arba': [{'kodas': '10'), {'skus': {'$ ir': [{'kaina': {'$ į': ['20', '40')} }, {'code': 'RedApple'}]}}]}
    • Pasirinkite visus produktus, kurių produkto kodas yra 10 arba sku 20 ir 40, ir sku kodas yra „RedApple“.
2
05 апр. atsakymą pateikė Kamran Ali Khan, balandžio 5 d 2012-04-05 13:46 '12, 13:46, 2012-04-05 13:46

Čia yra keletas tikrai puikių atsakymų. Aš norėčiau juos padaryti kuo paprastesnius ir aiškesnius:

 public abstract class AbstractFilter<T> {  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(); } } } } } 
2
07 янв. Atsakymą pateikė Lawrence Jan 07 2015-01-07 14:07 '15 - 14:07 2015-01-07 14:07

Naudokite surinkimo užklausos mechanizmą (CQEngine) . Tai yra greičiausias būdas tai padaryti.

Taip pat žiūrėkite: Kaip paklausiate „Java“ objektų rinkinių (kriterijų / SQL)?

2
30 июля '12 в 1:12 2012-07-30 01:12 atsakymas pateikiamas npgall liepos 30 d., 12 val., 12:12 2012-07-30 01:12

Parašiau išplėstinę Iterable klasę , kuri palaiko funkcinių algoritmų naudojimą nekopijuojant kolekcijos turinio.

Naudoti:

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

Šis kodas iš tikrųjų bus įvykdytas

 for( int n : myList ) { if( n % 2 == 0 ) { System.out.println(n); } } 
2
05 апр. Vincentas Robertas atsakė į 05 Bal. 2010-04-05 15:43 '10, 15:43, 2010-04-05 15:43

Paprastas „Java8“ sprendimas:

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

Deja, šis sprendimas nėra visiškai bendras, rodomas sąrašas, o ne šios kolekcijos tipas. Be to, biblioteka ar įrašymo funkcijos, kurios apgaubia šį kodą, man atrodo nereikalingos, jei ši sąlyga nėra sudėtinga, bet tada galite įrašyti funkciją funkcijai.

1
03 июля '14 в 21:54 2014-07-03 21:54 atsakymą pateikė Andrew McKnight liepos 3 d. 14 d. 21:54 2014-07-03 21:54

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

Palaiko įvairias funkcijas

Šis mokestis

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

patinka

 class Dto { private int id; private String text; public int getId() { return id; } public int getText() { return text; } } 

Filtruoti

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

Be to,

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

Rūšiuoti (taip pat galima naudoti „Java 7“)

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

Grupavimas (galima naudoti ir „Java 7“)

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

Ryšiai (taip pat prieinami „Java 7“)

Atsižvelgiant į tai

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

Galite užsiregistruoti kaip

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

Išraiškos

 Filter<Dto> query = CQ.<Dto>filter() .from(testList) .where() .exec(s -> s.getId() + 1).eq().value(2); 
1
03 сент. Atsakymas pateikiamas „ Low Flying Pelican“ 03 rugsėjis. 2014-09-03 15:59 '14, 15:59 2014-09-03 15:59

Turėjau filtruoti sąrašą, priklausomai nuo sąraše esančių vertybių. Pvz., Ištrinkite visas reikšmes po mažesnės vertės nei dabartinė vertė. {2 5 3 4 7 5} → {2 5 7}. Arba, pavyzdžiui, ištrinkite visus dublikatus {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; } } 

Jis bus naudojamas taip.

 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
15 июня '17 в 17:28 2017-06-15 17:28 atsakymą pateikė Fredrik Metcalf birželio 17 d. 17 val. 17:28 2017-06-15 17:28

Mano atsakymas yra pagrįstas tuo, kad iš Kevino Wongo, čia, kaip viena eilutė, naudojant „ CollectionUtils iš pavasario ir „Java lambda“ java išraiškas.

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

Jis yra toks glaustas ir suprantamas kaip bet kokia alternatyva, kurią matiau (nenaudojant į aspektus orientuotų bibliotekų)

Pavasario kolekcijaUtils yra prieinama iš pavasario versijos 4.0.2.RELEASE, ir atminkite, kad jums reikia JDK 1.8 ir 8 + kalbos lygį.

1
22 апр. Atsakymas, kurį pateikė vikingsteve balandžio 22 d 2015-04-22 14:18 '15, 14:18, 2015-04-22 14:18

Su Guava:

 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
15 дек. atsakymą pateikė ZhekaKozlov 15 d. 2016-12-15 12:20 '16 at 12:20 2016-12-15 12:20

Naudodami java 8 , ypač lambda expression , galite tai padaryti tiesiog kaip pavyzdį:

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

kur kiekvienam productmyProducts rinkinyje, jei prod.price>10 , pridėkite šį produktą į naują filtruotą sąrašą.

0
13 дек. atsakymas duotas hd84335 13 dec. 2015-12-13 00:47 '15 - 0:47 2015-12-13 00:47

„Java 8“ galite naudoti šį filtro metodą ir tada tai padaryti.

  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); 
-1
18 окт. Atsakymas pateikiamas pramod_m 18 okt. 2018-10-18 16:40 '18, 4:40 pm 2018-10-18 16:40

Kiti klausimai apie „ arba „ Klauskite klausimą“