Filtrer le flux Java sur 1 et 1 seul élément

J'essaie d'utiliser Java 8 Streampour trouver des éléments dans a LinkedList. Je veux cependant garantir qu'il y a une et une seule correspondance avec les critères de filtrage.

Prenez ce code:

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

Ce code trouve un Userbasé sur leur ID. Mais rien ne garantit le nombre de Users correspondant au filtre.

Changer la ligne de filtre en:

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

Jettera un NoSuchElementException(bon!)

Je voudrais cependant qu'il génère une erreur s'il existe plusieurs correspondances. Y a-t-il un moyen de faire cela?

Créer un personnalisé 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);
            }
    );
}

Nous utilisons Collectors.collectingAndThenpour construire notre désir Collectorpar

1. Collectionner nos objets en un Listavec le Collectors.toList()collectionneur.
2. Appliquer un finisseur supplémentaire à la fin, qui renvoie l'élément unique - ou lance un IllegalStateExceptionif list.size != 1.

Utilisé comme:

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

Vous pouvez ensuite personnaliser cela Collectorautant que vous le souhaitez, par exemple donner l'exception comme argument dans le constructeur, l'ajuster pour autoriser deux valeurs, et plus encore.

Une solution alternative - sans doute moins élégante -:

Vous pouvez utiliser une solution de contournement qui implique peek()et un AtomicInteger, mais vous ne devriez vraiment pas utiliser cela.

Ce que vous pourriez faire, c'est simplement le collecter dans un List, comme ceci:

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

Par souci d'exhaustivité, voici le «one-liner» correspondant à l'excellente réponse de @ prunge:

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

Cela obtient le seul élément correspondant du flux, jetant

• NoSuchElementException dans le cas où le flux est vide, ou
• IllegalStateException dans le cas où le flux contient plus d'un élément correspondant.

Une variante de cette approche évite de lever une exception plus tôt et représente à la place le résultat comme Optionalcontenant soit le seul élément, soit rien (vide) s'il y a zéro ou plusieurs éléments:

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

Les autres réponses qui impliquent l'écriture d'une coutume Collectorsont probablement plus efficaces (comme celle de Louis Wasserman , +1), mais si vous voulez être bref, je suggère ce qui suit:

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

Vérifiez ensuite la taille de la liste des résultats.

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

La goyave fournit MoreCollectors.onlyElement()ce qui fait la bonne chose ici. Mais si vous devez le faire vous-même, vous pouvez lancer le vôtre Collectorpour cela:

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

... ou en utilisant votre propre Holdertype au lieu de AtomicReference. Vous pouvez le réutiliser Collectorautant que vous le souhaitez.

Utilisez Guava MoreCollectors.onlyElement()( JavaDoc ).

Il fait ce que vous voulez et lance un IllegalArgumentExceptionsi le flux est composé de deux éléments ou plus, et un NoSuchElementExceptionsi le flux est vide.

Usage:

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

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

L'opération "hachure d'échappement" qui vous permet de faire des choses étranges qui ne sont pas autrement prises en charge par les flux consiste à demander 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();
}

La goyave a une méthode pratique pour prendre un Iteratoret obtenir le seul élément, en jetant s'il y a zéro ou plusieurs éléments, ce qui pourrait remplacer les n-1 lignes inférieures ici.

Mettre à jour

Belle suggestion dans le commentaire de @Holger:

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

Réponse originale

L'exception est levée par Optional#get, mais si vous avez plus d'un élément, cela n'aidera pas. Vous pouvez collecter les utilisateurs dans une collection qui n'accepte qu'un seul élément, par exemple:

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

qui jette un java.lang.IllegalStateException: Queue full , mais qui semble trop hacky.

Ou vous pouvez utiliser une réduction combinée avec une option:

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 réduction renvoie essentiellement:

• null si aucun utilisateur n'est trouvé
• l'utilisateur si un seul est trouvé
• lève une exception si plus d'un est trouvé

Le résultat est ensuite enveloppé dans une option.

Mais la solution la plus simple serait probablement de simplement collecter dans une collection, de vérifier que sa taille est de 1 et d'obtenir le seul élément.

Une alternative est d'utiliser la réduction: (cet exemple utilise des chaînes mais pourrait facilement s'appliquer à n'importe quel type d'objet, y compris 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);};
}

Donc, dans le cas où Uservous auriez:

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

Utilisation de réduire

C'est la manière la plus simple et flexible que j'ai trouvée (basée sur la réponse @prunge)

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

De cette façon, vous obtenez:

• l'Optionnel - comme toujours avec votre objet ou Optional.empty()s'il n'est pas présent
• l'exception (avec éventuellement VOTRE type / message personnalisé) s'il y a plus d'un élément

Je pense que cette façon est plus simple:

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

En utilisant 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()
    );
}

Usage:

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

Nous retournons un Optional, car nous ne pouvons généralement pas supposer que le Collectioncontient exactement un élément. Si vous savez déjà que c'est le cas, appelez:

User user = result.orElseThrow();

Cela met le fardeau de gérer l'erreur sur l'appelant - comme il se doit.

La goyave a un Collectorpour cela appelé MoreCollectors.onlyElement().

Nous pouvons utiliser RxJava ( bibliothèque d' extensions réactives très puissante )

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

L' opérateur unique lève une exception si aucun utilisateur ou plus d'un utilisateur n'est trouvé.

Comme Collectors.toMap(keyMapper, valueMapper)utilise une fusion de lancement pour gérer plusieurs entrées avec la même clé, il est 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();

Vous obtiendrez un IllegalStateExceptionpour les clés en double. Mais à la fin, je ne sais pas si le code ne serait pas encore plus lisible en utilisant un if.

J'utilise ces deux collecteurs:

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

Si cela ne vous dérange pas d'utiliser une bibliothèque tierce, à SequenceMpartir de flux cyclops (et LazyFutureStreamde simple-react ), les deux ont des opérateurs single et singleOptional.

singleOptional()lève une exception s'il y a 0ou plus d' 1éléments dans le Stream, sinon il retourne la valeur unique.

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()renvoie Optional.empty()s'il n'y a pas de valeurs ou plus d'une valeur dans le 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

Divulgation - Je suis l'auteur des deux bibliothèques.

Je suis allé avec l'approche directe et je viens de mettre en œuvre la chose:

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


} 

avec le 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<>());
}

}

Cette implémentation n'est pas threadsafe.

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

As-tu essayé

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.

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