Supprimer le premier élément (avec un index nul) du flux de manière conditionnelle

J'ai le code suivant:

Stream<String> lines = reader.lines();

Si la première chaîne est égale à, "email"je veux supprimer la première chaîne du flux. Pour les autres chaînes du flux, je n'ai pas besoin de cette vérification.

Comment pourrais-je y parvenir?

PS

Bien sûr, je peux le transformer en liste, puis utiliser la vieille école pour la boucle, mais j'ai encore besoin de diffuser à nouveau.

Bien que le lecteur soit dans un état non spécifié après que vous en ayez construit un flux de lignes, il est dans un état bien défini avant de le faire.

Vous pouvez donc faire

String firstLine = reader.readLine();
Stream<String> lines = reader.lines();
if(firstLine != null && !"email".equals(firstLine))
    lines = Stream.concat(Stream.of(firstLine), lines);

Quelle est la solution la plus propre à mon avis. Notez que ce n'est pas la même chose que Java 9 dropWhile, qui laisserait tomber plus d'une ligne si elles correspondent.

Si vous ne pouvez pas avoir la liste et devez le faire avec seulement un Stream, vous pouvez le faire avec une variable.

Le fait est que vous ne pouvez utiliser une variable que si elle est "finale" ou "effectivement finale", vous ne pouvez donc pas utiliser un booléen littéral. Vous pouvez toujours le faire avec AtomicBoolean:

Stream<String> stream  = Arrays.asList("test", "email", "foo").stream();

AtomicBoolean first = new AtomicBoolean(true);
stream.filter(s -> {
    if (first.compareAndSet(true, false)) {
        return !s.equals("email");
    }
    return true;
})
// Then here, do whatever you need
.forEach(System.out::println);

Remarque: Je n'aime pas utiliser des "variables externes" dans un Streamcar les effets secondaires sont une mauvaise pratique dans le paradigme de programmation fonctionnelle. De meilleures options sont les bienvenues.

Pour éviter de vérifier la condition sur chaque ligne du fichier, je voudrais simplement lire et vérifier la première ligne séparément, puis exécuter le pipeline sur le reste des lignes sans vérifier la condition:

String first = reader.readLine();
Stream<String> firstLines = Optional.of(first)
        .filter(s -> !"email".equals(s))
        .map(s -> Stream.of(s))
        .orElseGet(() -> Stream.empty());

Stream<String> lines = Stream.concat(firstLines, reader.lines());

Plus simple sur Java 9+:

Stream<String> firstLines = Optional.of(first)
        .filter(s -> !"email".equals(s))
        .stream();

Stream<String> lines = Stream.concat(firstLines, reader.lines());

La réponse @Arnouds est correcte. Vous pouvez créer un flux pour la première ligne, puis comparer comme ci-dessous,

Stream<String> firstLineStream = reader.lines().limit(1).filter(line -> !line.startsWith("email"));;
Stream<String> remainingLinesStream = reader.lines().skip(1);
Stream.concat(firstLineStream, remainingLinesStream);

Pour filtrer les éléments en fonction de leur index, vous pouvez utiliser AtomicIntegerpour stocker et incrémenter l'index lors du traitement d'un Stream:

private static void filter(Stream<String> stream) {
  AtomicInteger index = new AtomicInteger();
  List<String> result = stream
      .filter(el -> {
        int i = index.getAndIncrement();
        return i > 0 || (i == 0 && !"email".equals(el));
      })
      .collect(toList());
  System.out.println(result);
}

public static void main(String[] args) {
  filter(Stream.of("email", "test1", "test2", "test3")); 
  //[test1, test2, test3]

  filter(Stream.of("test1", "email", "test2", "test3")); 
  //[test1, email, test2, test3]

  filter(Stream.of("test1", "test2", "test3")); 
  //[test1, test2, test3]
}

Cette approche permet de filtrer les éléments à n'importe quel index, pas seulement le premier.

Un peu plus compliqué, s'inspirant de cet extrait .

Vous pouvez créer un Stream<Integer>qui représentera les index et le "zip" avec votre Stream<String>pour créer unStream<Pair<String, Integer>>

Filtrez ensuite à l'aide de l'index et mappez-le sur un Stream<String>

public static void main(String[] args) {
    Stream<String> s = reader.lines();
    Stream<Integer> indexes = Stream.iterate(0, i -> i + 1);

    zip(s, indexes)
        .filter(pair -> !(pair.getKey().equals("email") && pair.getValue() == 0))
        .map(Pair::getKey)
        .forEach(System.out::println);
}

private static Stream<Pair<String,Integer>> zip(Stream<String> stringStream, Stream<Integer> indexesStream){
    Iterable<Pair<String,Integer>> iterable = () -> new ZippedWithIndexIterator(stringStream.iterator(), indexesStream.iterator());
    return StreamSupport.stream(iterable.spliterator(), false);
}

static class ZippedWithIndexIterator implements Iterator<Pair<String, Integer>> {
    private final Iterator<String> stringIterator;
    private final Iterator<Integer> integerIterator;

    ZippedWithIndexIterator(Iterator<String> stringIterator, Iterator<Integer> integerIterator) {
        this.stringIterator = stringIterator;
        this.integerIterator = integerIterator;
    }
    @Override
    public Pair<String, Integer> next() {
        return new Pair<>(stringIterator.next(), integerIterator.next());
    }
    @Override
    public boolean hasNext() {
        return stringIterator.hasNext() && integerIterator.hasNext();
    }
}

Voici un exemple avec Collectors.reducing. Mais à la fin crée une liste de toute façon.

Stream<String> lines = Arrays.asList("email", "aaa", "bbb", "ccc")
        .stream();

List reduceList = (List) lines
        .collect(Collectors.reducing( new ArrayList<String>(), (a, v) -> {
                    List list = (List) a;
                    if (!(list.isEmpty() && v.equals("email"))) {
                        list.add(v);
                    }
                    return a;
                }));

reduceList.forEach(System.out::println);

Essaye ça:

MutableBoolean isFirst = MutableBoolean.of(true);
lines..dropWhile(e -> isFirst.getAndSet(false) && "email".equals(e))