¿Cómo puedo obtener un java.io.InputStream de un java.lang.String?

Tengo un Stringque quiero usar como InputStream. En Java 1.0, podría usar java.io.StringBufferInputStream, pero así ha sido @Deprecrated(con una buena razón, no puede especificar la codificación del juego de caracteres):

Esta clase no convierte correctamente los caracteres en bytes. A partir de JDK 1.1, la forma preferida de crear una secuencia a partir de una cadena es a través de la StringReader clase.

Puede crear un java.io.Readercon java.io.StringReader, pero no hay adaptadores para tomar un Readery crear un InputStream.

Encontré un error antiguo que solicitaba un reemplazo adecuado, pero no existe tal cosa, por lo que yo sé.

La solución alternativa sugerida con frecuencia es utilizarla java.lang.String.getBytes()como entrada para java.io.ByteArrayInputStream:

public InputStream createInputStream(String s, String charset)
    throws java.io.UnsupportedEncodingException {

    return new ByteArrayInputStream(s.getBytes(charset));
}

pero eso significa materializar todo Stringen la memoria como una matriz de bytes, y anula el propósito de una secuencia. En la mayoría de los casos, esto no es gran cosa, pero estaba buscando algo que preservara la intención de un flujo: que la menor cantidad de datos posible se (re) materialice en la memoria.

Actualización: esta respuesta es precisamente lo que el OP no quiere. Lea las otras respuestas.

Para aquellos casos en los que no nos importa que los datos se vuelvan a materializar en la memoria, utilice:

new ByteArrayInputStream(str.getBytes("UTF-8"))

Si no le importa una dependencia del paquete commons-io , entonces puede usar el método IOUtils.toInputStream (String text) .

Hay un adaptador de Apache Commons-IO que se adapta de Reader a InputStream, que se llama ReaderInputStream .

Código de ejemplo:

@Test
public void testReaderInputStream() throws IOException {
    InputStream inputStream = new ReaderInputStream(new StringReader("largeString"), StandardCharsets.UTF_8);
    Assert.assertEquals("largeString", IOUtils.toString(inputStream, StandardCharsets.UTF_8));
}

Referencia: https://stackoverflow.com/a/27909221/5658642

En mi opinión, la forma más sencilla de hacerlo es enviando los datos a través de un editor:

public class StringEmitter {
  public static void main(String[] args) throws IOException {
    class DataHandler extends OutputStream {
      @Override
      public void write(final int b) throws IOException {
        write(new byte[] { (byte) b });
      }
      @Override
      public void write(byte[] b) throws IOException {
        write(b, 0, b.length);
      }
      @Override
      public void write(byte[] b, int off, int len)
          throws IOException {
        System.out.println("bytecount=" + len);
      }
    }

    StringBuilder sample = new StringBuilder();
    while (sample.length() < 100 * 1000) {
      sample.append("sample");
    }

    Writer writer = new OutputStreamWriter(
        new DataHandler(), "UTF-16");
    writer.write(sample.toString());
    writer.close();
  }
}

La implementación de JVM que estoy usando empujó datos en fragmentos de 8K, pero podría tener algún efecto en el tamaño del búfer al reducir la cantidad de caracteres escritos a la vez y llamar a flush.

Una alternativa a escribir su propio contenedor CharsetEncoder para usar un Writer para codificar los datos, aunque es algo complicado hacerlo bien. Esta debería ser una implementación confiable (aunque ineficiente):

/** Inefficient string stream implementation */
public class StringInputStream extends InputStream {

  /* # of characters to buffer - must be >=2 to handle surrogate pairs */
  private static final int CHAR_CAP = 8;

  private final Queue<Byte> buffer = new LinkedList<Byte>();
  private final Writer encoder;
  private final String data;
  private int index;

  public StringInputStream(String sequence, Charset charset) {
    data = sequence;
    encoder = new OutputStreamWriter(
        new OutputStreamBuffer(), charset);
  }

  private int buffer() throws IOException {
    if (index >= data.length()) {
      return -1;
    }
    int rlen = index + CHAR_CAP;
    if (rlen > data.length()) {
      rlen = data.length();
    }
    for (; index < rlen; index++) {
      char ch = data.charAt(index);
      encoder.append(ch);
      // ensure data enters buffer
      encoder.flush();
    }
    if (index >= data.length()) {
      encoder.close();
    }
    return buffer.size();
  }

  @Override
  public int read() throws IOException {
    if (buffer.size() == 0) {
      int r = buffer();
      if (r == -1) {
        return -1;
      }
    }
    return 0xFF & buffer.remove();
  }

  private class OutputStreamBuffer extends OutputStream {

    @Override
    public void write(int i) throws IOException {
      byte b = (byte) i;
      buffer.add(b);
    }

  }

}

Bueno, una forma posible es:

• Crear un PipedOutputStream
• Típelo a un PipedInputStream
• Envuelva un OutputStreamWriteralrededor de PipedOutputStream(puede especificar la codificación en el constructor)
• Et voilá, cualquier cosa que le escriba OutputStreamWriterse puede leer desde el PipedInputStream!

Por supuesto, esta parece una forma bastante hackea de hacerlo, pero al menos es una forma.

Una solución es lanzar la suya propia, creando una InputStreamimplementación que probablemente se usaría java.nio.charset.CharsetEncoderpara codificar cada uno charo un fragmento de chars en una matriz de bytes InputStreamsegún sea necesario.

Puede tomar la ayuda de la biblioteca org.hsqldb.lib.

public StringInputStream(String paramString)
  {
    this.str = paramString;
    this.available = (paramString.length() * 2);
  }

Sé que esta es una pregunta antigua, pero hoy tuve el mismo problema y esta fue mi solución:

public static InputStream getStream(final CharSequence charSequence) {
 return new InputStream() {
  int index = 0;
  int length = charSequence.length();
  @Override public int read() throws IOException {
   return index>=length ? -1 : charSequence.charAt(index++);
  }
 };
}