แปลง InputStream เป็นไบต์อาร์เรย์ใน Java

ฉันจะอ่านข้อมูลทั้งหมดInputStreamลงในอาร์เรย์แบบไบต์ได้อย่างไร

คุณสามารถใช้ Apache Commons IOเพื่อจัดการงานนี้และงานที่คล้ายกัน

IOUtilsประเภทมีวิธีการคงอ่านและส่งกลับInputStreambyte[]

InputStream is;
byte[] bytes = IOUtils.toByteArray(is);

ภายในนี้จะสร้างและสำเนาไบต์เพื่อการส่งออกโทรแล้วByteArrayOutputStream toByteArray()มันจัดการไฟล์ขนาดใหญ่โดยการคัดลอกไบต์ในบล็อกของ 4KiB

คุณจะต้องอ่านแต่ละไบต์จากคุณและเขียนไปยังInputStreamByteArrayOutputStream

จากนั้นคุณสามารถดึงข้อมูลอาร์เรย์ไบต์พื้นฐานได้ด้วยการโทรtoByteArray():

InputStream is = ...
ByteArrayOutputStream buffer = new ByteArrayOutputStream();

int nRead;
byte[] data = new byte[16384];

while ((nRead = is.read(data, 0, data.length)) != -1) {
  buffer.write(data, 0, nRead);
}

return buffer.toByteArray();

ในที่สุดหลังจากยี่สิบปีที่ผ่านมามีวิธีง่ายๆที่ไม่ต้องใช้ห้องสมุดของบุคคลที่สามด้วยJava 9 :

InputStream is;
…
byte[] array = is.readAllBytes();

โปรดทราบวิธีการอำนวยความสะดวกreadNBytes(byte[] b, int off, int len)และtransferTo(OutputStream)การตอบสนองความต้องการที่เกิดขึ้นประจำ

ใช้ vanilla Java DataInputStreamและreadFullyวิธีการ (มีอยู่ตั้งแต่อย่างน้อย Java 1.4):

...
byte[] bytes = new byte[(int) file.length()];
DataInputStream dis = new DataInputStream(new FileInputStream(file));
dis.readFully(bytes);
...

มีรสชาติอื่น ๆ ของวิธีนี้ แต่ฉันใช้มันตลอดเวลาสำหรับกรณีการใช้งานนี้

หากคุณใช้google guavaมันจะง่ายเหมือน:

byte[] bytes = ByteStreams.toByteArray(inputStream);

เช่นเคยกรอบ Spring (spring-core ตั้งแต่ 3.2.2) มีบางอย่างสำหรับคุณ:StreamUtils.copyToByteArray()

public static byte[] getBytesFromInputStream(InputStream is) throws IOException {
    ByteArrayOutputStream os = new ByteArrayOutputStream(); 
    byte[] buffer = new byte[0xFFFF];
    for (int len = is.read(buffer); len != -1; len = is.read(buffer)) { 
        os.write(buffer, 0, len);
    }
    return os.toByteArray();
}

วิธีแก้ปัญหาอย่างปลอดภัย (ด้วยความสามารถของcloseสตรีมอย่างถูกต้อง):

• Java 9+ เวอร์ชัน:

  final byte[] bytes;
  try (inputStream) {
      bytes = inputStream.readAllBytes();
  }

• Java 8 เวอร์ชัน:

  public static byte[] readAllBytes(InputStream inputStream) throws IOException {
      final int bufLen = 4 * 0x400; // 4KB
      byte[] buf = new byte[bufLen];
      int readLen;
      IOException exception = null;
  
      try {
          try (ByteArrayOutputStream outputStream = new ByteArrayOutputStream()) {
              while ((readLen = inputStream.read(buf, 0, bufLen)) != -1)
                  outputStream.write(buf, 0, readLen);
  
              return outputStream.toByteArray();
          }
      } catch (IOException e) {
          exception = e;
          throw e;
      } finally {
          if (exception == null) inputStream.close();
          else try {
              inputStream.close();
          } catch (IOException e) {
              exception.addSuppressed(e);
          }
      }
  }

