ฉันจะรับ java.io.InputStream จาก java.lang.String ได้อย่างไร

ฉันมีStringที่ฉันต้องการใช้เป็นInputStreamไฟล์. ใน Java 1.0 คุณสามารถใช้ได้java.io.StringBufferInputStreamแต่นั่นเป็น@Deprecrated(ด้วยเหตุผลที่ดี - คุณไม่สามารถระบุการเข้ารหัสชุดอักขระได้):

คลาสนี้แปลงอักขระเป็นไบต์ไม่ถูกต้อง สำหรับ JDK 1.1 วิธีที่ต้องการในการสร้างสตรีมจากสตริงคือผ่านStringReader คลาส

คุณสามารถสร้างjava.io.Readerด้วยjava.io.StringReaderแต่ไม่มีอะแดปเตอร์ที่จะใช้Readerและสร้างInputStreamไฟล์.

ฉันพบแมงโบราณขอให้มีการเปลี่ยนทดแทนที่เหมาะสม แต่ไม่มีสิ่งนั้นอยู่ - เท่าที่ฉันสามารถบอกได้

วิธีแก้ปัญหาที่แนะนำบ่อย ๆ คือใช้java.lang.String.getBytes()เป็นข้อมูลเข้าjava.io.ByteArrayInputStream:

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

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

แต่นั่นหมายถึงการทำให้ข้อมูลทั้งหมดStringในหน่วยความจำกลายเป็นอาร์เรย์ของไบต์และเอาชนะจุดประสงค์ของสตรีม ในกรณีส่วนใหญ่นี่ไม่ใช่เรื่องใหญ่ แต่ฉันกำลังมองหาสิ่งที่จะรักษาจุดประสงค์ของสตรีม - ข้อมูลที่มีเพียงเล็กน้อยที่สุดเท่าที่จะเป็นไปได้คือ (re) ปรากฏในหน่วยความจำ

อัปเดต:คำตอบนี้เป็นสิ่งที่ OP ไม่ต้องการอย่างแน่นอน โปรดอ่านคำตอบอื่น ๆ

สำหรับกรณีเหล่านั้นเมื่อเราไม่สนใจว่าข้อมูลจะถูกทำให้เป็นรูปเป็นร่างขึ้นใหม่ในหน่วยความจำโปรดใช้:

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

หากคุณไม่ทราบการพึ่งพาที่คอมมอนส์-ioแพคเกจแล้วคุณสามารถใช้IOUtils.toInputStream (String ข้อความ)วิธีการ

มีอะแดปเตอร์จาก Apache Commons-IO เป็นซึ่งปรับจาก Reader เพื่อ InputStream ซึ่งเป็นชื่อReaderInputStream

รหัสตัวอย่าง:

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

อ้างอิง: https://stackoverflow.com/a/27909221/5658642

ในความคิดของฉันวิธีที่ง่ายที่สุดในการทำเช่นนี้คือการส่งข้อมูลผ่าน 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();
  }
}

การใช้งาน JVM ฉันใช้ข้อมูลที่พุชผ่านเป็นชิ้น 8K แต่คุณอาจมีผลต่อขนาดบัฟเฟอร์โดยการลดจำนวนอักขระที่เขียนในครั้งเดียวและเรียกฟลัช

อีกทางเลือกหนึ่งในการเขียน CharsetEncoder wrapper ของคุณเองเพื่อใช้ Writer ในการเข้ารหัสข้อมูลแม้ว่าจะเป็นเรื่องที่เจ็บปวดที่ต้องทำ สิ่งนี้ควรเป็นการใช้งานที่เชื่อถือได้ (หากไม่มีประสิทธิภาพ):

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

  }

}

วิธีหนึ่งที่เป็นไปได้คือ:

• สร้างไฟล์ PipedOutputStream
• บีบไปที่ไฟล์ PipedInputStream
• พันOutputStreamWriterรอบPipedOutputStream (คุณสามารถระบุการเข้ารหัสในตัวสร้างที่)
• อื่น ๆ สิ่งที่คุณเขียนถึงOutputStreamWriterสามารถอ่านได้จากPipedInputStream!

แน่นอนว่านี่เป็นวิธีที่ค่อนข้างแฮ็ค แต่อย่างน้อยก็เป็นวิธีหนึ่ง

วิธีแก้ปัญหาคือการม้วนของคุณเองสร้างการInputStreamใช้งานที่น่าจะใช้java.nio.charset.CharsetEncoderในการเข้ารหัสแต่ละcharชิ้นหรือชิ้นส่วนcharเป็นอาร์เรย์ของไบต์InputStreamตามความจำเป็น

คุณสามารถใช้ความช่วยเหลือของไลบรารี org.hsqldb.lib

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

ฉันรู้ว่านี่เป็นคำถามเก่า แต่ฉันก็มีปัญหาเดียวกันในวันนี้และนี่คือวิธีแก้ปัญหาของฉัน:

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