¿Cómo puedo verificar si un InputStream está vacío sin leerlo?

Question 1

quiero saber si un InputStream está vacío, pero sin usar el método read(). ¿Hay alguna manera de saber si está vacío sin leerlo?

Question 2

No, no puedes. InputStream está diseñado para trabajar con recursos remotos, por lo que no puede saber si está allí hasta que realmente lo lea.

Es posible que pueda usar un java.io.PushbackInputStreamsin embargo, lo que le permite leer de la secuencia para ver si hay algo allí, y luego “empujarlo hacia atrás” en la secuencia (no es así como funciona realmente, pero así es como se comporta con el código del cliente).

Question 3

creo que estas buscando inputstream.available(). No le dice si está vacío, pero puede darle una indicación de si hay datos para leer o no.

Question 4

Basado en la sugerencia de usar PushbackInputStream, aquí encontrará una implementación de ejemplo:

/**
 * @author Lorber Sebastien <i>(lorber.sebastien@gmail.com)</i>
 */
public class NonEmptyInputStream extends FilterInputStream {

  /**
   * Once this stream has been created, do not consume the original InputStream 
   * because there will be one missing byte...
   * @param originalInputStream
   * @throws IOException
   * @throws EmptyInputStreamException
   */
  public NonEmptyInputStream(InputStream originalInputStream) throws IOException, EmptyInputStreamException {
    super( checkStreamIsNotEmpty(originalInputStream) );
  }


  /**
   * Permits to check the InputStream is empty or not
   * Please note that only the returned InputStream must be consummed.
   *
   * see:
   * http://stackoverflow.com/questions/1524299/how-can-i-check-if-an-inputstream-is-empty-without-reading-from-it
   *
   * @param inputStream
   * @return
   */
  private static InputStream checkStreamIsNotEmpty(InputStream inputStream) throws IOException, EmptyInputStreamException {
    Preconditions.checkArgument(inputStream != null,"The InputStream is mandatory");
    PushbackInputStream pushbackInputStream = new PushbackInputStream(inputStream);
    int b;
    b = pushbackInputStream.read();
    if ( b == -1 ) {
      throw new EmptyInputStreamException("No byte can be read from stream " + inputStream);
    }
    pushbackInputStream.unread(b);
    return pushbackInputStream;
  }

  public static class EmptyInputStreamException extends RuntimeException {
    public EmptyInputStreamException(String message) {
      super(message);
    }
  }

}

Y aquí hay algunas pruebas de aprobación:

  @Test(expected = EmptyInputStreamException.class)
  public void test_check_empty_input_stream_raises_exception_for_empty_stream() throws IOException {
    InputStream emptyStream = new ByteArrayInputStream(new byte[0]);
    new NonEmptyInputStream(emptyStream);
  }

  @Test
  public void test_check_empty_input_stream_ok_for_non_empty_stream_and_returned_stream_can_be_consummed_fully() throws IOException {
    String streamContent = "HELLooooô wörld";
    InputStream inputStream = IOUtils.toInputStream(streamContent, StandardCharsets.UTF_8);
    inputStream = new NonEmptyInputStream(inputStream);
    assertThat(IOUtils.toString(inputStream,StandardCharsets.UTF_8)).isEqualTo(streamContent);
  }

Question 5

Si el InputStream está utilizando soporte para marcar/restablecer, también puede intentar leer el primer byte de la secuencia y luego restablecerlo a su posición original:

input.mark(1);
final int bytesRead = input.read(new byte[1]);
input.reset();
if (bytesRead != -1) {
    //stream not empty
} else {
    //stream empty
}

Si no controlas qué tipo de InputStream estás usando, puedes usar el markSupported() método para verificar si marcar/restablecer funcionará en la transmisión y recurrir al available() método o el java.io.PushbackInputStream método de otra manera.

Question 6

Puedes usar el available() método para preguntar a la transmisión si hay datos disponibles en el momento lo llamas. Sin embargo, no se garantiza que esa función funcione en todos los tipos de flujos de entrada. Eso significa que no puedes usar available() para determinar si una llamada a read() realmente bloqueará o no.

Question 7

¿Qué hay de usar inputStreamReader.listo() ¿descubrir?

import java.io.InputStreamReader;

/// ...

InputStreamReader reader = new InputStreamReader(inputStream);
if (reader.ready()) {
    // do something
}

// ...

Question 8

Sin leer no puedes hacer esto. Pero puede usar una solución alternativa como la siguiente.

Puedes usar Marcos() y Reiniciar() métodos para hacer esto.

El método mark(int readlimit) marca la posición actual en este flujo de entrada.

El método reset () reposiciona este flujo a la posición en el momento en que se llamó por última vez al método de marca en este flujo de entrada.

Antes de que pueda usar la marca y el restablecimiento, debe probar si estas operaciones son compatibles con el flujo de entrada que está leyendo. Puede hacerlo con markSupported.

El método de marca acepta un límite (entero), que denota el número máximo de bytes que se leerán por adelantado. Si lee más de este límite, no puede volver a esta marca.

Para aplicar estas funcionalidades para este caso de uso, debemos marcar la posición como 0 y luego leer el flujo de entrada. Luego, debemos restablecer el flujo de entrada y el flujo de entrada se revertirá al original.

    if (inputStream.markSupported()) {
          inputStream.mark(0);
          if (inputStream.read() != -1) {
               inputStream.reset();
          } else {
               //Inputstream is empty
          }
    }

Aquí, si el flujo de entrada está vacío, el método read() devolverá -1.

¿Ha sido útil esta solución?