How to Find an Element in a List with Java

1. Overview

Finding an element in a list is a very common task we come across as developers.

In this quick tutorial, we’ll cover different ways we can do this with Java.

2. Setup

First let’s start by defining a Customer POJO:

public class Customer {

    private int id;
    private String name;
    
    // getters/setters, custom hashcode/equals
}

Then an ArrayList of customers:

List<Customer> customers = new ArrayList<>();
customers.add(new Customer(1, "Jack"));
customers.add(new Customer(2, "James"));
customers.add(new Customer(3, "Kelly"));

Note that we’ve overridden hashCode and equals in our Customer class.

Based on our current implementation of equals, two Customer objects with the same id will be considered equal.

We’ll use this list of customers along the way.

3. Using Java API

Java itself provides several ways of finding an item in a list:

• The contains method
• The indexOf method
• An ad-hoc for loop
• The Stream API

3.1. contains()

List exposes a method called contains:

boolean contains(Object element)

As the name suggests, this method returns true if the list contains the specified element, and returns false otherwise. 

So when we need to check if a specific item exists in our list, we can:

Customer james = new Customer(2, "James");
if (customers.contains(james)) {
    // ...
}

3.2. indexOf()

indexOf is another useful method for finding elements:

int indexOf(Object element)

This method returns the index of the first occurrence of the specified element in the given list, or -1 if the list doesn’t contain the element.

So logically, if this method returns anything other than -1, we know that the list contains the element:

if(customers.indexOf(james) != -1) {
    // ...
}

The main advantage of using this method is that it can tell us the position of the specified element in the given list.

3.3. Basic Looping

Now, what if we want to do a field-based search for an element? For example, say we’re announcing a lottery and we need to declare a Customer with a specific name as the winner.

For such field-based searches, we can turn to iteration.

A traditional way of iterating through a list is to use one of Java’s looping constructs. In each iteration, we compare the current item in the list with the element we’re looking for to see if it’s a match:

public Customer findUsingEnhancedForLoop(
  String name, List<Customer> customers) {

    for (Customer customer : customers) {
        if (customer.getName().equals(name)) {
            return customer;
        }
    }
    return null;
}

Here, the name refers to the name we are searching for in the given list of customers. This method returns the first Customer object in the list with a matching name, or null if no such Customer exists.

3.4. Looping With an Iterator

An Iterator is another way that we can traverse a list of items.

We can simply take our previous example and tweak it a bit:

public Customer findUsingIterator(
  String name, List<Customer> customers) {
    Iterator<Customer> iterator = customers.iterator();
    while (iterator.hasNext()) {
        Customer customer = iterator.next();
        if (customer.getName().equals(name)) {
            return customer;
        }
    }
    return null;
}

Consequently, the behavior is the same as before.

3.5. Java 8 Stream API

As of Java 8, we can also use the Stream API to find an element in a List.

To find an element matching specific criteria in a given list, we:

• invoke stream() on the list
• call the filter() method with a proper Predicate
• call the findAny() construct, which returns the first element that matches the filter predicate wrapped in an Optional if such an element exists
  

Customer james = customers.stream()
  .filter(customer -> "James".equals(customer.getName()))
  .findAny()
  .orElse(null);

For convenience, we default to null in case an Optional is empty, but this might not always be the best choice for every scenario.

4. Third-Party Libraries

Now, while the Stream API is more than sufficient, what should we do if we’re stuck on an earlier version of Java?

Fortunately, there are many third-party libraries like Google Guava and Apache Commons which we can use.

4.1. Google Guava

Google Guava provides functionality that is similar to what we can do with streams:

Customer james = Iterables.tryFind(customers,
  new Predicate<Customer>() {
      public boolean apply(Customer customer) {
          return "James".equals(customer.getName());
      }
  }).orNull();

Just like with Stream API, we can optionally choose to return a default value instead of null:

Customer james = Iterables.tryFind(customers,
  new Predicate<Customer>() {
      public boolean apply(Customer customer) {
          return "James".equals(customer.getName());
      }
  }).or(customers.get(0));

The above code will pick the first element in the list if no match is found.

Also, don’t forget that Guava throws a NullPointerException if either the list or the predicate is null.

4.2. Apache Commons Collections: IterableUtils.find

We can find an element in almost the same way using the IterableUtils.find() method in Apache Commons Collections:

Customer james = IterableUtils.find(customers,
  new Predicate<Customer>() {
      public boolean evaluate(Customer customer) {
          return "James".equals(customer.getName());
      }
  });

Let’s verify using a test method:

@Test
public void givenName_whenCustomerWithNameFoundUsingApacheCommon_thenReturnCustomer() {
    Customer james = findACustomerInGivenList.findUsingApacheCommon("James", customers);

    assertEquals("James", james.getName());
    assertEquals(2, james.getId());
}

There are a couple of important differences, though:

1. IterableUtils.find() just returns null if we pass a null list.
2. It doesn’t provide default value functionality like Guava’s tryFind.

4.3. Apache Commons Collections: CollectionUtils.exists

We can find an element in a List using the CollectionUtils.exists() method from Apache Commons Collections. This method takes two arguments: an Iterable (like a List) and a Predicate. Therefore, we need to define a Predicate that specifies the criteria for the element we’re looking for.

The exists() method then checks if any element in the collection satisfies that predicate. It returns true as soon as it finds an element that satisfies the predicate. In other words, it answers true if a predicate is true for at least one element of a collection. Or, it returns false if it iterates through the entire collection without finding a match:

public boolean findUsingExists(String name, List<Customer> customers) {
    return CollectionUtils.exists(customers, new org.apache.commons.collections4.Predicate<Customer>() {
        public boolean evaluate(Customer customer) {
            return customer.getName().equals(name);
        }
    });
}

Let’s verify that it returns true when it finds a customer:

@Test
public void givenName_whenCustomerWithNameFoundUsingExists_thenReturnTrue() {
    boolean isJamesPresent = findACustomerInGivenList.findUsingExists("James", customers);
    assertTrue(isJamesPresent);
}

Again, let’s verify that it returns false when it doesn’t find a customer:

@Test
public void givenName_whenCustomerWithNameNotFoundUsingExists_thenReturnFalse() {
    boolean isJohnPresent = findACustomerInGivenList.findUsingExists("John", customers);
    assertFalse(isJohnPresent);
}

Further, a null-valued collection or predicate returns false.

5. Conclusion

In this article, we learned different ways of finding an element in a List, starting with quick existence checks and finishing with field-based searches.

We also looked at the third-party libraries Google Guava and Apache Commons as alternatives to the Java 8 Streams API.