it-swarm.com.de

Wie kann eine Java -Auflistung am besten gefiltert werden?

Ich möchte einen Java.util.Collection basierend auf einem Prädikat filtern.

635
Kevin Wong

Java 8 ( 2014 ) löst dieses Problem mit Streams und Lambdas in einer Codezeile:

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

Hier ist ein Tutorial .

Verwenden Sie Collection#removeIf , um die Sammlung zu ändern. (Hinweis: In diesem Fall entfernt das Prädikat Objekte, die das Prädikat erfüllen.)

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

lambdaj ermöglicht das Filtern von Sammlungen, ohne Schleifen oder innere Klassen zu schreiben:

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

Können Sie sich etwas besser lesbares vorstellen?

Haftungsausschluss: Ich bin ein Mitwirkender bei Lambdaj

639
Mario Fusco

Unter der Annahme, dass Sie Java 1.5 verwenden und Google Collections nicht hinzufügen können, würde ich etwas sehr Ähnliches tun wie die Google-Leute. Dies ist eine geringfügige Abweichung von Jons Kommentaren.

Fügen Sie diese Schnittstelle zunächst Ihrer Codebasis hinzu.

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

Ihre Implementierer können antworten, wenn ein bestimmtes Prädikat eines bestimmten Typs wahr ist. Z.B. Wenn TUser und AuthorizedUserPredicate<User>IPredicate<T> implementiert, gibt AuthorizedUserPredicate#apply zurück, ob die übergebene User autorisiert ist.

Dann könnte man in irgendeiner Gebrauchsklasse sagen

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

Angenommen, Sie haben die oben genannten Möglichkeiten

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

Wenn die Leistung bei der linearen Prüfung von Bedeutung ist, möchte ich möglicherweise ein Domänenobjekt mit der Zielsammlung haben. Das Domänenobjekt mit der Zielsammlung verfügt über eine Filterlogik für die Methoden, mit denen die Zielsammlung initialisiert, hinzugefügt und festgelegt wird.

AKTUALISIEREN:

In der Utility-Klasse (sagen wir Predicate) habe ich eine select-Methode mit einer Option für den Standardwert hinzugefügt, wenn das Prädikat den erwarteten Wert nicht zurückgibt, sowie eine statische Eigenschaft für Parameter, die im neuen IPredicate verwendet werden sollen.

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

Das folgende Beispiel sucht nach fehlenden Objekten zwischen Sammlungen:

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

Das folgende Beispiel sucht nach einer Instanz in einer Auflistung und gibt das erste Element der Auflistung als Standardwert zurück, wenn die Instanz nicht gefunden wird:

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

UPDATE (nach Java 8):

Es ist einige Jahre her, dass ich (Alan) diese Antwort zum ersten Mal gepostet habe, und ich kann immer noch nicht glauben, dass ich SO Punkte für diese Antwort sammle. Jedenfalls wäre meine Antwort jetzt, da Java 8 die Sprache geschlossen hat, erheblich anders und einfacher. Mit Java 8 ist keine separate statische Dienstprogrammklasse erforderlich. Wenn Sie also das erste Element suchen möchten, das Ihrem Prädikat entspricht.

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 für optionale Geräte kann get(), isPresent(), orElse(defaultUser), orElseGet(userSupplier) und orElseThrow(exceptionSupplier) sowie andere 'monadische' Funktionen wie map, flatMap und filter.

Wenn Sie einfach alle Benutzer sammeln möchten, die mit dem Prädikat übereinstimmen, verwenden Sie Collectors, um den Stream in der gewünschten Sammlung zu beenden.

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

In hier finden Sie weitere Beispiele für die Funktionsweise von Java 8-Streams.

219
Alan

Verwenden Sie CollectionUtils.filter (Collection, Predicate) von Apache Commons.

90
Kevin Wong

"Bester" Weg ist eine zu weite Bitte. Ist es "am kürzesten"? "Schnellste"? "Lesbar"? Filtern an Ort und Stelle oder in eine andere Sammlung?

Am einfachsten (aber nicht am besten lesbar) ist es, sie zu wiederholen und die Iterator.remove () -Methode zu verwenden:

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

Um es lesbarer zu machen, können Sie es in eine Utility-Methode einbinden. Dann erfinde eine IPredicate-Schnittstelle, erstelle eine anonyme Implementierung dieser Schnittstelle und mache etwas wie:

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

dabei durchläuft filterInPlace () die Auflistung und ruft Predicate.keepIt () auf, um zu ermitteln, ob die Instanz in der Auflistung beibehalten werden soll.

Ich sehe keine Rechtfertigung dafür, eine Drittanbieter-Bibliothek nur für diese Aufgabe einzubringen.

65

Betrachten Sie Google Collections für ein aktualisiertes Collections-Framework, das Generika unterstützt.