• รุ่นKotlin (เมื่อไม่สามารถเข้าถึง Java 9+):

  @Throws(IOException::class)
  fun InputStream.readAllBytes(): ByteArray {
      val bufLen = 4 * 0x400 // 4KB
      val buf = ByteArray(bufLen)
      var readLen: Int = 0
  
      ByteArrayOutputStream().use { o ->
          this.use { i ->
              while (i.read(buf, 0, bufLen).also { readLen = it } != -1)
                  o.write(buf, 0, readLen)
          }
  
          return o.toByteArray()
      }
  }

  เพื่อหลีกเลี่ยงการซ้อนกันuseดูที่นี่

คุณต้องการภาพเป็นbyte[]หรือไม่? สิ่งที่คุณคาดหวังในสิ่งที่byte[]- เนื้อหาที่สมบูรณ์ของไฟล์ภาพที่เข้ารหัสในรูปแบบใดไฟล์ภาพที่อยู่ในหรือค่าพิกเซล RGB?

คำตอบอื่น ๆ byte[]ที่นี่แสดงให้คุณเห็นวิธีการอ่านไฟล์ลงได้ คุณbyte[]จะมีเนื้อหาที่แน่นอนของไฟล์และคุณจะต้องถอดรหัสให้ทำอะไรกับข้อมูลภาพ

มาตรฐาน API ของ Java สำหรับการอ่าน (และเขียน) ภาพเป็น API ImageIO javax.imageioซึ่งคุณจะพบในแพคเกจ คุณสามารถอ่านรูปภาพจากไฟล์ที่มีโค้ดเพียงบรรทัดเดียว:

BufferedImage image = ImageIO.read(new File("image.jpg"));

นี้จะช่วยให้คุณไม่ได้BufferedImage byte[]ที่จะได้รับข้อมูลภาพคุณสามารถเรียกบนgetRaster() BufferedImageสิ่งนี้จะให้Rasterวัตถุซึ่งมีวิธีการเข้าถึงข้อมูลพิกเซล (มีหลายวิธีgetPixel()/ getPixels())

ค้นหาเอกสาร API สำหรับjavax.imageio.ImageIO, java.awt.image.BufferedImage, java.awt.image.Rasterฯลฯ

ImageIO รองรับรูปแบบภาพจำนวนมากโดยค่าเริ่มต้น: JPEG, PNG, BMP, WBMP และ GIF เป็นไปได้ที่จะเพิ่มการรองรับรูปแบบเพิ่มเติม (คุณต้องมีปลั๊กอินที่ใช้อินเทอร์เฟซผู้ให้บริการ ImageIO)

ดูเพิ่มเติมบทช่วยสอนต่อไปนี้: การทำงานกับรูปภาพ

ในกรณีที่มีคนยังคงมองหาวิธีการแก้ปัญหาโดยไม่ต้องพึ่งพาและหากคุณมีไฟล์

1) DataInputStream

 byte[] data = new byte[(int) file.length()];
 DataInputStream dis = new DataInputStream(new FileInputStream(file));
 dis.readFully(data);
 dis.close();

2) ByteArrayOutputStream

 InputStream is = new FileInputStream(file);
 ByteArrayOutputStream buffer = new ByteArrayOutputStream();
 int nRead;
 byte[] data = new byte[(int) file.length()];
 while ((nRead = is.read(data, 0, data.length)) != -1) {
     buffer.write(data, 0, nRead);
 }

3) RandomAccessFile

 RandomAccessFile raf = new RandomAccessFile(file, "r");
 byte[] data = new byte[(int) raf.length()];
 raf.readFully(data);

หากคุณไม่ต้องการใช้ห้องสมุด Apache Commons-io ข้อมูลโค้ดนี้นำมาจากคลาส sun.misc.IOUtils มันเร็วเกือบสองเท่าของการติดตั้งทั่วไปโดยใช้ ByteBuffers:

