Условно удалить первый (с нулевым индексом) элемент из потока

У меня есть следующий код:

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

Если первая строка равна, "email"я хочу удалить первую строку из потока. Для других строк из потока мне не нужна эта проверка.

Как я мог заболеть?

PS

Конечно, я могу преобразовать его в список, затем использовать old school for loop, но в дальнейшем мне снова нужен поток.

Хотя читатель будет в неопределенном состоянии после того, как вы построите из него поток строк, он будет в четко определенном состоянии, прежде чем вы это сделаете.

Так что вы можете сделать

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

Что является самым чистым решением на мой взгляд. Обратите внимание, что это не то же самое, что и в Java 9 dropWhile, из-за которого было бы больше одной строки, если они совпадают

Если вы не можете получить список и должны делать это только с помощью a Stream, вы можете сделать это с помощью переменной.

Дело в том, что вы можете использовать переменную только в том случае, если она является «окончательной» или «фактически конечной», поэтому вы не можете использовать буквальное логическое значение. Вы все еще можете сделать это с 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);

Примечание: мне не нравится использовать «внешние переменные», Streamпотому что побочные эффекты - плохая практика в парадигме функционального программирования. Лучшие варианты приветствуются.

Чтобы не проверять условие в каждой строке файла, я просто прочитал и проверил первую строку отдельно, а затем запустил конвейер для остальных строк без проверки условия:

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

Проще на Java 9+:

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

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

@ Arnouds ответ правильный. Вы можете создать один поток для первой строки, а затем сравнить, как показано ниже,

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

Чтобы отфильтровать элементы по их индексу, вы можете использовать AtomicIntegerдля хранения и увеличения индекса при обработке 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]
}

Такой подход позволяет фильтровать элементы по любому индексу, а не только по первому.

Чуть более запутанный, получая вдохновение из этого фрагмента .

Вы можете создать объект, Stream<Integer>который будет представлять индексы, и «сжать» его, Stream<String>чтобы создатьStream<Pair<String, Integer>>

Затем отфильтруйте, используя индекс, и сопоставьте его с 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();
    }
}

Вот пример с Collectors.reducing. Но в конце концов создает список в любом случае.

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

Попробуй это:

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