Como posso obter um java.io.InputStream de um java.lang.String?

Eu tenho um Stringque quero usar como um InputStream. No Java 1.0, você poderia usar java.io.StringBufferInputStream, mas tem sido @Deprecrated(com um bom motivo - você não pode especificar a codificação do conjunto de caracteres):

Esta classe não converte corretamente caracteres em bytes. A partir do JDK 1.1, a maneira preferida de criar um fluxo de uma string é por meio da StringReader classe.

Você pode criar um java.io.Readercom java.io.StringReader, mas não há adaptadores para pegar um Readere criar um InputStream.

Eu encontrei um bug antigo pedindo uma substituição adequada, mas tal coisa não existe - pelo que eu posso dizer.

A solução alternativa frequentemente sugerida é usar 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));
}

mas isso significa materializar o todo Stringna memória como um array de bytes, e anula o propósito de um stream. Na maioria dos casos, isso não é grande coisa, mas eu estava procurando por algo que preservasse a intenção de um stream - que o mínimo possível de dados seja (re) materializado na memória.

Atualização: Essa resposta é exatamente o que o OP não quer. Por favor, leia as outras respostas.

Para aqueles casos em que não nos importamos com os dados sendo materializados novamente na memória, use:

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

Se você não se importa com a dependência do pacote commons-io , pode usar o método IOUtils.toInputStream (String text) .

Há um adaptador do Apache Commons-IO que se adapta do Reader para o InputStream, que é denominado ReaderInputStream .

Código de exemplo:

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

Referência: https://stackoverflow.com/a/27909221/5658642

Em minha opinião, a maneira mais fácil de fazer isso é enviar os dados por meio de um Writer:

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

A implementação da JVM que estou usando por push de dados em blocos de 8K, mas você pode ter algum efeito no tamanho do buffer, reduzindo o número de caracteres gravados de uma vez e chamando flush.

Uma alternativa para escrever seu próprio invólucro CharsetEncoder para usar um gravador para codificar os dados, embora seja difícil fazer da maneira certa. Esta deve ser uma implementação confiável (se 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);
    }

  }

}

Bem, uma maneira possível é:

• Crie um PipedOutputStream
• Canalize para um PipedInputStream
• Enrole uma OutputStreamWriterem torno da PipedOutputStream(você pode especificar a codificação no construtor)
• Et voilá, qualquer coisa que você escrever no OutputStreamWriterpode ser lido no PipedInputStream!

Claro, essa parece uma maneira bastante hackeada de fazer isso, mas pelo menos é uma maneira.

Uma solução é lançar o seu próprio, criando uma InputStreamimplementação que provavelmente seria usada java.nio.charset.CharsetEncoderpara codificar cada um charou um pedaço de chars em um array de bytes para o InputStreamconforme necessário.

Você pode obter ajuda da biblioteca org.hsqldb.lib.

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

Eu sei que esta é uma pergunta antiga, mas eu tive o mesmo problema hoje, e esta foi a minha solução:

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