UPDATE: Die Google-Sammlungsbibliothek ist jetzt veraltet. Sie sollten stattdessen die neueste Version von Guava verwenden. Es gibt immer noch dieselben Erweiterungen für das Collections-Framework, einschließlich eines Mechanismus zum Filtern basierend auf einem Prädikat.

62
Heath Borders

Warten Sie auf 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());
26
gavenkoa

Ich werfe RxJava in den Ring, der auch auf Android verfügbar ist. RxJava ist möglicherweise nicht immer die beste Option, bietet Ihnen jedoch mehr Flexibilität, wenn Sie Ihrer Sammlung weitere Transformationen hinzufügen oder Fehler beim Filtern behandeln möchten.

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

Ausgabe:

1
3
5

Weitere Details zu RxJava's filter finden Sie hier .

11
anon

Seit der frühen Veröffentlichung von Java 8 können Sie Folgendes ausprobieren:

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

Wenn Sie beispielsweise eine Liste mit ganzen Zahlen hatten und die Zahlen filtern möchten, die größer als 10 sind, und diese Zahlen dann auf der Konsole ausgeben möchten, können Sie Folgendes tun:

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

Möchten Sie die Sammlung wirklich filtern und nicht einen Iterator?

siehe org.Apache.commons.collections.iterators.FilterIterator

oder mit Version 4 von Apache commons org.Apache.commons.collections4.iterators.FilterIterator

7
ykaganovich

Die Einrichtung:

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 Verwendung:

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

Wie wäre es mit einfachem und geradlinigem Java?

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

Einfach, lesbar und einfach (und funktioniert unter Android!). Wenn Sie jedoch Java 8 verwenden, können Sie dies in einer einzigen Zeile tun:

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

Beachten Sie, dass toList () statisch importiert wird

Schauen wir uns an, wie eine integrierte JDK-Liste und eine MutableList mit Eclipse Collections (früher GS Collections ) gefiltert werden.

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

Wenn Sie die Zahlen kleiner als 3 filtern möchten, erwarten Sie die folgenden Ausgaben.

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

Hier erfahren Sie, wie Sie mithilfe einer anonymen inneren Klasse als Predicate filtern können.

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 sind einige Alternativen zum Filtern von JDK-Listen und Eclipse Collections MutableLists mit der Factory Predicates .

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

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

In der folgenden Version wird dem Prädikat kein Objekt zugewiesen, indem stattdessen die Factory Predicates2 mit der Methode selectWith verwendet wird, die den Wert Predicate2 annimmt.

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

Manchmal möchten Sie nach einer negativen Bedingung filtern. In Eclipse-Sammlungen gibt es eine spezielle Methode mit dem Namen reject.

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

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

So können Sie mit Java 8 Lambda als Predicate filtern.

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 Methode partition gibt zwei Sammlungen zurück, die die von Predicate ausgewählten und abgelehnten Elemente enthalten.

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

Hinweis: Ich bin ein Committer für Eclipse-Sammlungen.

6
Donald Raab

Die Collections2.filter (Collection, Predicate) -Methode in Googles Guava-Bibliothek macht genau das, wonach Sie suchen.

5
Kevin Wong

Mit dem ForEach DSL darfst du schreiben

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

Bei einer Sammlung von [The, quick, brown, fox, jumps, over, the, lazy, dog] ergibt dies [quick, brown, jumps, over, lazy], dh alle Zeichenfolgen, die länger als drei Zeichen sind.

Alle von ForEach DSL unterstützten Iterationsstile sind

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

Weitere Informationen finden Sie unter https://www.iam.unibe.ch/scg/svn_repos/Sources/ForEach

5
akuhn

Seit Java 9Collectors.filtering ist aktiviert:

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

Das Filtern sollte also sein:

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

Beispiel:

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

Dies, zusammen mit dem Mangel an echten Verschlüssen, ist meine größte Beschwerde für Java. Ehrlich gesagt, die meisten der oben genannten Methoden sind ziemlich einfach zu lesen und WIRKLICH effizient. Nachdem Sie Zeit mit .Net, Erlang usw. verbracht haben, macht das auf Sprachebene integrierte Listenverständnis alles so viel sauberer. Ohne Spracherweiterungen kann Java nicht so sauber sein wie viele andere Sprachen in diesem Bereich.

Wenn die Leistung ein großes Problem darstellt, ist Google Collections der richtige Weg (oder schreiben Sie Ihr eigenes einfaches Prädikat-Dienstprogramm). Die Lambdaj-Syntax ist für manche Menschen besser lesbar, aber nicht ganz so effizient.

Und dann gibt es eine Bibliothek, die ich geschrieben habe. Ich werde alle Fragen in Bezug auf seine Effizienz ignorieren (ja, es ist so schlimm).

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

ODER

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

Einige wirklich tolle tolle Antworten hier. Ich möchte die Dinge so einfach und lesbar wie möglich halten:

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

