Hapus elemen pertama (dengan indeks nol) dari aliran bersyarat

Saya memiliki kode berikut:

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

Jika fist string sama dengan "email"saya ingin menghapus string pertama dari Stream. Untuk string lain dari aliran saya tidak perlu cek ini.

Bagaimana saya bisa mencapainya?

PS

Tentu saya bisa mengubahnya ke daftar, lalu gunakan sekolah tua untuk loop tetapi lebih lanjut saya perlu streaming lagi.

Sementara pembaca akan berada dalam kondisi yang tidak ditentukan setelah Anda membangun aliran garis dari itu, itu dalam keadaan yang terdefinisi dengan baik sebelum Anda melakukannya.

Jadi kamu bisa melakukannya

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

Yang merupakan solusi terbersih menurut saya. Perhatikan bahwa ini tidak sama dengan Java 9 dropWhile, yang akan turun lebih dari satu baris jika cocok.

Jika Anda tidak dapat memiliki daftar dan harus melakukannya hanya dengan Stream, Anda dapat melakukannya dengan variabel.

Masalahnya adalah Anda hanya bisa menggunakan variabel jika "final" atau "efektif final" sehingga Anda tidak dapat menggunakan boolean literal. Anda masih dapat melakukannya dengan 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);

Catatan: Saya tidak suka menggunakan "variabel eksternal" Streamkarena efek samping adalah praktik buruk dalam paradigma pemrograman fungsional. Pilihan yang lebih baik dipersilakan.

Untuk menghindari memeriksa kondisi pada setiap baris file, saya cukup membaca dan memeriksa baris pertama secara terpisah, kemudian jalankan pipeline pada sisa baris tanpa memeriksa kondisi:

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

Lebih sederhana di Java 9+:

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

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

Jawaban @rnouds benar. Anda dapat membuat satu aliran untuk baris pertama dan kemudian membandingkannya seperti di bawah ini,

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

Untuk memfilter elemen berdasarkan indeksnya, Anda dapat menggunakan AtomicIntegeruntuk menyimpan dan menambah indeks saat memproses 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]
}

Pendekatan ini memungkinkan untuk menyaring elemen pada indeks apa pun, tidak hanya yang pertama.

Sedikit lebih berbelit-belit, mendapat inspirasi dari cuplikan ini .

Anda dapat membuat Stream<Integer>yang akan mewakili indeks dan "zip" dengan Anda Stream<String>untuk membuatStream<Pair<String, Integer>>

Kemudian filter menggunakan indeks dan petakan kembali ke 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();
    }
}

Berikut ini contoh dengan Collectors.reducing. Namun pada akhirnya tetap membuat daftar.

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

Coba ini:

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