Java コレクションをフィルタリングする最良の方法は何ですか?

https://stackoverflow.com/questions/122105

02-07-2019
|

質問

フィルタリングしたい java.util.Collection 述語に基づいています。

解決

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

ラムダージループや内部クラスを作成せずにコレクションをフィルタリングできます。

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

もっと読みやすいものを想像できますか?

免責事項: 私はlambdajの寄稿者です

他のヒント

使用していると仮定すると、 Java 1.5, 、追加できないこと Google コレクション, 、私は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 リリース後):

私 (アラン) が最初にこの回答を投稿してから数年が経ちましたが、この回答で 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 ストリームがどのように機能するかに関するその他の例については、こちらをご覧ください。

使用 CollectionUtils.filter(コレクション,述語), 、Apache Commons から。

「最善の」方法は要求が広すぎます。「最短」ですか？「最速」？「読める」？その場でフィルタリングするか、それとも別のコレクションにフィルタリングしますか?

最も簡単な (ただし、最も読みやすいわけではない) 方法は、それを反復して 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() を呼び出して、インスタンスがコレクション内に保持されるかどうかを学習します。

このタスクのためだけにサードパーティのライブラリを導入する正当な理由がわかりません。

考慮する Google コレクションジェネリックをサポートする更新されたコレクションフレームワークの場合。

アップデート:Google コレクションライブラリは廃止されました。最新リリースを使用する必要がありますグアバその代わり。述語に基づいてフィルタリングするメカニズムなど、コレクションフレームワークに対する同じ拡張機能がすべてそのまま残っています。

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

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

投げます RxJava リングでも利用可能ですアンドロイド. 。RxJava が常に最良のオプションであるとは限りませんが、コレクションにさらに変換を追加したり、フィルタリング中にエラーを処理したりする場合は、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 見つけることができますここ.

セットアップ:

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を使用している場合は、甘い1行でそれを行うことができます。

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

toList() は静的にインポートされることに注意してください

イテレータではなく、コレクション自体をフィルタリングしてもよろしいですか?

見る org.apache.commons.collections.iterators.FilterIterator

または Apache Commons のバージョン 4 を使用する org.apache.commons.collections4.iterators.FilterIterator

組み込みの JDK リストと可変リストを使用してエクリプスコレクション (以前は GSコレクション).

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

ここでは、JDK リストをフィルタリングするための代替手段をいくつか紹介します。エクリプスコレクション MutableList を使用する述語工場。

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

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

以下は、述語にオブジェクトを割り当てないバージョンです。述語2 代わりに工場で selectWith を取るメソッド Predicate2.

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 によって選択された要素と拒否された要素を含む 2 つのコレクションが返されます。 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());

注記：私は Eclipse Collections のコミッターです。

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

[The、quick、brown、fox、jumps、over、the、lazy、dog] のコレクションを考えると、結果は [quick、brown、jumps、over、lazy]、つまり 3 文字より長いすべての文字列になります。

ForEach DSL でサポートされるすべての反復スタイルは次のとおりです。

AllSatisfy
AnySatisfy
Collect
Counnt
CutPieces
Detect
GroupedBy
IndexOf
InjectInto
Reject
Select

詳細については、を参照してください。 https://www.iam.unibe.ch/scg/svn_repos/Sources/ForEach

の Collections2.filter(コレクション,述語) のメソッド GoogleのGuavaライブラリまさにあなたが探していることを行います。

以来 ジャバ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()));

これは、実際のクロージャの欠如と相まって、Java に対する私の最大の不満です。正直なところ、上記のメソッドのほとんどは非常に読みやすく、非常に効率的です。ただし、.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");

Jフィルター 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"]}}
- ここで、オブジェクト ID プロパティは 0 または 100 です。
{"lineItems":{"lineAmount":"1"}}
- ここで、パラメータ化された型の lineItems コレクションプロパティの lineAmount は 1 です。
{ "$and":[{"id":"0"}、{"請求先住所":{"都市":"DEL"}}]}
- ここで、id プロパティは 0、billingAddress.city プロパティは DEL です。
{"lineItems":{"taxes":{ "key":{"code":"GST"}, "value":{"$gt":"1.01"}}}}
- ここで、パラメータ化されたタイプの lineItems コレクションプロパティには、税マップタイプのパラメータ化されたタイプのプロパティがあり、そのコードは 1.01 より大きい GST 値に相当します。
{'$or':[{'code':'10'},{'skus':{'$and':[{'price':{'$in':['20', '40']}}, {'code':'RedApple'}]}}]}
- 製品コードが 10 または SKU 価格が 20 および 40 で、SKU コードが「RedApple」であるすべての製品を選択します。

私が書いた拡張された 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);
    }
}

使用コレクションクエリエンジン (CQEngine). 。これはこれを行うのに最も速い方法です。

以下も参照してください。 Java (Criteria/SQL に似た) でオブジェクトコレクションをクエリするにはどうすればよいですか?

ここには本当に素晴らしい素晴らしい答えがいくつかあります。私としては、内容をできるだけシンプルで読みやすいものにしたいと考えています。

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

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

私の答えは、Kevin Wong からの回答に基づいており、ここではワンライナーとして以下を使用しています。 CollectionUtils から春そしてJava 8 ラムダ 表現。

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

これは、私がこれまでに見た他の代替案と同じくらい簡潔で読みやすいです（アスペクトベースのライブラリを使用しない）

春コレクションユーティリティ春のバージョン 4.0.2.RELEASE から利用可能です。JDK 1.8 と言語レベル 8 以降が必要であることに注意してください。

使用する 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;
    }
});

グアバの場合:

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

ライセンス： CC-BY-SA と帰属

所属していません StackOverflow