Filter Java Stream to 1 and only 1 element

For the sake of completeness, here is the ‘one-liner’ corresponding to @prunge’s excellent answer:

User user1 = users.stream() .filter(user -> user.getId() == 1) .reduce((a, b) -> { throw new IllegalStateException("Multiple elements: " + a + ", " + b); }) .get(); 

This obtains the sole matching element from the stream, throwing

• NoSuchElementException in case the stream is empty, or
• IllegalStateException in case the stream contains more than one matching element.

A variation of this approach avoids throwing an exception early and instead represents the result as an Optional containing either the sole element, or nothing (empty) if there are zero or multiple elements:

Optional<User> user1 = users.stream() .filter(user -> user.getId() == 1) .collect(Collectors.reducing((a, b) -> null)); 

Guava provides MoreCollectors.onlyElement() which does the right thing here. But if you have to do it yourself, you could roll your own Collector for this:

<E> Collector<E, ?, Optional<E>> getOnly() { return Collector.of( AtomicReference::new, (ref, e) -> { if (!ref.compareAndSet(null, e)) { throw new IllegalArgumentException("Multiple values"); } }, (ref1, ref2) -> { if (ref1.get() == null) { return ref2; } else if (ref2.get() != null) { throw new IllegalArgumentException("Multiple values"); } else { return ref1; } }, ref -> Optional.ofNullable(ref.get()), Collector.Characteristics.UNORDERED); } 

...or using your own Holder type instead of AtomicReference. You can reuse that Collector as much as you like.

