What is the best way to filter a Java Collection?

Question

I want to filter a java.util.Collection based on a predicate.

Answer 1

In Java 8, You can directly use this filter method and then do that.



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

Answer 2

With the ForEach DSL you may write

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

Given a collection of [The, quick, brown, fox, jumps, over, the, lazy, dog] this results in [quick, brown, jumps, over, lazy], ie all strings longer than three characters.

All iteration styles supported by the ForEach DSL are

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

For more details, please refer to https://www.iam.unibe.ch/scg/svn_repos/Sources/ForEach

Answer 3

The simple pre-Java8 solution:

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

Unfortunately this solution isn't fully generic, outputting a list rather than the type of the given collection. Also, bringing in libraries or writing functions that wrap this code seems like overkill to me unless the condition is complex, but then you can write a function for the condition.

Answer 4

JFilter http://code.google.com/p/jfilter/ is best suited for your requirement.

JFilter is a simple and high performance open source library to query collection of Java beans.

Key features

• Support of collection (java.util.Collection, java.util.Map and Array) properties.
• Support of collection inside collection of any depth.
• Support of inner queries.
• Support of parameterized queries.
• Can filter 1 million records in few 100 ms.
• Filter ( query) is given in simple json format, it is like Mangodb queries. Following are some examples.
• { "id":{"$le":"10"}
  • where object id property is less than equals to 10.
• { "id": {"$in":["0", "100"]}}
  • where object id property is 0 or 100.
• {"lineItems":{"lineAmount":"1"}}
  • where lineItems collection property of parameterized type has lineAmount equals to 1.
• { "$and":[{"id": "0"}, {"billingAddress":{"city":"DEL"}}]}
  • where id property is 0 and billingAddress.city property is DEL.
• {"lineItems":{"taxes":{ "key":{"code":"GST"}, "value":{"$gt": "1.01"}}}}
  • where lineItems collection property of parameterized type which has taxes map type property of parameteriszed type has code equals to GST value greater than 1.01.
• {'$or':[{'code':'10'},{'skus': {'$and':[{'price':{'$in':['20', '40']}}, {'code':'RedApple'}]}}]}
  • Select all products where product code is 10 or sku price in 20 and 40 and sku code is "RedApple".

Answer 5

"Best" way is too wide a request. Is it "shortest"? "Fastest"? "Readable"? Filter in place or into another collection?

Simplest (but not most readable) way is to iterate it and use Iterator.remove() method:

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

Now, to make it more readable, you can wrap it into a utility method. Then invent a IPredicate interface, create an anonymous implementation of that interface and do something like:

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

where filterInPlace() iterate the collection and calls Predicate.keepIt() to learn if the instance to be kept in the collection.

I don't really see a justification for bringing in a third-party library just for this task.

Answer 6

I wrote an extended Iterable class that support applying functional algorithms without copying the collection content.

Usage:

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

The code above will actually execute

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