Compruebe si la corriente de Java se ha consumido

tkruse:

¿Cómo puedo comprobar si una instancia de secuencia se ha consumido o no (es decir, después de haber llamado una operación de terminal de tal manera que cualquier otra convocatoria a una operación de terminal puede fallar con IllegalStateException: stream has already been operated upon or closed.?

Idealmente Quiero un método que no consume la corriente si todavía no se ha consumido, y que devuelve un falso booleano si la corriente se ha consumido sin coger una IllegalStateExceptionde un método corriente (porque el uso de excepciones para el flujo de control es costoso y propenso a errores , en particular cuando el uso de excepciones estándar).

Un método similar al hasNext()de iterador en el lanzamiento de excepción y el comportamiento de retorno booleano (aunque sin contrato a next()).

Ejemplo:

public void consume(java.util.function.Consumer<Stream<?>> consumer, Stream<?> stream) {
   consumer.accept(stream);
   // defensive programming, check state
   if (...) {
       throw new IllegalStateException("consumer must call terminal operation on stream");
   }
}

El objetivo es fallar antes de tiempo si el código de cliente llama a este método sin consumir la corriente.

Parece que no hay ningún método para hacer eso y me gustaría tener que agregar un bloque try-catch llamar a cualquier operación de terminales como iterator(), capturar una excepción y lanzar una nueva.

Una respuesta aceptable también puede ser "No existe una solución" con una buena justificación de por qué la especificación no podría añadir un método tal (si existe una buena justificación). Parece que el JDK arroyos por lo general tienen esta fragmentos en el inicio de sus métodos de terminal:

// in AbstractPipeline.java
if (linkedOrConsumed)
    throw new IllegalStateException(MSG_STREAM_LINKED);

Por lo tanto, para los flujos, no parece tan difícil la implementación de un procedimiento de este tipo.

Eugene:

Teniendo en cuenta que spliterator(por ejemplo) es una operación de terminales, sólo tiene que crear un método como:

private static <T> Optional<Stream<T>> isConsumed(Stream<T> stream) {

    Spliterator<T> spliterator;
    try {
        spliterator = stream.spliterator();
    } catch (IllegalStateException ise) {
        return Optional.empty();
    }

    return Optional.of(StreamSupport.stream(
        () -> spliterator,
        spliterator.characteristics(),
        stream.isParallel()));
}

No sé de una mejor manera de hacerlo ... y su uso sería:

Stream<Integer> ints = Stream.of(1, 2, 3, 4)
                                 .filter(x -> x < 3);

YourClass.isConsumed(ints)
         .ifPresent(x -> x.forEachOrdered(System.out::println));

Como yo no creo que haya una razón práctica para devolver una secuencia ya consumido, Voy a volver Optional.empty()en su lugar.