Extract elements from list based on object property type

Often, I have a list of objects. Each object has properties. I want to extract a subset of the list where a specific property has a predefined value.

Example:

I have a list of User objects. A User has a homeTown. I want to extract all users from my list with "Springfield" as their homeTown.

I normally see this accomplished as follows:

List use开发者_Python百科rs = getTheUsers();

List returnList = new ArrayList();

for (User user: users) {

   if ("springfield".equalsIgnoreCase(user.getHomeTown()) 

        returnList.add(user); 

}

I am not particularly satisfied with this solution. Yes, it works, but it seems so slow. There must be a non-linear solution.

Suggestions?

Well, this operation is linear in nature unless you do something extreme like index the collection based on properties you expect to examine in this way. Short of that, you're just going to have to look at each object in the collection.

But there may be some things you can do to improve readability. For example, Groovy provides an each() method for collections. It would allow you to do something like this...

def returnList = new ArrayList();
users.each() {
    if ("springfield".equalsIgnoreCase(it.getHomeTown()) 
        returnList.add(user); 
};

You will need a custom solution for this. Create a custom collection such that it implements List interface and add all elements from original list into this list.

Internally in this custom List class you need to maintain some collections of Map of all attributes which can help you lookup values as you need. To populate this Map you will have to use introspection to find list of all fields and their values.

This custom object will have to implement some methods as List findAllBy(String propertyName, String propertyValue); that will use above hash map to look up those values.

This is not an easy straightforward solution. Further more you will need to consider nested attributes like "user.address.city". Making this custom List immutable will help a lot.

However even if you are iterating list of 1000's of objects in List, still it will be faster so you are better off iterating List for what you need.

As I have found out, if you are using a list, you have to iterate. Whether its a for-each, lambda, or a FindAll - it is still being iterated. No matter how you dress up a duck, it's still a duck. As far as I know there are HashTables, Dictionaries, and DataTables that do not require iteration to find a value. I am not sure what the Java equivalent implementations are, but maybe this will give you some other ideas.

If you are really interested in performance here, I would also suggest a custom solution. My suggestion would be to create a Tree of Lists in which you can sort the elements.

If you are not interested about the ordering of the elements inside your list (and most people are usually not), you could also use a TreeMap (or HashMap) and use the homeTown as key and a List of all entries as value. If you add new elements, just look up the belonging list in the Map and append it (if it is the first element of course you need to create the list first). If you want to delete an element simply do the same.

In the case you want a list of all users with a given homeTown you just need to look up that list in the Map and return it (no copying of elements needed), I am not 100% sure about the Map implementations in Java, but the complete method should be in constant time (worst case logarithmic, depending on the Map implementation).

I ended up using Predicates. Its readability looks similar to Drew's suggestion.

As far as performance is concerned, I found negligible speed improvements for small (< 100 items) lists. For larger lists (5k-10k), I found 20-30% improvements. Medium lists had benefits but not quite as large as bigger lists. I did not test super large lists, but my testing made it seem the large the list the better the results in comparison to the foreach process.