Як перевірити, чи потік Java 8 порожній?

Як я можу перевірити, чи Streamпорожнє a , і видати виняток, якщо ні, як нетермінальну операцію?

В основному, я шукаю щось еквівалентне коду нижче, але без матеріалізації потоку між ними. Зокрема, перевірка не повинна відбуватися до того, як потік фактично спожитий операцією терміналу.

public Stream<Thing> getFilteredThings() {
    Stream<Thing> stream = getThings().stream()
                .filter(Thing::isFoo)
                .filter(Thing::isBar);
    return nonEmptyStream(stream, () -> {
        throw new RuntimeException("No foo bar things available")   
    });
}

private static <T> Stream<T> nonEmptyStream(Stream<T> stream, Supplier<T> defaultValue) {
    List<T> list = stream.collect(Collectors.toList());
    if (list.isEmpty()) list.add(defaultValue.get());
    return list.stream();
}

Якщо ви можете жити з обмеженими паралельними можливостями, буде працювати таке рішення:

private static <T> Stream<T> nonEmptyStream(
    Stream<T> stream, Supplier<RuntimeException> e) {

    Spliterator<T> it=stream.spliterator();
    return StreamSupport.stream(new Spliterator<T>() {
        boolean seen;
        public boolean tryAdvance(Consumer<? super T> action) {
            boolean r=it.tryAdvance(action);
            if(!seen && !r) throw e.get();
            seen=true;
            return r;
        }
        public Spliterator<T> trySplit() { return null; }
        public long estimateSize() { return it.estimateSize(); }
        public int characteristics() { return it.characteristics(); }
    }, false);
}

Ось приклад коду з його використанням:

List<String> l=Arrays.asList("hello", "world");
nonEmptyStream(l.stream(), ()->new RuntimeException("No strings available"))
  .forEach(System.out::println);
nonEmptyStream(l.stream().filter(s->s.startsWith("x")),
               ()->new RuntimeException("No strings available"))
  .forEach(System.out::println);

Проблема (ефективного) паралельного виконання полягає в тому, що підтримка розбиття Spliteratorвимагає безпечного для потоку способу помітити, чи не бачив якийсь із фрагментів якесь значення безпечним для потоку способом. Тоді останній із виконуваних фрагментів tryAdvanceповинен усвідомити, що це останній (і він також не зміг просунутися вперед), який викинув відповідний виняток. Тож я не додав тут підтримку розділення.

Інші відповіді та коментарі є правильними, оскільки для вивчення вмісту потоку потрібно додати операцію терміналу, тим самим «поглинаючи» потік. Однак це можна зробити і перетворити результат назад у потік, не буферизуючи весь вміст потоку. Ось кілька прикладів:

static <T> Stream<T> throwIfEmpty(Stream<T> stream) {
    Iterator<T> iterator = stream.iterator();
    if (iterator.hasNext()) {
        return StreamSupport.stream(Spliterators.spliteratorUnknownSize(iterator, 0), false);
    } else {
        throw new NoSuchElementException("empty stream");
    }
}

static <T> Stream<T> defaultIfEmpty(Stream<T> stream, Supplier<T> supplier) {
    Iterator<T> iterator = stream.iterator();
    if (iterator.hasNext()) {
        return StreamSupport.stream(Spliterators.spliteratorUnknownSize(iterator, 0), false);
    } else {
        return Stream.of(supplier.get());
    }
}

В основному перетворіть потік в a Iterator, щоб зателефонувати hasNext()йому, і якщо це правда, перетворіть Iteratorназад в a Stream. Це неефективно, оскільки всі наступні операції над потоком будуть проходити через ітератор hasNext()та next()методи, що також означає, що потік ефективно обробляється послідовно (навіть якщо згодом він перетворюється паралельно). Однак це дозволяє перевірити потік без буферизації всіх його елементів.

Ймовірно, є спосіб зробити це, використовуючи Spliteratorзамість Iterator. Це потенційно дозволяє поверненому потоку мати ті самі характеристики, що і вхідний потік, включаючи паралельний запуск.

Цього може бути достатньо у багатьох випадках

stream.findAny().isPresent()

Ви повинні виконати операцію терміналу на потоці, щоб застосувати будь-який з фільтрів. Тому ви не можете знати, чи буде він порожнім, поки ви його не спожите.

Найкраще, що ви можете зробити, - це завершити потік за допомогою findAny()терміналу, який зупиниться, коли знайде будь-який елемент, але якщо такого немає, йому доведеться виконати ітерацію по всьому списку введення, щоб це виявити.

Це допоможе вам лише у тому випадку, якщо вхідний список містить багато елементів і один із перших декількох передає фільтри, оскільки лише невелика підмножина списку повинна бути використана, перш ніж ви дізнаєтесь, що потік не порожній.

Звичайно, вам все одно доведеться створити новий потік, щоб створити вихідний список.

Я думаю, цього повинно бути достатньо для відображення логічного значення

У коді це:

boolean isEmpty = anyCollection.stream()
    .filter(p -> someFilter(p)) // Add my filter
    .map(p -> Boolean.TRUE) // For each element after filter, map to a TRUE
    .findAny() // Get any TRUE
    .orElse(Boolean.FALSE); // If there is no match return false

Наслідуючи ідею Стюарта, це можна зробити приблизно Spliteratorтак:

static <T> Stream<T> defaultIfEmpty(Stream<T> stream, Stream<T> defaultStream) {
    final Spliterator<T> spliterator = stream.spliterator();
    final AtomicReference<T> reference = new AtomicReference<>();
    if (spliterator.tryAdvance(reference::set)) {
        return Stream.concat(Stream.of(reference.get()), StreamSupport.stream(spliterator, stream.isParallel()));
    } else {
        return defaultStream;
    }
}

Я думаю, це працює з паралельними потоками як stream.spliterator() операція завершить потік, а потім відновить його, як потрібно

У моєму варіанті використання мені було потрібне значення за замовчуванням, Streamа не значення за замовчуванням. це досить легко змінити, якщо це не те, що вам потрібно