public static byte[] readFully(InputStream is, int length, boolean readAll)
        throws IOException {
    byte[] output = {};
    if (length == -1) length = Integer.MAX_VALUE;
    int pos = 0;
    while (pos < length) {
        int bytesToRead;
        if (pos >= output.length) { // Only expand when there's no room
            bytesToRead = Math.min(length - pos, output.length + 1024);
            if (output.length < pos + bytesToRead) {
                output = Arrays.copyOf(output, pos + bytesToRead);
            }
        } else {
            bytesToRead = output.length - pos;
        }
        int cc = is.read(output, pos, bytesToRead);
        if (cc < 0) {
            if (readAll && length != Integer.MAX_VALUE) {
                throw new EOFException("Detect premature EOF");
            } else {
                if (output.length != pos) {
                    output = Arrays.copyOf(output, pos);
                }
                break;
            }
        }
        pos += cc;
    }
    return output;
}

ByteArrayOutputStream out = new ByteArrayOutputStream();
byte[] buffer = new byte[1024];
while (true) {
    int r = in.read(buffer);
    if (r == -1) break;
    out.write(buffer, 0, r);
}

byte[] ret = out.toByteArray();

@Adamski: คุณสามารถหลีกเลี่ยงบัฟเฟอร์ทั้งหมด

รหัสที่คัดลอกมาจากhttp://www.exampledepot.com/egs/java.io/File2ByteArray.html (ใช่มันเป็น verbose มาก แต่ต้องการหน่วยความจำครึ่งหนึ่งเท่ากับโซลูชันอื่น)

// Returns the contents of the file in a byte array.
public static byte[] getBytesFromFile(File file) throws IOException {
    InputStream is = new FileInputStream(file);

    // Get the size of the file
    long length = file.length();

    // You cannot create an array using a long type.
    // It needs to be an int type.
    // Before converting to an int type, check
    // to ensure that file is not larger than Integer.MAX_VALUE.
    if (length > Integer.MAX_VALUE) {
        // File is too large
    }

    // Create the byte array to hold the data
    byte[] bytes = new byte[(int)length];

    // Read in the bytes
    int offset = 0;
    int numRead = 0;
    while (offset < bytes.length
           && (numRead=is.read(bytes, offset, bytes.length-offset)) >= 0) {
        offset += numRead;
    }

    // Ensure all the bytes have been read in
    if (offset < bytes.length) {
        throw new IOException("Could not completely read file "+file.getName());
    }

    // Close the input stream and return bytes
    is.close();
    return bytes;
}

Input Stream is ...
ByteArrayOutputStream bos = new ByteArrayOutputStream();
int next = in.read();
while (next > -1) {
    bos.write(next);
    next = in.read();
}
bos.flush();
byte[] result = bos.toByteArray();
bos.close();

Java 9 จะให้วิธีที่ดีแก่คุณ:

InputStream in = ...;
ByteArrayOutputStream bos = new ByteArrayOutputStream();
in.transferTo( bos );
byte[] bytes = bos.toByteArray();

ฉันรู้ว่ามันสายเกินไป แต่ที่นี่ฉันคิดว่าเป็นโซลูชันที่สะอาดกว่าและอ่านง่ายกว่า ...

/**
 * method converts {@link InputStream} Object into byte[] array.
 * 
 * @param stream the {@link InputStream} Object.
 * @return the byte[] array representation of received {@link InputStream} Object.
 * @throws IOException if an error occurs.
 */
public static byte[] streamToByteArray(InputStream stream) throws IOException {

    byte[] buffer = new byte[1024];
    ByteArrayOutputStream os = new ByteArrayOutputStream();

    int line = 0;
    // read bytes from stream, and store them in buffer
    while ((line = stream.read(buffer)) != -1) {
        // Writes bytes from byte array (buffer) into output stream.
        os.write(buffer, 0, line);
    }
    stream.close();
    os.flush();
    os.close();
    return os.toByteArray();
}

Java 8 way (ขอบคุณBufferedReaderและAdam Bien )

private static byte[] readFully(InputStream input) throws IOException {
    try (BufferedReader buffer = new BufferedReader(new InputStreamReader(input))) {
        return buffer.lines().collect(Collectors.joining("\n")).getBytes(<charset_can_be_specified>);
    }
}

โปรดทราบว่าวิธีแก้ปัญหานี้จะทำการปัดคืนค่าขนส่ง ('\ r') และอาจไม่เหมาะสม

