Check if an Element Is Present in a Set in Java

1. Overview

In this short tutorial, we’ll cast light on how to check if an element is present in a Set in Java.

First, we’ll kick things off by exploring solutions using core JDK. Then, we’ll elucidate how to achieve the same outcome using external libraries such as Apache Commons.

2. Using Core JDK

Java provides several convenient ways to check whether a Set contains a given element. Let’s explore these and see how to use them in practice.

2.1. Set#contains() Method

As the name implies, this method checks if a specific Set contains the given element. It’s one of the easiest solutions that we can use to answer our central question:

@Test
void givenASet_whenUsingContainsMethod_thenCheck() {
    assertThat(CITIES.contains("London")).isTrue();
    assertThat(CITIES.contains("Madrid")).isFalse();
}

Typically, the contains() method returns true if the given element is present in the Set, and false otherwise.

According to the documentation, the method returns true if and only:

object==null ? element==null : object.equals(element);

This is why it’s important to implement the equals() method within the class to which the Set objects belong. That way, we can customize the equality logic to account for either all or some of the class fields.

In short, the contains() method offers the most concise and straightforward way to check if an element is present in a given Set compared to the other methods.

2.2. Collections#disjoint() Method

The Collections utility class provides another method, called disjoint(), that we can use to check if a Set contains a given element.

This method accepts two collections as parameters and returns true if they have no elements in common:

@Test
public void givenASet_whenUsingCollectionsDisjointMethod_thenCheck() {
    boolean isPresent = !Collections.disjoint(CITIES, Collections.singleton("Paris"));
    assertThat(isPresent).isTrue();
}

Overall, we created an immutable Set containing only the given string “Paris”. Furthermore, we used the disjoint() method with the negation operator to check whether the two collections have elements in common.

2.3. Stream#anyMatch() Method

The Stream API offers the anyMatch() method that we can use to verify if any element of a given collection matches the provided predicate.

So, let’s see it in action:

class CheckIfPresentInSetUnitTest {
    private static final Set<String> CITIES = new HashSet<>();
    @BeforeAll
    static void setup() {
        CITIES.add("Paris");
        CITIES.add("London");
        CITIES.add("Tokyo");
        CITIES.add("Tamassint");
        CITIES.add("New york");
    }
    @Test
    void givenASet_whenUsingStreamAnyMatchMethod_thenCheck() {
        boolean isPresent = CITIES.stream()
          .anyMatch(city -> city.equals("London"));
        assertThat(isPresent).isTrue();
    }
}

As we can see, we used the predicate city.equals(“London”) to check if there is any city in the stream that matches the condition of being equal to “London”.

2.4. Stream#filter() Method

Another solution would be using the filter() method. It returns a new stream consisting of elements that satisfy the provided condition.

In other words, it filters the stream based on the specified condition:

@Test
void givenASet_whenUsingStreamFilterMethod_thenCheck() {
    long resultCount = CITIES.stream()
      .filter(city -> city.equals("Tamassint"))
      .count();
    assertThat(resultCount).isPositive();
}

As shown above, we filtred our Set to include only elements that are equal to the value “Tamassint”. Then, we used the terminal operation count() to return the number of the filtered elements.

3. Using Apache Commons Collections

The Apache Commons Collections library is another option to consider if we want to check if a given element is present in a Set. Let’s start by adding its dependency to the pom.xml file:

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-collections4</artifactId>
    <version>4.4</version>
</dependency>

3.1. CollectionUtils#containsAny() Method

CollectionUtils provides a set of utility methods to perform common operations on collections. Among these methods, we find containsAny(Collection<?> coll1, Collection<?> coll2). This method returns true if at least one element of the second collection is also contained in the first collection.

So, let’s see it in action:

@Test
void givenASet_whenUsingCollectionUtilsContainsAnyMethod_thenCheck() {
    boolean isPresent = CollectionUtils.containsAny(CITIES, Collections.singleton("Paris"));
    assertThat(isPresent).isTrue();
}

Similarly, we created a singleton Set containing one element, “Paris”. Then, we used the containsAny() method to check if our collection CITIES contains the given value “Paris”.

3.2. SetUtils#intersection() Method

Alternatively, we can use the SetUtils utility class to tackle our challenge. This class offers the intersection(Set<? extends E> a, Set<? extends E> b) method that returns a new Set containing elements that are both present in the specified two Sets:

@Test
void givenASet_whenUsingSetUtilsIntersectionMethod_thenCheck() {
    Set<String> result = SetUtils.intersection(CITIES, Collections.singleton("Tamassint"));
    assertThat(result).isNotEmpty();
}

In a nutshell, the idea here is to verify whether the city “Tamassint” is present in CITIES by checking if the intersection between CITIES and the given singleton Set is not empty.

4. Conclusion

In this short article, we explored the nitty-gritty of how to check if a Set contains a given element in Java.

First, we saw how to do this using ready-to-use JDK methods. Then, we demonstrated how to accomplish the same goal using the Apache Commons Collections library.

As always, the code used in this article can be found over on GitHub.