Rimuovere il primo elemento (con indice zero) dallo stream in modo condizionale

Ho il seguente codice:

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

Se la stringa del pugno è uguale, "email"voglio rimuovere la prima stringa dallo Stream. Per altre stringhe dello stream non ho bisogno di questo controllo.

Come potrei raggiungerlo?

PS

Certo che posso trasformarlo in elenco, quindi utilizzare la vecchia scuola per il ciclo, ma ulteriormente ho bisogno di nuovo lo streaming.

Mentre il lettore sarà in uno stato non specificato dopo aver costruito un flusso di linee da esso, è in uno stato ben definito prima di farlo.

Quindi puoi farlo

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

Qual è la soluzione più pulita secondo me. Si noti che questo non è lo stesso di Java 9 dropWhile, che lascerebbe cadere più di una riga se corrispondessero.

Se non puoi avere la lista e devi farlo solo con a Stream, puoi farlo con una variabile.

Il fatto è che puoi usare una variabile solo se è "finale" o "effettivamente finale", quindi non puoi usare un valore booleano letterale. Puoi ancora farlo con un 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);

Nota: non mi piace usare "variabili esterne" in un Streamperché gli effetti collaterali sono una cattiva pratica nel paradigma di programmazione funzionale. Le opzioni migliori sono benvenute.

Per evitare di controllare la condizione su ciascuna riga del file, leggo e controllo la prima riga separatamente, quindi eseguo la pipeline su tutte le righe senza verificare la condizione:

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

Più semplice su Java 9+:

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

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

La risposta di @Arnouds è corretta. Puoi creare un flusso per la prima riga e confrontarlo come di seguito,

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

Per filtrare gli elementi in base al loro indice, è possibile utilizzare AtomicIntegerper archiviare e incrementare l'indice durante l'elaborazione di 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]
}

Questo approccio consente di filtrare elementi in qualsiasi indice, non solo nel primo.

Un po 'più contorto, traendo ispirazione da questo frammento .

È possibile creare un Stream<Integer>che rappresenterà gli indici e "comprimerlo" con il proprio Stream<String>per creare unStream<Pair<String, Integer>>

Quindi filtrare utilizzando l'indice e mapparlo nuovamente a 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();
    }
}

Ecco un esempio con Collectors.reducing. Ma alla fine crea comunque un elenco.

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

Prova questo:

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