Technically there's an ugly 'workaround' that involves peek() and an AtomicInteger, but really you shouldn't be using that.

What I do in these cases is just collecting it in a list, like this:

LinkedList<User> users = new LinkedList<>();

users.add(new User(1, "User1"));

users.add(new User(2, "User2"));

users.add(new User(3, "User3"));

List<User> resultUserList = users.stream()

        .filter(user -> user.getId() == 1)

        .collect(Collectors.toList());

if (resultUserList.size() != 1) {

    throw new IllegalStateException();

}

User resultUser = resultUserList.get(0);

I am not aware of a way to do this in the API, meanwhile I will work on another example involving a custom element.

Update, You should create your own Collector for this:

public static <T> Collector<T, List<T>, T> singletonCollector() {

    return Collector.of(

            ArrayList::new,

            List::add,

            (left, right) -> { left.addAll(right); return left; },

            list -> {

                if (list.size() != 1) {

                    throw new IllegalStateException();

                }

                return list.get(0);

            }

    );

}

What it does is:

• It mimicks the Collectors.toList() collector.
• It applies an extra finisher at the end, that throws an exception, or if no exception, returns the first element of the list.

Used as:

User resultUser = users.stream()

        .filter(user -> user.getId() > 0)

        .collect(singletonCollector());

You can then customize this singletonCollector as much as you want, for example give the exception as argument in the constructor, tweak it to allow two values, and more.

New update, I revised my old answer once more for singletonCollector(), it can actually be obtained like this:

public static <T> Collector<T, ?, T> singletonCollector() {

    return Collectors.collectingAndThen(

            Collectors.toList(),

            list -> {

                if (list.size() != 1) {

                    throw new IllegalStateException();

                }

                return list.get(0);

            }

    );

}

Wow, such complexity! :-) 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.

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 "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.

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.

Have you tried this

    long c = users.stream().filter((user) -> user.getId() == 1).count();

    if(c>1){

        throw new IllegalStateException();

    }

long count()

Returns the count of elements in this stream. This is a special case of a reduction and is equivalent to:

     return mapToLong(e -> 1L).sum();

This is a terminal operation.