Filtra Java Stream su 1 e solo 1 elemento

Sto cercando di usare Java 8 Streams per trovare elementi in a LinkedList. Voglio garantire, tuttavia, che esiste una e una sola corrispondenza ai criteri di filtro.

Prendi questo codice:

public static void main(String[] args) {

    LinkedList<User> users = new LinkedList<>();
    users.add(new User(1, "User1"));
    users.add(new User(2, "User2"));
    users.add(new User(3, "User3"));

    User match = users.stream().filter((user) -> 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;
    }
}

Questo codice trova un in Userbase al loro ID. Ma non ci sono garanzie sul numero di Users corrispondenti al filtro.

Modifica della linea del filtro in:

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

Lancerà un NoSuchElementException(buono!)

Vorrei che generasse un errore se ci sono più partite, però. C'è un modo per fare questo?

Crea un'abitudine Collector

public static <T> Collector<T, ?, T> toSingleton() {
    return Collectors.collectingAndThen(
            Collectors.toList(),
            list -> {
                if (list.size() != 1) {
                    throw new IllegalStateException();
                }
                return list.get(0);
            }
    );
}

Usiamo Collectors.collectingAndThenper costruire il nostro desiderato Collectorda

1. Collezionare i nostri oggetti in a Listcon il Collectors.toList()collezionista.
2. Applicando un finisher aggiuntivo alla fine, che restituisce il singolo elemento - o genera un IllegalStateExceptionif list.size != 1.

Usato come:

User resultUser = users.stream()
        .filter(user -> user.getId() > 0)
        .collect(toSingleton());

È quindi possibile personalizzare ciò Collectorquanto si desidera, ad esempio fornire l'eccezione come argomento nel costruttore, modificarlo per consentire due valori e altro.

Un'alternativa - probabilmente meno elegante - soluzione:

Puoi usare una "soluzione alternativa" che coinvolge peek()e un AtomicInteger, ma in realtà non dovresti usarlo.

Quello che potresti fare è semplicemente raccoglierlo in un List, come questo:

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);

Per completezza, ecco il 'one-liner' corrispondente alla risposta eccellente di @ prunge:

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

Questo ottiene l'unico elemento corrispondente dallo stream, lanciando

• NoSuchElementException nel caso in cui il flusso sia vuoto, oppure
• IllegalStateException nel caso in cui il flusso contenga più di un elemento corrispondente.

Una variante di questo approccio evita di lanciare un'eccezione in anticipo e rappresenta invece il risultato come Optionalcontenente il solo elemento o nulla (vuoto) se ci sono zero o più elementi:

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

Le altre risposte che comportano la scrittura di un'abitudine Collectorsono probabilmente più efficienti (come Louis Wasserman , +1), ma se si desidera la brevità, suggerirei quanto segue:

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

Quindi verificare la dimensione dell'elenco dei risultati.

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

Guava fornisce ciò MoreCollectors.onlyElement()che fa la cosa giusta qui. Ma se devi farlo da solo, puoi farlo da solo Collector:

<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);
}

... o usando il tuo Holdertipo invece di AtomicReference. Puoi riutilizzarlo Collectorquanto vuoi.

Usa Guava MoreCollectors.onlyElement()( JavaDoc ).

Fa quello che vuoi e genera un IllegalArgumentExceptionse il flusso è composto da due o più elementi e un NoSuchElementExceptionse il flusso è vuoto.

Uso:

import static com.google.common.collect.MoreCollectors.onlyElement;

User match =
    users.stream().filter((user) -> user.getId() < 0).collect(onlyElement());

L'operazione "tratteggio di escape" che ti consente di fare cose strane che altrimenti non sono supportate dagli stream è di chiedere un 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 ha un metodo pratico per prendere un Iteratore ottenere l'unico elemento, lanciando se ci sono zero o più elementi, che potrebbero sostituire qui le righe n-1 inferiori.

Aggiornare

Bel suggerimento nel commento di @Holger:

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

Risposta originale