The other answers that involve writing a custom Collector are probably more efficient (such as Louis Wasserman's, +1), but if you want brevity, I'd suggest the following:

List<User> result = users.stream() .filter(user -> user.getId() == 1) .limit(2) .collect(Collectors.toList()); 

Then verify the size of the result list.

if (result.size() != 1) { throw new IllegalStateException("Expected exactly one user but got " + result); } User user = result.get(0); 

Use Guava's MoreCollectors.onlyElement() (source code).

A collector that takes a stream containing exactly one element and returns that element. The returned collector throws an IllegalArgumentException if the stream consists of two or more elements, and a NoSuchElementException if the stream is empty.

This does what you want, throwing an exception if the stream does not contain exactly one element.

Usage:

import static com.google.common.collect.MoreCollectors.onlyElement; User match = users.stream().filter((user) -> user.getId() < 0).collect(onlyElement()); 

The "escape hatch" operation that lets you do weird things that are not otherwise supported by streams is to ask for an Iterator:

Iterator<T> it = users.stream().filter((user) -> user.getId() < 0).iterator(); if (!it.hasNext()) { throw new NoSuchElementException(); } else { result = it.next(); if (it.hasNext()) { throw new TooManyElementsException(); } } 

Guava has a convenience method to take an Iterator and get the only element, throwing if there are zero or multiple elements, which could replace the bottom n-1 lines here.

Update

Nice suggestion in comment from @Holger:

Optional<User> match = users.stream() .filter((user) -> user.getId() > 1) .reduce((u, v) -> { throw new IllegalStateException("More than one ID found") }); 

Original answer

The exception is thrown by Optional#get, but if you have more than one element that won't help. You could collect the users in a collection that only accepts one item, for example:

User match = users.stream().filter((user) -> user.getId() > 1) .collect(toCollection(() -> new ArrayBlockingQueue<User>(1))) .poll(); 

which throws a java.lang.IllegalStateException: Queue full, but that feels too hacky.

Or you could use a reduction combined with an optional:

User match = Optional.ofNullable(users.stream().filter((user) -> user.getId() > 1) .reduce(null, (u, v) -> { if (u != null && v != null) throw new IllegalStateException("More than one ID found"); else return u == null ? v : u; })).get(); 

The reduction essentially returns:

• null if no user is found
• the user if only one is found
• throws an exception if more than one is found

The result is then wrapped in an optional.

But the simplest solution would probably be to just collect to a collection, check that its size is 1 and get the only element.

Using reduce

This is the simpler and flexible way I found (based on @prunge answer)

Optional<User> user = users.stream() .filter(user -> user.getId() == 1) .reduce((a, b) -> { throw new IllegalStateException("Multiple elements: " + a + ", " + b); }) 

This way you obtain:

• the Optional - as always with your object or Optional.empty() if not present
• the Exception (with eventually YOUR custom type/message) if there's more than one element

I think this way is more simple:

User resultUser = users.stream() .filter(user -> user.getId() > 0) .findFirst().get(); 

An alternative is to use reduction: (this example uses strings but could easily apply to any object type including User)

List<String> list = ImmutableList.of("one", "two", "three", "four", "five", "two"); String match = list.stream().filter("two"::equals).reduce(thereCanBeOnlyOne()).get(); //throws NoSuchElementException if there are no matching elements - "zero" //throws RuntimeException if duplicates are found - "two" //otherwise returns the match - "one" ... //Reduction operator that throws RuntimeException if there are duplicates private static <T> BinaryOperator<T> thereCanBeOnlyOne() { return (a, b) -> {throw new RuntimeException("Duplicate elements found: " + a + " and " + b);}; } 

So for the case with User you would have:

User match = users.stream().filter((user) -> user.getId() < 0).reduce(thereCanBeOnlyOne()).get(); 

Guava has a Collector for this called MoreCollectors.onlyElement().

Using a Collector:

public static <T> Collector<T, ?, Optional<T>> singleElementCollector() { return Collectors.collectingAndThen( Collectors.toList(), list -> list.size() == 1 ? Optional.of(list.get(0)) : Optional.empty() ); } 

Usage:

Optional<User> result = users.stream() .filter((user) -> user.getId() < 0) .collect(singleElementCollector()); 

We return an Optional, since we usually can't assume the Collection to contain exactly one element. If you already know this is the case, call:

User user = result.orElseThrow(); 

This puts the burden of handeling the error on the caller - as it should.

Using Reduce and Optional

From Fabio Bonfante response:

public <T> T getOneExample(Collection<T> collection) { return collection.stream() .filter(x -> /* do some filter */) .reduce((x,y)-> {throw new IllegalStateException("multiple");}) .orElseThrow(() -> new NoSuchElementException("none")); } 

We can use RxJava (very powerful reactive extension library)

LinkedList<User> users = new LinkedList<>(); users.add(new User(1, "User1")); users.add(new User(2, "User2")); users.add(new User(3, "User3")); User userFound = Observable.from(users) .filter((user) -> user.getId() == 1) .single().toBlocking().first(); 

The single operator throws an exception if no user or more then one user is found.

As Collectors.toMap(keyMapper, valueMapper) uses a throwing merger to handle multiple entries with the same key it is easy:

List<User> users = new LinkedList<>(); users.add(new User(1, "User1")); users.add(new User(2, "User2")); users.add(new User(3, "User3")); int id = 1; User match = Optional.ofNullable(users.stream() .filter(user -> user.getId() == id) .collect(Collectors.toMap(User::getId, Function.identity())) .get(id)).get(); 

You will get a IllegalStateException for duplicate keys. But at the end I am not sure if the code would not be even more readable using an if.

Starting in JDK 24 (available as a preview in JDK 22 and 23), Stream Gatherers can be used to limit a stream to one and only one element as follows.

A state object tracks the element, if any:

class State<T> { private T element; public boolean accept(T element) { if (this.element != null) { throw new IllegalArgumentException("too many elements"); } this.element = element; return true; } public T element() { if (element == null) { throw new NoSuchElementException("no elements"); } return element; } } 

And a gatherer uses the state to get the only object, if there is one, and pass it downstream, or throw an exception if either a second element is seen or if the end of the stream is reached without any element being seen.

<T> Gatherer<T, State<T>, T> onlyOne() { return Gatherer.ofSequential(State::new, Gatherer.Integrator.ofGreedy((state, element, _) -> { return state.accept(element); }), (state, downstream) -> { downstream.push(state.element()); }); } 

When used like:

users.stream().filter(user -> user.getId() == 1).gather(onlyOne()).findFirst().get() 

It will return the matching user, if there is one, or throw IllegalArgumentException or NoSuchElementException if there are no elements. I chose these to match Guava's MoreCollectors::onlyElement but you can change them to suit your needs.

It is efficient in space and time because it throws as soon as it sees a single duplicate element rather than waiting for all the elements, and it only stores a single reference to the first element seen, unlike solutions that accumulate an entire list.

It does not produce the matching element to the downstream as soon as it sees it but rather produces it in the finisher, so if there is going to be a duplicate element found, by the time it sees it and throws, it will not have already produced the first, matching element. Thus in the case where there are duplicates, you don't get the element and later, the exception. You just get the exception.

I am using those two collectors:

public static <T> Collector<T, ?, Optional<T>> zeroOrOne() { return Collectors.reducing((a, b) -> { throw new IllegalStateException("More than one value was returned"); }); } public static <T> Collector<T, ?, T> onlyOne() { return Collectors.collectingAndThen(zeroOrOne(), Optional::get); } 

If you don't mind using a 3rd party library, SequenceM from cyclops-streams (and LazyFutureStream from simple-react) both a have single & singleOptional operators.

singleOptional() throws an exception if there are 0 or more than 1 elements in the Stream, otherwise it returns the single value.

String result = SequenceM.of("x") .single(); SequenceM.of().single(); // NoSuchElementException SequenceM.of(1, 2, 3).single(); // NoSuchElementException String result = LazyFutureStream.fromStream(Stream.of("x")) .single(); 

singleOptional() returns Optional.empty() if there are no values or more than one value in the Stream.

Optional<String> result = SequenceM.fromStream(Stream.of("x")) .singleOptional(); //Optional["x"] Optional<String> result = SequenceM.of().singleOptional(); // Optional.empty Optional<String> result = SequenceM.of(1, 2, 3).singleOptional(); // Optional.empty 

Disclosure - I am the author of both libraries.

 List<Integer> list = new ArrayList<>(); list.add(1); list.add(2); list.add(3); Integer value = list.stream().filter((x->x.intValue()==8)).findFirst().orElse(null); 

I have used Integer type instead of primitive as it will have null pointer exception. you just have to handle this exception... looks succinct, I think ;)

