İlk (sıfır dizinli) öğeyi akıştan koşullu olarak kaldır

Aşağıdaki kod var:

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

Yumruk dizesi eşitse Akıştan "email"ilk dizeyi kaldırmak istiyorum. Akıştaki diğer dizeler için bu kontrole ihtiyacım yok.

Nasıl başarabilirim?

PS

Tabii listeye dönüştürebilirim, sonra eski okulu döngü için kullanabilirim, ancak tekrar akışa ihtiyacım var.

Okuyucu, ondan bir satır akışı oluşturduktan sonra belirtilmemiş bir durumda olsa da, bunu yapmadan önce iyi tanımlanmış bir durumdadır.

Böylece yapabilirsin

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

Bence en temiz çözüm. Bunun, Java 9'larla aynı olmadığını ve dropWhileeşleşmeleri durumunda birden fazla satır düşeceğini unutmayın.

Listeye sahip olamıyorsanız ve listeyi yalnızca a Streamile yapmanız gerekiyorsa, bunu bir değişkenle yapabilirsiniz.

Mesele şu ki, bir değişkeni yalnızca "son" veya "etkin bir şekilde son" ise kullanabilirsiniz, böylece değişmez bir boole kullanamazsınız. Yine de aşağıdakilerle yapabilirsiniz 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);

Not: StreamYan etkiler fonksiyonel programlama paradigmasında kötü bir uygulama olduğu için "dış değişkenler" i kullanmayı sevmiyorum . Daha iyi seçenekler açıktır.

Dosyanın her satırındaki durumu kontrol etmekten kaçınmak için, ilk satırı ayrı ayrı okuyup kontrol ettim, ardından durumu kontrol etmeden boru hattını diğer satırlarda çalıştırırım:

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+ üzerinde daha basit:

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

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

@Arnouds yanıtı doğru. İlk satır için bir akış oluşturabilir ve ardından aşağıdaki gibi karşılaştırabilirsiniz,

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

Öğeleri dizinlerine göre filtrelemek için, aşağıdakileri AtomicIntegerişlerken dizini depolamak ve artırmak için kullanabilirsiniz 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]
}

Bu yaklaşım, yalnızca birincisine değil, herhangi bir dizindeki öğelerin filtrelenmesine izin verir.

Biraz daha kıvrımlı, bu pasajdan ilham alıyor .

Stream<Integer>Dizinleri temsil edecek bir tane oluşturabilir veStream<String> oluşturmak için birStream<Pair<String, Integer>>

Ardından dizini kullanarak filtreleyin ve bir 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();
    }
}

İşte ile örnek Collectors.reducing. Ama sonunda yine de bir liste oluşturur.

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

Bunu dene:

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