Filter Java Stream to 1 and only 1 element

Question

I am trying to use Java 8 Streams to find elements in a LinkedList  I want to guarantee  however  that there is one and only one match to the filter criteria   Take this code   public static void main String   args         LinkedList lt User gt  users   new LinkedList lt  gt         users add new User 1   User1         users add new User 2   User2         users add new User 3   User3          User match   users stream   filter  user  - gt  user getId      1  findAny   get        System out println match toString           static class User         Override     public String toString             return id     -     username             int id      String username       public User                public User int id  String username            this id   id          this username   username             public void setUsername String username            this username   username             public void setId int id            this id   id             public String getUsername             return username             public int getId             return id            This code finds a User based on their ID  But there are no guarantees how many Users matched the filter   Changing the filter line to   User match   users stream   filter  user  - gt  user getId    lt  0  findAny   get      Will throw a NoSuchElementException  good    I would like it to throw an error if there are multiple matches  though  Is there a way to do this

User · Answer

Update  Nice suggestion in comment from  Holger   Optional lt User gt  match   users stream                  filter  user  - gt  user getId    gt  1                 reduce  u  v  - gt    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  - gt  user getId    gt  1                     collect toCollection    - gt  new ArrayBlockingQueue lt User gt  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  - gt  user getId    gt  1                   reduce null   u  v  - gt                        if  u    null  amp  amp  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

User · Answer

As Collectors toMap keyMapper  valueMapper  uses a throwing merger to handle multiple entries with the same key it is easy   List lt User gt  users   new LinkedList lt  gt     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 - gt  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

User · Answer

We can use RxJava  very powerful reactive extension library   LinkedList lt User gt  users   new LinkedList lt  gt     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  - gt  user getId      1                     single   toBlocking   first      The single operator throws an exception if no user or more then one user is found

User · Answer

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    lt E gt  Collector lt E     Optional lt E gt  gt  getOnly       return Collector of      AtomicReference  new       ref  e  - gt          if   ref compareAndSet null  e              throw new IllegalArgumentException  Multiple values                        ref1  ref2  - gt          if  ref1 get      null            return ref2          else if  ref2 get      null            throw new IllegalArgumentException  Multiple values            else           return ref1                     ref - gt  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

User · Answer

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 lt User gt  result   users stream        filter user - gt  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

User · Answer

Have you tried this  long c   users stream   filter  user  - gt  user getId      1  count    if c  gt  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 - gt  1L  sum     This is a terminal operation    Source  https   docs oracle com javase 8 docs api java util stream Stream html

User · Answer

Using reduce  This is the simpler and flexible way I found  based on  prunge answer   Optional lt User gt  user   users stream            filter user - gt  user getId      1           reduce  a  b  - gt                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

User · Answer

Using a Collector  public static  lt T gt  Collector lt T     Optional lt T gt  gt  toSingleton         return Collectors collectingAndThen              Collectors toList                list - gt  list size      1   Optional of list get 0     Optional empty              Usage  Optional lt User gt  result   users stream            filter  user  - gt  user getId    lt  0           collect toSingleton       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

User · Answer

Inspired by  skiwi  I solved it the following way  public static  lt T gt  T toSingleton Stream lt T gt  stream        List lt T gt  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

User · Answer

If you don t mind using a 3rd party library  SequenceM from cyclops-streams  and LazyFutureStream from simple-react  both a have single  amp  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 lt String gt  result   SequenceM fromStream Stream of  x                               singleOptional       Optional  x    Optional lt String gt  result   SequenceM of   singleOptional        Optional empty  Optional lt String gt  result    SequenceM of 1  2  3  singleOptional        Optional empty     Disclosure - I am the author of both libraries

User · Answer

I am using those two collectors   public static  lt T gt  Collector lt T     Optional lt T gt  gt  zeroOrOne         return Collectors reducing  a  b  - gt            throw new IllegalStateException  More than one value was returned               public static  lt T gt  Collector lt T     T gt  onlyOne         return Collectors collectingAndThen zeroOrOne    Optional  get

User · Answer

I think this way is more simple   User resultUser   users stream        filter user - gt  user getId    gt  0       findFirst   get

User · Answer

