Comment puis-je obtenir un java.io.InputStream à partir d'un java.lang.String?

J'ai un Stringfichier que je souhaite utiliser comme fichier InputStream. Dans Java 1.0, vous pouvez utiliser java.io.StringBufferInputStream, mais cela a été @Deprecrated(avec raison - vous ne pouvez pas spécifier le codage du jeu de caractères):

Cette classe ne convertit pas correctement les caractères en octets. Depuis JDK 1.1, la méthode préférée pour créer un flux à partir d'une chaîne est via la StringReader classe.

Vous pouvez créer un java.io.Readeravec java.io.StringReader, mais il n'y a pas d'adaptateurs pour prendre un Readeret créer un InputStream.

J'ai trouvé un ancien bug demandant un remplacement approprié, mais rien de tel n'existe - pour autant que je sache.

La solution de contournement souvent suggérée consiste à utiliser java.lang.String.getBytes()comme entrée pour java.io.ByteArrayInputStream:

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

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

mais cela signifie matérialiser le tout Stringen mémoire comme un tableau d'octets, et va à l'encontre de l'objectif d'un flux. Dans la plupart des cas, ce n'est pas un gros problème, mais je cherchais quelque chose qui préserverait l'intention d'un flux - que le moins de données possible soit (re) matérialisé en mémoire.

Mise à jour: Cette réponse est précisément ce que l'OP ne veut pas. Veuillez lire les autres réponses.

Pour les cas où nous ne nous soucions pas de la re-matérialisation des données en mémoire, veuillez utiliser:

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

Si une dépendance sur le package commons-io ne vous dérange pas , vous pouvez utiliser la méthode IOUtils.toInputStream (String text) .

Il existe un adaptateur d'Apache Commons-IO qui s'adapte de Reader à InputStream, appelé ReaderInputStream .

Exemple de code:

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

Référence: https://stackoverflow.com/a/27909221/5658642

À mon avis, le moyen le plus simple de le faire est de transmettre les données à 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'implémentation JVM que j'utilise avec des données poussées par blocs de 8K, mais vous pourriez avoir un effet sur la taille de la mémoire tampon en réduisant le nombre de caractères écrits en même temps et en appelant flush.

Une alternative à l'écriture de votre propre wrapper CharsetEncoder pour utiliser un Writer pour encoder les données, bien que ce soit quelque chose de pénible à faire correctement. Cela devrait être une implémentation fiable (si inefficace):

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

  }

}

Eh bien, une façon possible est de:

• Créer un PipedOutputStream
• Dirigez-le vers un PipedInputStream
• Enveloppez un OutputStreamWriterautour du PipedOutputStream(vous pouvez spécifier l'encodage dans le constructeur)
• Et voilá, tout ce que vous écrivez sur le OutputStreamWriterpeut être lu à partir du PipedInputStream!

Bien sûr, cela semble être une façon plutôt hackish de le faire, mais au moins c'est une façon.

Une solution consiste à générer la vôtre, en créant une InputStreamimplémentation qui utiliserait probablement java.nio.charset.CharsetEncoderpour encoder chaque charou morceau de chars en un tableau d'octets pour le InputStreamsi nécessaire.

Vous pouvez prendre l'aide de la bibliothèque org.hsqldb.lib.

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

Je sais que c'est une vieille question mais j'ai moi-même eu le même problème aujourd'hui, et c'était ma solution:

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