Come posso ottenere un java.io.InputStream da un java.lang.String?

Ho un file Stringche voglio usare come file InputStream. In Java 1.0, potresti usare java.io.StringBufferInputStream, ma è stato @Deprecrated(con una buona ragione - non puoi specificare la codifica del set di caratteri):

Questa classe non converte correttamente i caratteri in byte. A partire da JDK 1.1, il modo preferito per creare un flusso da una stringa è tramite la StringReader classe.

Puoi creare un java.io.Readercon java.io.StringReader, ma non ci sono adattatori per prendere un Readere creare un file InputStream.

Ho trovato un antico bug che chiedeva un sostituto adatto, ma non esiste nulla del genere, per quanto ne so.

La soluzione alternativa suggerita è quella di utilizzare java.lang.String.getBytes()come input per java.io.ByteArrayInputStream:

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

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

ma ciò significa materializzare l'intero Stringin memoria come un array di byte e vanifica lo scopo di un flusso. Nella maggior parte dei casi questo non è un grosso problema, ma stavo cercando qualcosa che preservasse l'intento di un flusso - che il minor numero possibile di dati venga (ri) materializzato nella memoria.

Aggiornamento: questa risposta è esattamente ciò che l'OP non vuole. Si prega di leggere le altre risposte.

Per quei casi in cui non ci interessa che i dati vengano rimaterializzati in memoria, si prega di utilizzare:

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

Se non ti dispiace una dipendenza dal pacchetto commons-io , puoi usare il metodo IOUtils.toInputStream (String text) .

C'è un adattatore da Apache Commons-IO che si adatta da Reader a InputStream, che si chiama ReaderInputStream .

Codice di esempio:

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

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

A mio avviso, il modo più semplice per farlo è spingere i dati attraverso un 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();
  }
}

L'implementazione JVM che sto usando ha trasferito i dati in blocchi di 8K, ma potresti avere qualche effetto sulla dimensione del buffer riducendo il numero di caratteri scritti contemporaneamente e chiamando flush.

Un'alternativa alla scrittura del proprio wrapper CharsetEncoder per utilizzare un writer per codificare i dati, sebbene sia una seccatura farlo bene. Questa dovrebbe essere un'implementazione affidabile (se inefficiente):

/** 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);
    }

  }

}

Bene, un modo possibile è:

• Creare un PipedOutputStream
• Collegalo a un file PipedInputStream
• Avvolgere un OutputStreamWriterintorno PipedOutputStream(è possibile specificare la codifica nel costruttore)
• Et voilá, tutto ciò che scrivi OutputStreamWriterpuò essere letto dal PipedInputStream!

Certo, questo sembra un modo piuttosto hacker per farlo, ma almeno è un modo.

Una soluzione è eseguire il rollio personalizzato, creando InputStreamun'implementazione che probabilmente utilizzerebbe java.nio.charset.CharsetEncoderper codificare ciascuno charo un blocco di messaggi di posta elettronica charin un array di byte per InputStreamquanto necessario.

Puoi chiedere aiuto alla libreria org.hsqldb.lib.

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

So che questa è una vecchia domanda, ma oggi ho avuto lo stesso problema e questa era la mia soluzione:

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