Jak mogę uzyskać java.io.InputStream z java.lang.String?

Mam plik String, którego chcę użyć jako InputStream. W Javie 1.0 możesz użyć java.io.StringBufferInputStream, ale tak było @Deprecrated(nie bez powodu - nie możesz określić kodowania zestawu znaków):

Ta klasa nie konwertuje poprawnie znaków na bajty. Począwszy od JDK 1.1, preferowanym sposobem tworzenia strumienia z łańcucha jest użycie StringReader klasy.

Możesz utworzyć za java.io.Readerpomocą java.io.StringReader, ale nie ma adapterów do wzięcia Readeri utworzenia InputStream.

Znalazłem starożytny błąd proszący o odpowiednią wymianę, ale nic takiego nie istnieje - o ile wiem.

Często sugerowanym rozwiązaniem jest użycie java.lang.String.getBytes()jako danych wejściowych do java.io.ByteArrayInputStream:

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

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

ale to oznacza materializację całości Stringw pamięci jako tablicę bajtów i udaremnia cel strumienia. W większości przypadków nie jest to wielka sprawa, ale szukałem czegoś, co zachowałoby intencję strumienia - aby jak najmniej danych było (ponownie) zmaterializowanych w pamięci.

Aktualizacja: ta odpowiedź jest dokładnie tym, czego OP nie chce. Przeczytaj pozostałe odpowiedzi.

W przypadkach, gdy nie zależy nam na ponownym zmaterializowaniu danych w pamięci, użyj:

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

Jeśli nie masz nic przeciwko zależności od pakietu commons-io , możesz użyć metody IOUtils.toInputStream (tekst String) .

Istnieje adapter firmy Apache Commons-IO, który dostosowuje się z programu Reader do InputStream i nazywa się ReaderInputStream .

Przykładowy kod:

@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ódła: https://stackoverflow.com/a/27909221/5658642

Moim zdaniem najłatwiejszym sposobem na to jest przepchnięcie danych przez moduł 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();
  }
}

Implementacja JVM Używam danych wypychanych w porcjach 8K, ale możesz mieć pewien wpływ na rozmiar bufora, zmniejszając liczbę znaków zapisywanych jednocześnie i wywołując flush.

Alternatywa dla pisania własnego opakowania CharsetEncoder w celu użycia Writera do kodowania danych, chociaż jest to trochę trudne. Powinno to być niezawodne (jeśli nieefektywne) wdrożenie:

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

  }

}

Cóż, jednym z możliwych sposobów jest:

• Stwórz PipedOutputStream
• Przełóż to do PipedInputStream
• Zawiń OutputStreamWriterwokół PipedOutputStream(możesz określić kodowanie w konstruktorze)
• Et voilá, wszystko, do czego napiszesz, OutputStreamWritermożna przeczytać w PipedInputStream!

Oczywiście wydaje się to raczej hakerskim sposobem na zrobienie tego, ale przynajmniej tak jest.

Rozwiązaniem jest utworzenie własnego, tworząc InputStreamimplementację, która prawdopodobnie java.nio.charset.CharsetEncoderużyłaby do zakodowania każdego charlub fragmentu chars do tablicy bajtów w InputStreamrazie potrzeby.

Możesz skorzystać z pomocy biblioteki org.hsqldb.lib.

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

Wiem, że to stare pytanie, ale sam miałem dzisiaj ten sam problem, a to było moje rozwiązanie:

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