How to filter a Java Collection (based on predicate)?

Java 8 (2014) solves this problem using streams and lambdas in one line of code:

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

Here's a tutorial.

Use Collection#removeIf to modify the collection in place. (Notice: In this case, the predicate will remove objects who satisfy the predicate):

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

lambdaj allows filtering collections without writing loops or inner classes:

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

Can you imagine something more readable?

Disclaimer: I am a contributor on lambdaj

Assuming that you are using Java 1.5, and that you cannot add Google Collections, I would do something very similar to what the Google guys did. This is a slight variation on Jon's comments.

First add this interface to your codebase.

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

Its implementers can answer when a certain predicate is true of a certain type. E.g. If T were User and AuthorizedUserPredicate<User> implements IPredicate<T>, then AuthorizedUserPredicate#apply returns whether the passed in User is authorized.

Then in some utility class, you could say

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

So, assuming that you have the use of the above might be

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

If performance on the linear check is of concern, then I might want to have a domain object that has the target collection. The domain object that has the target collection would have filtering logic for the methods that initialize, add and set the target collection.

UPDATE:

In the utility class (let's say Predicate), I have added a select method with an option for default value when the predicate doesn't return the expected value, and also a static property for params to be used inside the new IPredicate.

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

The following example looks for missing objects between collections:

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

The following example, looks for an instance in a collection, and returns the first element of the collection as default value when the instance is not found:

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

UPDATE (after Java 8 release):

It's been several years since I (Alan) first posted this answer, and I still cannot believe I am collecting SO points for this answer. At any rate, now that Java 8 has introduced closures to the language, my answer would now be considerably different, and simpler. With Java 8, there is no need for a distinct static utility class. So if you want to find the 1st element that matches your predicate.

final UserService userService = ... // perhaps injected IoCfinal Optional<UserModel> userOption = userCollection.stream().filter(u -> {    boolean isAuthorized = userService.isAuthorized(u);    return isAuthorized;}).findFirst();

The JDK 8 API for optionals has the ability to get(), isPresent(), orElse(defaultUser), orElseGet(userSupplier) and orElseThrow(exceptionSupplier), as well as other 'monadic' functions such as map, flatMap and filter.

If you want to simply collect all the users which match the predicate, then use the Collectors to terminate the stream in the desired collection.

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

See here for more examples on how Java 8 streams work.

Use CollectionUtils.filter(Collection,Predicate), from Apache Commons.