JFilter http://code.google.com/p/jfilter/ ist am besten für Ihre Anforderung geeignet.

JFilter ist eine einfache und leistungsstarke Open-Source-Bibliothek, mit der eine Sammlung von Java Beans abgefragt werden kann.

Hauptmerkmale

  • Unterstützung von Collection-Eigenschaften (Java.util.Collection, Java.util.Map und Array).
  • Unterstützung der Sammlung innerhalb der Sammlung beliebiger Tiefe.
  • Unterstützung innerer Abfragen.
  • Unterstützung von parametrisierten Abfragen.
  • Kann 1 Million Datensätze in wenigen 100 ms filtern.
  • Filter (Abfrage) wird im einfachen json-Format angegeben, ähnlich wie Mangodb-Abfragen. Es folgen einige Beispiele.
  • {"id": {"$ le": "10"}
    • dabei ist die Eigenschaft object id kleiner als 10.
  • {"id": {"$ in": ["0", "100"]}}
    • dabei ist die Objekt-ID-Eigenschaft 0 oder 100.
  • {"lineItems": {"lineAmount": "1"}}
    • dabei hat die lineItems-Auflistungseigenschaft des parametrisierten Typs lineAmount den Wert 1.
  • {"$ and": [{"id": "0"}, {"billingAddress": {"city": "DEL"}}]}
    • dabei ist die Eigenschaft id 0 und die Eigenschaft billingAddress.city ist DEL.
  • {"lineItems": {"tax": {"key": {"code": "GST"}, "value": {"$ gt": "1.01"}}}
    • wobei die lineItems-Auflistungseigenschaft des parametrisierten Typs, die die Steuerkartentypeigenschaft des parametrisierten Typs aufweist, Code enthält, der einem GST-Wert größer als 1,01 entspricht.
  • {'$ or': [{'code': '10'}, {'skus': {'$ and': [{'price': {'$ in': ['20', '40']} }, {'code': 'RedApple'}]}}]}
    • Wählen Sie alle Produkte mit einem Produktcode von 10 oder einem Artikelpreis von 20 und 40 und einem Artikelcode von "RedApple".
2
Kamran Ali Khan

Verwenden Sie Collection Query Engine (CQEngine) . Dies ist bei weitem der schnellste Weg.

Siehe auch: Wie werden Objektsammlungen in Java (Criteria/SQL-like) abgefragt?

2
npgall

Ich schrieb eine erweiterte Iterable-Klasse , die das Anwenden von Funktionsalgorithmen unterstützt, ohne den Inhalt der Sammlung zu kopieren.

Verwendungszweck:

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

Der obige Code wird tatsächlich ausgeführt

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

Mit Java 8, speziell lambda expression, können Sie dies einfach wie im folgenden Beispiel tun:

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

wo für jede product in myProducts Sammlung, wenn prod.price>10, dann fügen Sie dieses Produkt der neuen gefilterten Liste hinzu.

1
hd84335

Ich musste eine Liste abhängig von den Werten filtern, die bereits in der Liste vorhanden sind. Entfernen Sie beispielsweise alle folgenden Werte, die kleiner als der aktuelle Wert sind. {2 5 3 4 7 5} -> {2 5 7}. Oder zum Beispiel, um alle Duplikate {3 5 4 2 3 5 6} -> {3 5 4 2 6} zu entfernen.

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

Dies wird so verwendet.

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

Meine Antwort baut darauf auf, von Kevin Wong, hier als Einzeiler mit CollectionUtils von spring und einem Java 8 Lambda Ausdruck.

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

Dies ist so präzise und lesbar wie jede andere Alternative, die ich gesehen habe (ohne aspektbasierte Bibliotheken zu verwenden).

Spring CollectionUtils ist ab der Frühlingsversion 4.0.2.RELEASE verfügbar. Denken Sie daran, dass Sie JDK 1.8 und Sprachlevel 8+ benötigen.

1
vikingsteve

Die einfache Pre-Java8-Lösung:

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

Leider ist diese Lösung nicht vollständig generisch und gibt eher eine Liste als den Typ der angegebenen Sammlung aus. Das Einspielen von Bibliotheken oder das Schreiben von Funktionen, die diesen Code umbrechen, scheint mir zu viel zu sein, es sei denn, die Bedingung ist komplex. Dann können Sie jedoch eine Funktion für die Bedingung schreiben.

1
Andrew McKnight

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

Unterstützt verschiedene Möglichkeiten,

Gegebene Sammlung,

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

vom Typ,

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

Ebenfalls,

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

Sortieren (auch für Java 7 verfügbar)

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

Gruppierung (auch für Java 7 verfügbar)

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

Joins (auch für Java 7 verfügbar)

Gegeben,

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

Kann wie verbunden werden,

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

Ausdrücke

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

Mit Guave:

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

In Java 8 können Sie diese Filtermethode direkt verwenden und dann ausführen.

 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