ฉันพยายามแก้ไขคำตอบ @ numan ด้วยการแก้ไขสำหรับการเขียนข้อมูลขยะ แต่การแก้ไขถูกปฏิเสธ ในขณะที่โค้ดสั้น ๆ นี้ไม่มีอะไรที่ยอดเยี่ยม แต่ฉันไม่เห็นคำตอบที่ดีกว่านี้ นี่คือสิ่งที่สมเหตุสมผลที่สุดสำหรับฉัน:

ByteArrayOutputStream out = new ByteArrayOutputStream();
byte[] buffer = new byte[1024]; // you can configure the buffer size
int length;

while ((length = in.read(buffer)) != -1) out.write(buffer, 0, length); //copy streams
in.close(); // call this in a finally block

byte[] result = out.toByteArray();

ไม่จำเป็นต้องปิด btw ByteArrayOutputStream ลอง / สร้างโครงสร้างที่ละเว้นเพื่อความสามารถในการอ่าน

ดูInputStream.available()เอกสารประกอบ:

เป็นสิ่งสำคัญอย่างยิ่งที่ต้องตระหนักว่าคุณต้องไม่ใช้วิธีนี้ในการกำหนดขนาดของคอนเทนเนอร์และสมมติว่าคุณสามารถอ่านสตรีมทั้งหมดได้โดยไม่จำเป็นต้องปรับขนาดคอนเทนเนอร์ ผู้เรียกดังกล่าวควรเขียนทุกสิ่งที่พวกเขาอ่านไปยัง ByteArrayOutputStream และแปลงให้เป็นอาร์เรย์ไบต์ หรือหากคุณกำลังอ่านจากไฟล์ File.length จะส่งคืนความยาวปัจจุบันของไฟล์ (แม้ว่าการสมมติว่าความยาวของไฟล์ไม่สามารถเปลี่ยนแปลงได้อาจไม่ถูกต้อง แต่การอ่านไฟล์นั้นจะมีชีวิตชีวา)

ห่อไว้ใน DataInputStream หากไม่อยู่ในตารางด้วยเหตุผลบางอย่างเพียงใช้การอ่านเพื่อตอกหมุดมันจนกว่ามันจะให้ -1 หรือบล็อกทั้งหมดที่คุณขอ

public int readFully(InputStream in, byte[] data) throws IOException {
    int offset = 0;
    int bytesRead;
    boolean read = false;
    while ((bytesRead = in.read(data, offset, data.length - offset)) != -1) {
        read = true;
        offset += bytesRead;
        if (offset >= data.length) {
            break;
        }
    }
    return (read) ? offset : -1;
}

เราเห็นความล่าช้าในการทำธุรกรรม AWS บางรายการในขณะที่แปลงวัตถุ S3 เป็น ByteArray

หมายเหตุ: S3 Object เป็นเอกสาร PDF (ขนาดสูงสุดคือ 3 mb)

เรากำลังใช้ตัวเลือก # 1 (org.apache.commons.io.IOUtils) เพื่อแปลงวัตถุ S3 เป็น ByteArray เราได้สังเกตเห็น S3 ให้วิธี inbuild IOUtils ในการแปลงวัตถุ S3 เป็น ByteArray เราขอให้คุณยืนยันว่าวิธีที่ดีที่สุดในการแปลงวัตถุ S3 เป็น ByteArray คืออะไรเพื่อหลีกเลี่ยงความล่าช้า

ตัวเลือกที่ 1:

import org.apache.commons.io.IOUtils;
is = s3object.getObjectContent();
content =IOUtils.toByteArray(is);

ตัวเลือก # 2:

import com.amazonaws.util.IOUtils;
is = s3object.getObjectContent();
content =IOUtils.toByteArray(is);

นอกจากนี้ยังแจ้งให้เราทราบหากเรามีวิธีอื่นที่ดีกว่าในการแปลงวัตถุ s3 เป็น bytearray

อีกกรณีหนึ่งเพื่อรับอาร์เรย์ไบต์ที่ถูกต้องผ่านสตรีมหลังจากส่งคำขอไปยังเซิร์ฟเวอร์และรอการตอบกลับ