L'eccezione viene generata da Optional#get, ma se hai più di un elemento che non ti aiuterà. È possibile raccogliere gli utenti in una raccolta che accetta solo un elemento, ad esempio:

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

che genera un java.lang.IllegalStateException: Queue full, ma sembra troppo confuso.

Oppure potresti usare una riduzione combinata con un 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();

La riduzione essenzialmente restituisce:

• null se non viene trovato nessun utente
• l'utente se ne viene trovato solo uno
• genera un'eccezione se ne viene trovata più di una

Il risultato viene quindi racchiuso in un facoltativo.

Ma la soluzione più semplice sarebbe probabilmente quella di raccogliere solo in una collezione, verificare che la sua dimensione sia 1 e ottenere l'unico elemento.

Un'alternativa è usare la riduzione: (questo esempio usa stringhe ma potrebbe facilmente applicarsi a qualsiasi tipo di oggetto incluso 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);};
}

Quindi per il caso con Userte avresti:

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

Utilizzando ridurre

Questo è il modo più semplice e flessibile che ho trovato (basato sulla risposta di @prunge)

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

In questo modo ottieni:

• l'Opzionale - come sempre con il tuo oggetto o Optional.empty()se non presente
• l'eccezione (con eventualmente il TUO tipo / messaggio personalizzato) se c'è più di un elemento

Penso che in questo modo sia più semplice:

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

Utilizzando un Collector:

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

Uso:

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

Restituiamo un Optional, poiché di solito non possiamo supporre Collectionche contenga esattamente un elemento. Se sai già che è così, chiama:

User user = result.orElseThrow();

Ciò comporta l'onere di gestire l'errore sul chiamante, come dovrebbe.

Guava ha un Collectorper questo chiamato MoreCollectors.onlyElement().

Possiamo usare RxJava ( libreria di estensioni reattive molto potente )

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();

Il singolo operatore genera un'eccezione se non viene trovato nessun utente o più di un utente.

Poiché Collectors.toMap(keyMapper, valueMapper)utilizza una fusione di lancio per gestire più voci con la stessa chiave, è facile:

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();

Riceverai una IllegalStateExceptionchiave duplicata. Ma alla fine non sono sicuro che il codice non sarebbe ancora più leggibile usando un if.

Sto usando quei due collezionisti:

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);
}

Se non ti dispiace usare una libreria di terze parti, SequenceMdai flussi di ciclopi (e LazyFutureStreamdalla reazione semplice ) entrambi hanno operatori single e singleOptional.

singleOptional()genera un'eccezione se ci sono 0o più di 1elementi in Stream, altrimenti restituisce il singolo valore.

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()ritorna Optional.empty()se non ci sono valori o più di un valore in 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

Divulgazione - Sono l'autore di entrambe le biblioteche.

Sono andato con l'approccio diretto e ho appena implementato la cosa:

public class CollectSingle<T> implements Collector<T, T, T>, BiConsumer<T, T>, Function<T, T>, Supplier<T> {
T value;

@Override
public Supplier<T> supplier() {
    return this;
}

@Override
public BiConsumer<T, T> accumulator() {
    return this;
}

@Override
public BinaryOperator<T> combiner() {
    return null;
}

@Override
public Function<T, T> finisher() {
    return this;
}

@Override
public Set<Characteristics> 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;
}


} 

con il test JUnit:

public class CollectSingleTest {

@Test
public void collectOne( ) {
    List<Integer> lst = new ArrayList<>();
    lst.add(7);
    Integer o = lst.stream().collect( new CollectSingle<>());
    System.out.println(o);
}

@Test(expected = UnsupportedOperationException.class)
public void failOnTwo( ) {
    List<Integer> lst = new ArrayList<>();
    lst.add(7);
    lst.add(8);
    Integer o = lst.stream().collect( new CollectSingle<>());
}

}

Questa implementazione non è sicura.

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

Hai provato questo

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.

Fonte: https://docs.oracle.com/javase/8/docs/api/java/util/stream/Stream.html