Bir java.lang.String'den java.io.InputStream'i nasıl edinebilirim?

Kullanmak Stringistediğim bir InputStream. Java 1.0'da kullanabilirsiniz java.io.StringBufferInputStream, ancak bunu kullanabilirsiniz @Deprecrated(iyi bir nedenle - karakter seti kodlamasını belirleyemezsiniz):

Bu sınıf, karakterleri düzgün şekilde bayta dönüştürmez. JDK 1.1'den itibaren, bir dizeden akım yaratmanın tercih edilen yolu StringReader sınıf yoluyladır.

Bir java.io.Readerile oluşturabilirsiniz java.io.StringReader, ancak Readerbir InputStream.

Uygun bir yedek isteyen eski bir böcek buldum , ancak söyleyebileceğim kadarıyla böyle bir şey yok.

Sıklıkla önerilen geçici çözüm, aşağıdakiler için java.lang.String.getBytes()girdi olarak kullanmaktır java.io.ByteArrayInputStream:

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

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

ancak bu String, bellekteki bütünün bir bayt dizisi olarak somutlaştırılması anlamına gelir ve bir akışın amacını bozar. Çoğu durumda bu büyük bir sorun değil, ancak bir akışın amacını koruyacak bir şey arıyordum - mümkün olduğunca az verinin bellekte (yeniden) somutlaştırılması.

Güncelleme: Bu cevap tam olarak OP'nin istemediği şeydir. Lütfen diğer cevapları okuyun.

Verilerin bellekte yeniden gerçekleştirilmesini önemsemediğimiz durumlar için lütfen şunu kullanın:

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

Commons-io paketine bağımlılık sorun yaşamıyorsanız , IOUtils.toInputStream (String text) yöntemini kullanabilirsiniz.

Reader'dan InputStream'e uyarlanan Apache Commons- IO'dan ReaderInputStream adlı bir adaptör bulunmaktadır .

Örnek 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));
}

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

Bence bunu yapmanın en kolay yolu, verileri bir Yazar aracılığıyla aktarmaktır:

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

JVM uygulaması, 8K öbeklerde itilen verileri kullanıyorum, ancak bir seferde yazılan karakter sayısını azaltarak ve floş çağırarak arabellek boyutu üzerinde bir miktar etkiye sahip olabilirsiniz.

Verileri kodlamak için bir Writer kullanmak için kendi CharsetEncoder sarmalayıcınızı yazmaya bir alternatif, ancak bu doğru yapılması gereken bir acıdır. Bu, güvenilir (verimsizse) bir uygulama olmalıdır:

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

  }

}

Olası bir yol şudur:

• Oluşturmak PipedOutputStream
• Bir PipedInputStream
• OutputStreamWriterEtrafına sarın PipedOutputStream(yapıcıda kodlamayı belirtebilirsiniz)
• Et voilá, yazdığınız her şey OutputStreamWriterburadan okunabilir PipedInputStream!

Tabii ki, bu, bunu yapmanın oldukça hilekâr bir yolu gibi görünüyor, ama en azından bir yol.

Bir çözüm, gerekli olduğu gibi bir bayt dizisine her bir s parçasını veya s kümesini kodlamak için InputStreamkullanacak bir uygulama oluşturarak kendi çözümünüzü yuvarlamaktır .java.nio.charset.CharsetEncodercharcharInputStream

Org.hsqldb.lib kütüphanesinden yardım alabilirsiniz.

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

Bunun eski bir soru olduğunu biliyorum ama bugün de aynı sorunu yaşadım ve bu benim çözümümdü:

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