If you don't use Guava or Kotlin, here's a solution based on @skiwi and @Neuron answers.

users.stream().collect(single(user -> user.getId() == 1)); 

or

users.stream().collect(optional(user -> user.getId() == 1)); 

where single and optional are statically imported functions returning corresponding collectors.

I reasoned it would look more succinct if the filtering logic had been moved inside the collector. Also nothing would break in the code if you happened to delete the string with .filter.

The gist for the code https://gist.github.com/overpas/ccc39b75f17a1c65682c071045c1a079

Tried a sample code for my self and here is the solution for that.

User user = Stream.of(new User(2), new User(2), new User(1), new User(2)) .filter(u -> u.getAge() == 2).findFirst().get(); 

and the user class

class User { private int age; public User(int age) { this.age = age; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } } 

public List<state> getAllActiveState() { List<Master> master = masterRepository.getActiveExamMasters(); Master activeMaster = new Master(); try { activeMaster = master.stream().filter(status -> status.getStatus() == true).reduce((u, v) -> { throw new IllegalStateException(); }).get(); return stateRepository.getAllStateActiveId(activeMaster.getId()); } catch (IllegalStateException e) { logger.info(":More than one status found TRUE in Master"); return null; } } 

1. In this above code, As per the condition if its find more than one true in the list then it will through the exception.
2. When it through the error will showing custom message because it easy maintain the logs on server side.
3. From Nth number of element present in list just want only one element have true condition if in list there are more than one elements having true status at that moment it will through an exception.
4. after getting all the this we using get(); to taking that one element from list and stored it into another object.
5. If you want you added optional like Optional<activeMaster > = master.stream().filter(status -> status.getStatus() == true).reduce((u, v) -> {throw new IllegalStateException();}).get();

Here’s another version in which I fixed some minor issues.

Advantages:

• Does not scan the entire stream if it contains more than one element (early termination).
• Does not ignore null values in the stream; they are properly accounted for.
• Subjectively good readability.
• Works correctly with parallelStream(), ensuring proper merging of results.

Usage:

Optional<String> single = Stream.of("a").collect(toSingle()); 

Code:

public class SingleUtils { public static <T> Collector<T, ?, Optional<T>> toSingle() { return Collector.of( // Container: { value, counter } () -> new Container<T>(), // Add element (container, element) -> { int count = container.count; if (count > 0) { throw new IllegalStateException("Stream contains more than one element"); } container.value = element; container.count++; }, // Combine parts (used by parallelStream()) (left, right) -> { int leftCount = left.count; int rightCount = right.count; if (leftCount + rightCount > 1) { throw new IllegalStateException("Stream contains more than one element"); } return leftCount > 0 ? left : right; }, // Final mapping container -> Optional.ofNullable(container.value) ); } static class Container<T> { T value; int count; } } 

Unit Tests:

@Test void toSingle_readsStreamOnlyOnce() { AtomicInteger counter = new AtomicInteger(42); IntStream stream = IntStream.generate(counter::getAndIncrement); // Will generate an "unlimited" sequence 42, 43, 44, ... MAX_INT - 1 assertThrows(IllegalStateException.class, () -> stream.mapToObj(Integer.class::cast).collect(SingleUtils.toSingle())); // First time take 42 and increment to 43 // Second time take 43 and increment to 44, then throw exception assertEquals(44, counter.get()); } @Test void toSingle_mixedNullAndValueStream_throwsIllegalStateException() { List<Integer> mixedList = new ArrayList<>(); mixedList.add(1); mixedList.add(null); assertThrows(IllegalStateException.class, () -> mixedList.stream().collect(toSingle())); } @Test void toSingle_parallelStream_singleElement_returnsOptionalWithValue() { List<Integer> list = List.of(42); Optional<Integer> result = list.parallelStream().collect(toSingle()); assertTrue(result.isPresent()); assertEquals(42, result.get()); } @Test void toSingle_parallelStream_multipleElements_throwsIllegalStateException() { List<Integer> list = List.of(4, 2); assertThrows(IllegalStateException.class, () -> list.parallelStream().collect(toSingle())); } 

User match = users.stream().filter((user) -> user.getId()== 1).findAny().orElseThrow(()-> new IllegalArgumentException()); 

Inspired by @skiwi, I solved it the following way:

public static <T> T toSingleton(Stream<T> stream) { List<T> list = stream.limit(1).collect(Collectors.toList()); if (list.isEmpty()) { return null; } else { return list.get(0); } } 

And then:

User user = toSingleton(users.stream().filter(...).map(...));