/**
         * Begin setup TCP connection to PC app
         * to open integrate connection between mobile app and pc app (or mobile app)
         */
        mSocket = new Socket(IP, port);
       // mSocket.setSoTimeout(30000);

        DataOutputStream mDos = new DataOutputStream(mSocket.getOutputStream());

        String str = "MobileRequest#" + params[0] + "#<EOF>";

        mDos.write(str.getBytes());

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        /* Since data are accepted as byte, all of them will be collected in the
        following byte array which initialised with accepted data length. */
        DataInputStream mDis = new DataInputStream(mSocket.getInputStream());
        byte[] data = new byte[mDis.available()];

        // Collecting data into byte array
        for (int i = 0; i < data.length; i++)
            data[i] = mDis.readByte();

        // Converting collected data in byte array into String.
        String RESPONSE = new String(data);

คุณกำลังทำสำเนาเพิ่มเติมหากคุณใช้ ByteArrayOutputStream หากคุณทราบความยาวของสตรีมก่อนที่จะเริ่มอ่าน (เช่น InputStream เป็น FileInputStream จริง ๆ และคุณสามารถเรียกไฟล์ file.length () บนไฟล์หรือ InputStream เป็นรายการ zipfile InputStream และคุณสามารถเรียก zipEntry ได้ length ()) จากนั้นควรเขียนลงในอาร์เรย์ byte [] โดยตรงดีกว่า - ใช้หน่วยความจำครึ่งหนึ่งและประหยัดเวลา

// Read the file contents into a byte[] array
byte[] buf = new byte[inputStreamLength];
int bytesRead = Math.max(0, inputStream.read(buf));

// If needed: for safety, truncate the array if the file may somehow get
// truncated during the read operation
byte[] contents = bytesRead == inputStreamLength ? buf
                  : Arrays.copyOf(buf, bytesRead);

หมายเหตุบรรทัดสุดท้ายด้านบนเกี่ยวข้องกับไฟล์ที่ถูกตัดทอนในขณะที่สตรีมกำลังอ่านหากคุณจำเป็นต้องจัดการกับความเป็นไปได้นั้น แต่ถ้าไฟล์ยาวขึ้นในขณะที่สตรีมกำลังอ่านเนื้อหาในอาร์เรย์ [] จะไม่ยาวขึ้น รวมถึงเนื้อหาของแฟ้มใหม่อาร์เรย์ก็จะถูกตัดทอนความยาวเก่าinputStreamLength

ฉันใช้สิ่งนี้

public static byte[] toByteArray(InputStream is) throws IOException {
        ByteArrayOutputStream output = new ByteArrayOutputStream();
        try {
            byte[] b = new byte[4096];
            int n = 0;
            while ((n = is.read(b)) != -1) {
                output.write(b, 0, n);
            }
            return output.toByteArray();
        } finally {
            output.close();
        }
    }

นี่คือเวอร์ชันคัดลอกของฉัน:

@SuppressWarnings("empty-statement")
public static byte[] inputStreamToByte(InputStream is) throws IOException {
    if (is == null) {
        return null;
    }
    // Define a size if you have an idea of it.
    ByteArrayOutputStream r = new ByteArrayOutputStream(2048);
    byte[] read = new byte[512]; // Your buffer size.
    for (int i; -1 != (i = is.read(read)); r.write(read, 0, i));
    is.close();
    return r.toByteArray();
}

Java 7 และใหม่กว่า:

import sun.misc.IOUtils;
...
InputStream in = ...;
byte[] buf = IOUtils.readFully(in, -1, false);

คุณสามารถลองCactoos :

byte[] array = new BytesOf(stream).bytes();

นี่คือรุ่นที่ปรับให้เหมาะสมซึ่งพยายามหลีกเลี่ยงการคัดลอกไบต์ข้อมูลให้มากที่สุด:

private static byte[] loadStream (InputStream stream) throws IOException {
   int available = stream.available();
   int expectedSize = available > 0 ? available : -1;
   return loadStream(stream, expectedSize);
}

