Java 8（ 2014 ）は、1行のコードでストリームとラムダを使用してこの問題を解決します。
List<Person> beerDrinkers = persons.stream()
.filter(p -> p.getAge() > 16).collect(Collectors.toList());
これが チュートリアル です。
コレクションを適切に修正するには Collection#removeIf を使用します。 （注意：この場合、述語は述語を満たすオブジェクトを削除します）：
persons.removeIf(p -> p.getAge() <= 16);
lambdaj ループや内部クラスを書かずにコレクションをフィルタリングすることができます。
List<Person> beerDrinkers = select(persons, having(on(Person.class).getAge(),
greaterThan(16)));
もっと読みやすいものを想像できますか。
免責事項： 私はlambdajの寄稿者です
Java 1.5 を使用していて、 Google Collections を追加できないと仮定して、私はGoogleの人々がしたことと非常によく似たことをするでしょう。これはJonのコメントに対するわずかな変化です。
最初にこのインターフェースをあなたのコードベースに追加してください。
public interface IPredicate<T> { boolean apply(T type); }
その実装者は、特定の述語が特定の型に当てはまる場合に答えることができます。例えば。 TがUserで、AuthorizedUserPredicate<User>がIPredicate<T>を実装している場合、AuthorizedUserPredicate#applyは渡されたUserが許可されているかどうかを返します。
それからある実用的なクラスでは、あなたは言うことができる
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;
}
だから、あなたが上記の使用をしていると仮定すると、
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);
線形チェックのパフォーマンスが問題になる場合は、ターゲットコレクションを持つドメインオブジェクトを使用することをお勧めします。ターゲットコレクションを持つドメインオブジェクトは、ターゲットコレクションを初期化、追加、設定するメソッドのためのフィルタリングロジックを持ちます。
更新：
ユーティリティクラス（たとえばPredicate）に、述語が期待値を返さない場合のデフォルト値のオプションを持つselectメソッドと、新しいIPredicate内で使用されるparamsの静的プロパティを追加しました。
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;
}
}
次の例では、コレクション間で不足しているオブジェクトを探します。
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;
}
});
次の例では、コレクション内のインスタンスを検索し、インスタンスが見つからないときにはコレクションの最初の要素をデフォルト値として返します。
MyType myObject = Predicate.select(collectionOfMyType, new IPredicate<MyType>() {
public boolean apply(MyType objectOfMyType) {
return objectOfMyType.isDefault();
}}, collectionOfMyType.get(0));
更新（Java 8リリース以降）：
私（Alan）が最初にこの回答を投稿してから数年が経ちましたが、この回答に対してSO個のポイントを集めているとはまだ信じられません。いずれにしても、Java 8が言語にクロージャーを導入したので、私の答えは今ではかなり異なり、そしてより単純になります。 Java 8では、個別の静的ユーティリティクラスは必要ありません。だからあなたがあなたの述語にマッチする最初の要素を見つけたいのなら。
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には、get()、isPresent()、orElse(defaultUser)、orElseGet(userSupplier)およびorElseThrow(exceptionSupplier)、ならびにmap、flatMapおよびfilterなどの他の「単項」関数があります。
述語に一致するすべてのユーザーを単純に収集したい場合は、Collectorsを使用して目的の収集でストリームを終了します。
final UserService userService = ... // perhaps injected IoC
final List<UserModel> userOption = userCollection.stream().filter(u -> {
boolean isAuthorized = userService.isAuthorized(u);
return isAuthorized;
}).collect(Collectors.toList());
Java 8ストリームがどのように機能するかについてのより多くの例については ここ を参照してください。
Apache Commonsの CollectionUtils.filter（Collection、Predicate） を使用します。
「最善の」方法は広すぎる要求です。それは「最短」ですか？ 「最速」？ 「読める」？その場で、または別のコレクションにフィルターをかけますか？
最も単純な（しかし最も読みやすいとは言えない）方法は、それを反復してIterator.remove（）メソッドを使用することです。
Iterator<Foo> it = col.iterator();
while( it.hasNext() ) {
Foo foo = it.next();
if( !condition(foo) ) it.remove();
}
読みやすくするために、ユーティリティメソッドにラップすることができます。それから、IPredicateインターフェースを発明し、そのインターフェースの匿名の実装を作成し、そして以下のようなことをしてください。
CollectionUtils.filterInPlace(col,
new IPredicate<Foo>(){
public boolean keepIt(Foo foo) {
return foo.isBar();
}
});
ここで、filterInPlace（）はコレクションを反復し、Predicate.keepIt（）を呼び出してインスタンスをコレクション内に保持するかどうかを調べます。
この作業のためだけにサードパーティのライブラリを持ち込むことに正当性があるとは思わない。
GenericsをサポートするアップデートされたCollectionsフレームワークについては、 Google Collections を検討してください。
_ update _ ：Googleコレクションライブラリは現在使用されていません。代わりに Guava の最新リリースを使用してください。それはまだ述語に基づいてフィルタリングするためのメカニズムを含むコレクションフレームワークへのすべての同じ拡張を持ちます。
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());
RxJava をリングに投げます。これは Android でも利用できます。 RxJavaが常に最良の選択肢であるとは限りませんが、コレクションにさらに変換を追加したり、フィルタリング中にエラーを処理したりする場合は、より柔軟性があります。
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);
}
});
出力：
1
3
5
RxJavaのfilterに関する詳細は ここ をご覧ください。
Java 8の初期リリース以来、次のようなことを試すことができます。
Collection<T> collection = ...;
Stream<T> stream = collection.stream().filter(...);
たとえば、整数のリストがあり、10を超える数字をフィルタしてからそれらの数字をコンソールに出力したい場合は、次のようにします。
List<Integer> numbers = Arrays.asList(12, 74, 5, 8, 16);
numbers.stream().filter(n -> n > 10).forEach(System.out::println);
イテレータではなくコレクション自体をフィルタリングしてもよろしいですか？
org.Apache.commons.collections.iterators.FilterIterator を参照してください。
またはApache commonsのバージョン4を使用する org.Apache.commons.collections4.iterators.FilterIterator
セットアップ：
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();
}
}
}
使い方
List<MyObject> myList = ...;
filterCollection(myList, new Predicate<MyObject>() {
public boolean filter(MyObject obj) {
return obj.shouldFilter();
}
});
単純で直接的なJavaについてはどうですか。
List<Customer> list ...;
List<Customer> newList = new ArrayList<>();
for (Customer c : list){
if (c.getName().equals("dd")) newList.add(c);
}
シンプルで読みやすく、そして簡単（そしてAndroidでも動作します！）しかし、Java 8を使用しているなら、それを一行で実行できます。
List<Customer> newList = list.stream().filter(c -> c.getName().equals("dd")).collect(toList());
ToList（）は静的にインポートされることに注意してください。
組み込みのJDKリストと MutableList /を使って Eclipse Collections （旧 GS Collections ）をフィルタリングする方法を見てみましょう。
List<Integer> jdkList = Arrays.asList(1, 2, 3, 4, 5);
MutableList<Integer> ecList = Lists.mutable.with(1, 2, 3, 4, 5);
3未満の数をフィルタリングしたい場合は、次のような出力が予想されます。
List<Integer> selected = Lists.mutable.with(1, 2);
List<Integer> rejected = Lists.mutable.with(3, 4, 5);
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));
述語 factoryを使ってJDKリストや Eclipseコレクション MutableListsをフィルタリングする代わりの方法がいくつかあります。
Assert.assertEquals(selected, Iterate.select(jdkList, Predicates.lessThan(3)));
Assert.assertEquals(selected, ecList.select(Predicates.lessThan(3)));
これは、Predicate2を取るselectWithメソッドで代わりに Predicates2 factoryを使用して、述部にオブジェクトを割り当てないバージョンです。
Assert.assertEquals(
selected, ecList.selectWith(Predicates2.<Integer>lessThan(), 3));
時にはあなたは否定的な条件でフィルターをかけたいと思うでしょう。 Eclipse Collectionsには、rejectという特別なメソッドがあります。
Assert.assertEquals(rejected, Iterate.reject(jdkList, lessThan3));
Assert.assertEquals(rejected, ecList.reject(lessThan3));
これが、Java 8λを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は、Predicateによって選択され拒否された要素を含む2つのコレクションを返します。
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());
注：私はEclipseコレクションのコミッターです。
Collections2.filter（Collection、Predicate）GoogleのGuavaライブラリのメソッド は、あなたが探しているものだけを実行します。
ForEach DSLでは、書くことができます
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();
[クイック、ブラウン、キツネ、ジャンプ、オーバー、ザ、レイジー、ドッグ]のコレクションを考えると、これは[クイック、ブラウン、キツネ、オーバー、レイジー]、すなわち3文字より長いすべてのストリングをもたらします。
ForEach DSLでサポートされているすべての反復スタイルは、
AllSatisfyAnySatisfyCollectCounntCutPiecesDetectGroupedByIndexOfInjectIntoRejectSelect
詳細については、 https://www.iam.unibe.ch/scg/svn_repos/Sources/ForEach を参照してください。
Java 9 Collectors.filteringが有効になっているので：
public static <T, A, R>
Collector<T, ?, R> filtering(Predicate<? super T> predicate,
Collector<? super T, A, R> downstream)
したがって、フィルタリングは次のようになります。
collection.stream().collect(Collectors.filtering(predicate, collector))
例：
List<Integer> oddNumbers = List.of(1, 19, 15, 10, -10).stream()
.collect(Collectors.filtering(i -> i % 2 == 1, Collectors.toList()));
これは、本物のクロージャーの欠如と相まって、私にとっての最大の不満です。正直なところ、上記の方法のほとんどは非常に読みやすく本当に効率的です。しかし、.Net、Erlangなどに時間を費やした後、言語レベルで統合されたリスト内包表記は、すべてをそれほどクリーンにします。言語レベルでの追加がなければ、Javaはこの分野の他の多くの言語と同じくらいきれいになることはできません。
パフォーマンスが大きな懸念事項である場合は、Googleのコレクションを使用する（または独自の単純な述語ユーティリティを作成する）方法があります。 Lambdaj構文は一部の人にとって読みやすくなっていますが、それほど効率的ではありません。
それから私が書いた図書館があります。その効率に関する質問は無視します（そう、その悪いこと）......はい、私はその明確な反映に基づいていることを知っています、そして、いいえ私は実際にそれを使用しません、しかしそれはうまくいきます：
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");
ここでいくつかの本当に素晴らしい素晴らしい答え。私、できる限りシンプルで読みやすいものにしたいと思います。
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();
}
}
}
}
}
JFilter http://code.google.com/p/jfilter/ はあなたの要件に最も適しています。
JFilterは、Java Beanのコレクションをクエリするためのシンプルで高性能なオープンソースライブラリです。
主な機能
- コレクション（Java.util.Collection、Java.util.Map、およびArray）プロパティのサポート。
- 任意の深さのコレクションの中のコレクションのサポート。
- 内部クエリのサポート.
- パラメータ化クエリのサポート.
- 数100ミリ秒で100万レコードをフィルタリングできます。
- フィルタ（クエリ）は単純なJSON形式で与えられ、それはMangodbクエリのようなものです。以下はその例です。
- {"id"：{"$ le"： "10"}
- ここで、オブジェクトIDプロパティは10以下です。
- {"id"：{"$ in"：["0"、 "100"]}}
- object idプロパティは0または100です。
- {"lineItems"：{"lineAmount"： "1"}}
- パラメータ化された型のlineItemsコレクションプロパティのlineAmountの値は1です。
- {"$ and"：[{"id"： "0"}、{"billingAddress"：{"都市"： "DEL"}}]}
- idプロパティは0、billingAddress.cityプロパティはDELです。
- {"lineItems"：{"税金"：{"キー"：{"コード"： "GST"}、 "値"：{"$ gt"： "1.01"}}}
- taxisized型のtax map typeプロパティを持つparameterized型のlineItemsコレクションプロパティのコードがGST値1.01以上である。
- {'$または'：[{'code'： '10'}、{'skus'：{'$および'：[{'price'：{'$ in'：['20'、 '40']} }、{'code'： 'RedApple'}]}}]}
- 商品コードが10または20と40のSKU価格で、SKUコードが「RedApple」であるすべての商品を選択します。
コレクションクエリエンジン（CQEngine）を使用 。これを実行するのがはるかに速い方法です。
以下も参照してください。 Javaでオブジェクトコレクションをどのようにクエリしますか（Criteria/SQL風）。
拡張されたIterableクラス を書いた。コレクションの内容をコピーせずに機能的アルゴリズムを適用することをサポートする。
使用法：
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);
}
上記のコードは実際に実行されます
for( int n : myList )
{
if( n % 2 == 0 )
{
System.out.println(n);
}
}
Java 8、具体的にはlambda expressionを使用すると、以下の例のように簡単に実行できます。
myProducts.stream().filter(prod -> prod.price>10).collect(Collectors.toList())
ここで、productコレクション内の各myProductsについて、prod.price>10の場合は、この商品を新しいフィルター処理済みリストに追加します。
リストに既に存在する値に応じてリストをフィルタリングする必要がありました。たとえば、現在の値より小さい、それ以降のすべての値を削除します。 {2 5 3 4 7 5} - > {2 5 7}。またはたとえば、すべての重複を削除するには{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;
}
}
これはこのように使用されます。
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;
}
});
私の答えはKevin Wongによるもので、ここでは spring からのCollectionUtilsとJava 8 lambda の式を使ったワンライナーです。
CollectionUtils.filter(list, p -> ((Person) p).getAge() > 16);
これは私がこれまでに見たことのある代替案と同じくらい簡潔で読みやすいものです（アスペクトベースのライブラリを使用せずに）
Spring CollectionUtils は、Springバージョン4.0.2.RELEASEから入手できます。JDK1.8および言語レベル8以降が必要です。
Java8より前の単純なソリューション
ArrayList<Item> filtered = new ArrayList<Item>();
for (Item item : items) if (condition(item)) filtered.add(item);
残念ながら、この解決策は完全に一般的なものではなく、与えられたコレクションの型ではなくリストを出力します。また、条件を複雑にしない限り、ライブラリを持ち込んだり、このコードをラップする関数を書いたりするのはやり過ぎに思えますが、その場合は条件に応じて関数を書くことができます。
https://code.google.com/p/joquery/
さまざまな可能性をサポート
コレクションを考えて、
Collection<Dto> testList = new ArrayList<>();
タイプの
class Dto
{
private int id;
private String text;
public int getId()
{
return id;
}
public int getText()
{
return text;
}
}
フィルタ
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();
また、
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"});
ソート （Java 7でも利用可能）
Filter<Dto> query = CQ.<Dto>filter(testList)
.orderBy()
.property(Dto::getId)
.property(Dto::getName)
Collection<Dto> sorted = query.list();
グループ化 （Java 7でも利用可能）
GroupQuery<Integer,Dto> query = CQ.<Dto,Dto>query(testList)
.group()
.groupBy(Dto::getId)
Collection<Grouping<Integer,Dto>> grouped = query.list();
結合 （Java 7でも使用可能）
与えられた、
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<>();
のように参加することができます、
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();
式
Filter<Dto> query = CQ.<Dto>filter()
.from(testList)
.where()
.exec(s -> s.getId() + 1).eq().value(2);
グアバ語で：
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
Java 8では、このフィルタメソッドを直接使用してから実行できます。
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);