An alternative is to use reduction   this example uses strings but could easily apply to any object type including User   List lt String gt  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  lt T gt  BinaryOperator lt T gt  thereCanBeOnlyOne         return  a  b  - gt   throw new RuntimeException  Duplicate elements found      a     and     b         So for the case with User you would have   User match   users stream   filter  user  - gt  user getId    lt  0  reduce thereCanBeOnlyOne    get

User · Answer

User match   users stream   filter  user  - gt  user getId     1  findAny   orElseThrow   - gt  new IllegalArgumentException

User · Answer

Create a custom Collector public static  lt T gt  Collector lt T     T gt  toSingleton         return Collectors collectingAndThen              Collectors toList                list - gt                    if  list size      1                        throw new IllegalStateException                                      return list get 0                           We use Collectors collectingAndThen to construct our desired Collector by  Collecting our objects in a List with the Collectors toList   collector  Applying an extra finisher at the end  that returns the single element     or throws an IllegalStateException if list size    1   Used as  User resultUser   users stream            filter user - gt  user getId    gt  0           collect toSingleton      You can then customize this Collector as much as you want  for example give the exception as argument in the constructor  tweak it to allow two values  and more  An alternative     arguably less elegant     solution  You can use a  workaround  that involves peek   and an AtomicInteger  but really you shouldn t be using that  What you could do istead is just collecting it in a List  like this  LinkedList lt User gt  users   new LinkedList lt  gt     users add new User 1   quot User1 quot     users add new User 2   quot User2 quot     users add new User 3   quot User3 quot     List lt User gt  resultUserList   users stream            filter user - gt  user getId      1           collect Collectors toList     if  resultUserList size      1        throw new IllegalStateException      User resultUser   resultUserList get 0

User · Answer

If you don t use Guava or Kotlin  here s a solution based on  skiwi and  Neuron answers  users stream   collect single user - gt  user getId      1     or users stream   collect optional user - gt  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

User · Answer

The  escape hatch  operation that lets you do weird things that are not otherwise supported by streams is to ask for an Iterator   Iterator lt T gt  it   users stream   filter  user  - gt  user getId    lt  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

User · Answer

For the sake of completeness  here is the    one-liner    corresponding to  prunge   s excellent answer   User user1   users stream            filter user - gt  user getId      1           reduce  a  b  - gt                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 lt User gt  user1   users stream            filter user - gt  user getId      1           collect Collectors reducing  a  b  - gt  null

User · Answer

I went with the direct-approach and just implemented the thing   public class CollectSingle lt T gt  implements Collector lt T  T  T gt   BiConsumer lt T  T gt   Function lt T  T gt   Supplier lt T gt    T value    Override public Supplier lt T gt  supplier         return this      Override public BiConsumer lt T  T gt  accumulator         return this      Override public BinaryOperator lt T gt  combiner         return null      Override public Function lt T  T gt  finisher         return this      Override public Set lt Characteristics gt  characteristics         return Collections emptySet        Override   accumulator public void accept T ignore  T nvalue        if  value    null            throw new UnsupportedOperationException  Collect single only supports single element                      value     and     nvalue     found               value   nvalue      Override   supplier public T get         value   null    reset for reuse     return value      Override   finisher public T apply T t        return value           with the JUnit test   public class CollectSingleTest     Test public void collectOne          List lt Integer gt  lst   new ArrayList lt  gt         lst add 7       Integer o   lst stream   collect  new CollectSingle lt  gt          System out println o       Test expected   UnsupportedOperationException class  public void failOnTwo          List lt Integer gt  lst   new ArrayList lt  gt         lst add 7       lst add 8       Integer o   lst stream   collect  new CollectSingle lt  gt             This implementation not threadsafe

User · Answer

Guava has a Collector for this called MoreCollectors onlyElement

User · Answer

Use Guava s MoreCollectors onlyElement    JavaDoc   It does what you want and throws an IllegalArgumentException if the stream consists of two or more elements  and a NoSuchElementException if the stream is empty  Usage  import static com google common collect MoreCollectors onlyElement   User match       users stream   filter  user  - gt  user getId    lt  0  collect onlyElement

[java] Filter Java Stream to 1 and only 1 element

Update

Original answer

Examples related to java

Examples related to lambda

Examples related to java-8

Examples related to java-stream