Entfernen Sie das erste Element (mit dem Index Null) bedingt aus dem Stream

Ich habe folgenden Code:

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

Wenn die erste Zeichenfolge gleich ist, "email"möchte ich die erste Zeichenfolge aus dem Stream entfernen. Für andere Strings aus dem Stream brauche ich diese Prüfung nicht.

Wie könnte ich es erreichen?

PS

Sicher kann ich es in die Liste umwandeln und dann die alte Schule für die Schleife verwenden, aber weiter brauche ich wieder Stream.

Während sich der Leser in einem nicht spezifizierten Zustand befindet, nachdem Sie einen Zeilenstrom daraus erstellt haben, befindet er sich in einem genau definierten Zustand, bevor Sie dies tun.

So können Sie tun

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

Welches ist die sauberste Lösung meiner Meinung nach. Beachten Sie, dass dies nicht mit Java 9 identisch ist dropWhile, bei dem mehr als eine Zeile gelöscht wird, wenn sie übereinstimmen.

Wenn Sie die Liste nicht haben können und es nur mit einem tun müssen Stream mit a ausführen , können Sie sie mit einer Variablen ausführen.

Die Sache ist, dass Sie eine Variable nur verwenden können, wenn sie "final" oder "effektiv final" ist, sodass Sie keinen wörtlichen Booleschen Wert verwenden können. Sie können es immer noch mit einem 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);

Hinweis: Ich mag es nicht, "externe Variablen" in einem zu verwenden, Streamda Nebenwirkungen eine schlechte Praxis im Paradigma der funktionalen Programmierung sind. Bessere Optionen sind willkommen.

Um zu vermeiden, dass die Bedingung in jeder Zeile der Datei überprüft wird, habe ich einfach die erste Zeile separat gelesen und überprüft und dann die Pipeline in den restlichen Zeilen ausgeführt, ohne die Bedingung zu überprüfen:

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

Einfacher auf Java 9+:

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

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

@ Arnouds Antwort ist richtig. Sie können einen Stream für die erste Zeile erstellen und dann wie folgt vergleichen:

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

Um Elemente basierend auf ihrem Index zu filtern, können Sie den Index AtomicIntegerspeichern und erhöhen, während Sie Folgendes verarbeiten 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]
}

Dieser Ansatz ermöglicht das Filtern von Elementen an jedem Index, nicht nur am ersten.

Etwas komplizierter, um sich von diesem Ausschnitt inspirieren zu lassen .

Sie können eine erstellen Stream<Integer>, die Indizes darstellt, und diese mit Ihrer "komprimieren"Stream<String> , um ein zu erstellenStream<Pair<String, Integer>>

Filtern Sie dann anhand des Index und ordnen Sie ihn wieder a zu 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();
    }
}

Hier ist ein Beispiel mit Collectors.reducing. Aber am Ende wird trotzdem eine Liste erstellt.

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

Versuche dies:

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