private static byte[] loadStream (InputStream stream, int expectedSize) throws IOException {
   int basicBufferSize = 0x4000;
   int initialBufferSize = (expectedSize >= 0) ? expectedSize : basicBufferSize;
   byte[] buf = new byte[initialBufferSize];
   int pos = 0;
   while (true) {
      if (pos == buf.length) {
         int readAhead = -1;
         if (pos == expectedSize) {
            readAhead = stream.read();       // test whether EOF is at expectedSize
            if (readAhead == -1) {
               return buf;
            }
         }
         int newBufferSize = Math.max(2 * buf.length, basicBufferSize);
         buf = Arrays.copyOf(buf, newBufferSize);
         if (readAhead != -1) {
            buf[pos++] = (byte)readAhead;
         }
      }
      int len = stream.read(buf, pos, buf.length - pos);
      if (len < 0) {
         return Arrays.copyOf(buf, pos);
      }
      pos += len;
   }
}

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

    fun InputStream.readBytesWithSize(size: Long): ByteArray? {
        return when {
            size < 0L -> this.readBytes()
            size == 0L -> ByteArray(0)
            size > Int.MAX_VALUE -> null
            else -> {
                val sizeInt = size.toInt()
                val result = ByteArray(sizeInt)
                readBytesIntoByteArray(result, sizeInt)
                result
            }
        }
    }

    fun InputStream.readBytesIntoByteArray(byteArray: ByteArray,bytesToRead:Int=byteArray.size) {
        var offset = 0
        while (true) {
            val read = this.read(byteArray, offset, bytesToRead - offset)
            if (read == -1)
                break
            offset += read
            if (offset >= bytesToRead)
                break
        }
    }

ถ้าคุณรู้ขนาดมันจะช่วยให้คุณประหยัดการเพิ่มหน่วยความจำที่ใช้เป็นสองเท่าเมื่อเทียบกับโซลูชั่นอื่น ๆ (ในช่วงเวลาสั้น ๆ แต่ก็ยังมีประโยชน์) นั่นเป็นเพราะคุณต้องอ่านสตรีมทั้งหมดจนจบจากนั้นแปลงเป็นอาร์เรย์ไบต์ (คล้ายกับ ArrayList ที่คุณแปลงเป็นเพียงอาร์เรย์)

ตัวอย่างเช่นถ้าคุณใช้ Android คุณมี Uri ให้จัดการคุณสามารถลองใช้ขนาดนี้ได้:

    fun getStreamLengthFromUri(context: Context, uri: Uri): Long {
        context.contentResolver.query(uri, arrayOf(MediaStore.MediaColumns.SIZE), null, null, null)?.use {
            if (!it.moveToNext())
                return@use
            val fileSize = it.getLong(it.getColumnIndex(MediaStore.MediaColumns.SIZE))
            if (fileSize > 0)
                return fileSize
        }
        //if you wish, you can also get the file-path from the uri here, and then try to get its size, using this: https://stackoverflow.com/a/61835665/878126
        FileUtilEx.getFilePathFromUri(context, uri, false)?.use {
            val file = it.file
            val fileSize = file.length()
            if (fileSize > 0)
                return fileSize
        }
        context.contentResolver.openInputStream(uri)?.use { inputStream ->
            if (inputStream is FileInputStream)
                return inputStream.channel.size()
            else {
                var bytesCount = 0L
                while (true) {
                    val available = inputStream.available()
                    if (available == 0)
                        break
                    val skip = inputStream.skip(available.toLong())
                    if (skip < 0)
                        break
                    bytesCount += skip
                }
                if (bytesCount > 0L)
                    return bytesCount
            }
        }
        return -1L
    }

/*InputStream class_InputStream = null;
I am reading class from DB 
class_InputStream = rs.getBinaryStream(1);
Your Input stream could be from any source
*/
int thisLine;
ByteArrayOutputStream bos = new ByteArrayOutputStream();
while ((thisLine = class_InputStream.read()) != -1) {
    bos.write(thisLine);
}
bos.flush();
byte [] yourBytes = bos.toByteArray();

/*Don't forget in the finally block to close ByteArrayOutputStream & InputStream
 In my case the IS is from resultset so just closing the rs will do it*/

if (bos != null){
    bos.close();
}