Eliminar el primer elemento (con índice cero) de la secuencia condicionalmente

Tengo el siguiente código:

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

Si la cadena del primer puño es igual "email", quiero eliminar la primera cadena del flujo. Para otras cadenas de la secuencia, no necesito esta verificación.

¿Cómo podría lograrlo?

PD

Claro que puedo transformarlo en la lista, luego usar la vieja escuela para el bucle, pero además necesito transmitir nuevamente.

Si bien el lector estará en un estado no especificado después de que construyó una secuencia de líneas a partir de él, está en un estado bien definido antes de hacerlo.

Entonces puedes hacer

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

Cuál es la solución más limpia en mi opinión. Tenga en cuenta que esto no es lo mismo que Java 9 dropWhile, que dejaría caer más de una línea si coinciden.

Si no puede tener la lista y debe hacerlo solo con a Stream, puede hacerlo con una variable.

La cuestión es que solo puede usar una variable si es "final" o "efectivamente final", por lo que no puede usar un booleano literal. Aún puedes hacerlo 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: No me gusta usar "variables externas" Streamporque los efectos secundarios son una mala práctica en el paradigma de programación funcional. Mejores opciones son bienvenidas.

Para evitar verificar la condición en cada línea del archivo, simplemente leía y verificaba la primera línea por separado, luego ejecutaba la tubería en el resto de las líneas sin verificar la condición:

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

Más simple en Java 9+:

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

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

La respuesta de @Arnouds es correcta. Puede crear una secuencia para la primera línea y luego compararla a continuación,

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

Para filtrar elementos en función de su índice, puede usarlo AtomicIntegerpara almacenar e incrementar el índice mientras procesa 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]
}

Este enfoque permite filtrar elementos en cualquier índice, no solo en el primero.

Un poco más enrevesado, obteniendo un poco de inspiración de este fragmento .

Puede crear un Stream<Integer>que represente índices y "comprimirlo" con su Stream<String>para crear unStream<Pair<String, Integer>>

Luego filtre usando el índice y vuelva a asignarlo a 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();
    }
}

Aquí hay un ejemplo con Collectors.reducing. Pero al final crea una lista de todos modos.

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

Prueba esto:

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