在Java中将InputStream转换为字节数组


Answers:


1134

您可以使用Apache Commons IO处理此任务和类似任务。

IOUtils类型具有用于读取InputStream和返回的静态方法byte[]

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

在内部,这会创建一个ByteArrayOutputStream并将字节复制到输出,然后调用toByteArray()。它通过复制4KiB块中的字节来处理大型文件。


188
如果想编写4行代码,您认为导入第3方依赖关系值得吗?
oxbow_lakes

217
如果有一个库可以处理需求并处理大文件的处理,并且经过了良好的测试,那么肯定的问题是我为什么要自己编写它?罐子只有107KB,如果您需要其中一种方法,您也可能会使用其他方法
Rich Seller

242
@oxbow_lakes:考虑到我在开发人员的生活中看到的此功能的错误实现的惊人数量,我认为的,非常有必要依靠外部依赖来实现它。
Joachim Sauer 2010年

17
为什么不去看看Apache Commons之类的东西,FastArrayList或它们的软性和弱性参考Maps,然后回来告诉我这个库是如何“经过充分测试的”。这是一堆垃圾
oxbow_lakes

87
除了Apache commons-io外,还可以从Google Guava中检出ByteStreams类。 InputStream is; byte[] filedata=ByteStreams.toByteArray(is);
michaelok

446

您需要读取您的每个字节InputStream并将其写入ByteArrayOutputStream

然后,您可以调用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();

16
新创建的byte []的大小如何?为什么是16384?如何确定正确的尺寸?非常感谢你。
Ondrej Bozek

6
16384是一个相当随意的选择,尽管我倾向于支持2的幂以增加数组与单词边界对齐的机会。pihentagy的答案显示了如何避免使用中间缓冲区,而是分配正确大小的数组。除非您处理的是大文件,否则我个人更喜欢上面的代码,该代码更加优雅,可用于InputStreams,而其中的读取字节数事先未知。
亚当斯基2012年

@Adamski是否创建的字节数组比您期望的数据流大得多,浪费了内存?
Paul Brewczynski 2013年

@bluesm:是的,这是正确的。但是,在我的示例中,字节数组仅为16Kb,以今天的标准来看是如此之小。同样,此内存当然会在之后再次释放。
亚当斯基

5
@Adamski许多基础架构硬件,Web服务器和OS层组件都在使用4K缓冲区来移动数据,这就是确切数目的原因,但是要点是,超过4K时,性能提升不大通常被认为浪费内存。我认为这仍然是正确的,因为这是我已有的十年知识!


132

使用香草Java DataInputStream及其readFully方法(至少从Java 1.4开始存在):

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

这种方法还有其他几种风格,但是在此用例中,我一直都使用这种方法。


45
+1用于使用标准库而不是第三方依赖。不幸的是,它对我不起作用,因为我不知道流的长度。
Andrew Spencer 2012年

2
什么是imgFile?它不能是InputStream,它应该是此方法的输入
Janus Troelsen

4
@janus是一个“文件”。只有当您知道文件的长度或要读取的字节数时,这种方式才有效。
dermoritz

5
有趣的是,但是您必须知道要读取的(部分)流的确切长度。而且,该类DataInputStream是主要的,用于从流中读取主要类型(Long,Short,Chars ...),因此我们可以将这种用法视为对类的滥用。
Olivier Faucheux,2015年

17
如果您已经知道要从流中读取的数据长度,那么这并不比更好InputStream.read
Logan Pickup

119

如果您碰巧使用了Google番石榴,它将变得非常简单:

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

8
ByteStreams标注有@Beta
Kid101


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

2
这是一个例子,因此简洁是当下的事。在某些情况下,在此处还返回null是正确的选择(尽管在生产环境中,您还将具有适当的异常处理和文档记录)。

11
我在一个示例中理解简洁,但是为什么不仅仅让示例方法抛出IOException而不是吞下它并返回无意义的值呢?
彭多

4
我已自由地从“返回null”更改为“引发IOException”
kritzikratzi 2015年

3
这里不需要尝试资源,因为ByteArrayOutputStream#close()不执行任何操作。(不需要ByteArrayOutputStream#flush()也不做任何事情。)
Luke Hutchison

25

安全解决方案(具有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);
            }
        }
    }
  • 科特林版本(无法访问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请参见此处


难道不是因为某个时候您既拥有缓冲区又拥有字节数组,所以在某个时候您将使用的内存加倍吗?没有办法直接将字节发送到输出字节数组吗?
Android开发人员

@androiddeveloper; 对不起。我不知道答案!但是我不这么认为。我认为这种方式(使用缓冲区)是一种优化的方式。
Mir-Ismaili

我已经检查过了,但确实如此,但这似乎是您不知道尺寸时唯一可以选择的解决方案。如果您已经知道大小,则可以直接创建具有给定大小的字节数组并填充它。因此,您使用的函数将获取字节大小的参数,并且如果该参数有效,则可使用它直接创建并填充字节数组,而无需创建任何其他大对象。
Android开发人员

@androiddeveloper; 感谢你的信息。我不认识他们
Mir-Ismaili

19

您是否真的需要图像byte[]?您究竟希望byte[]图像文件的完整内容,以图像文件所使用的任何格式或RGB像素值进行编码的是什么?

这里的其他答案显示了如何将文件读入byte[]。您byte[]将包含文件的确切内容,并且您需要对其进行解码以对图像数据进行任何处理。

ImageIO API是Java用于读取(和写入)图像的标准API,您可以在包中找到它javax.imageio。您只需一行代码就可以从文件中读取图像:

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

这会给你一个BufferedImage,而不是一个byte[]。要获取的图像数据,可以调用getRaster()BufferedImage。这将为您提供一个Raster对象,该对象具有访问像素数据的方法(它具有多个getPixel()/getPixels()方法)。

查找API文档javax.imageio.ImageIOjava.awt.image.BufferedImagejava.awt.image.Raster等。

ImageIO默认情况下支持多种图像格式:JPEG,PNG,BMP,WBMP和GIF。可以增加对更多格式的支持(您需要一个实现ImageIO服务提供商接口的插件)。

另请参见以下教程:使用图像


16

万一有人还在寻找没有依赖性的解决方案,并且如果您有file

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

说,如果字节数组太大会导致堆OOM,该怎么办?有没有类似的解决方案,将使用JNI来存储字节,以后我们将能够使用存储在那里的数据中的inputStream(某种临时缓存)?
Android开发人员

14

如果您不想使用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;
}

这是一个奇怪的解决方案,长度是数组长度的上限。如果您知道长度,则只需要:byte [] output = new byte [length]; is.read(输出); (但请看我的回答)
卢克·哈奇森

如我所说,@ luke-hutchison,这是sun.misc.IOUtils的解决方案。在最常见的情况下,您不知道InputStream的大小,因此,如果(length == -1)length = Integer.MAX_VALUE; 适用。即使给定的长度大于InputStream的长度,此解决方案仍然有效。
克里斯蒂安·克拉里奇

@LukeHutchison如果您知道长度,则可以用几行来处理。如果查看每个答案,每个人都会抱怨长度未知。最后,这是一个标准答案,可以与Java 7 Android一起使用,并且不需要任何外部库。
卡萨巴·托斯

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

8

@Adamski:您可以完全避免缓冲。

http://www.exampledepot.com/egs/java.io/File2ByteArray.html复制的代码(是的,它很冗长,但需要的内存大小是其他解决方案的一半。)

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

5
取决于预先知道的大小。
stolsvik

2
当然,但是他们应该知道大小:“我想阅读图像”
pihentagy

1
如果您知道大小,那么java将为您提供代码。看到我的答案或谷歌的“ DataInputStream”,它是readFully方法。
dermoritz

is.close()如果抛出该异常,则应添加if offset < bytes.lengthInputStream将不会关闭。
贾里德·鲁姆勒

3
更好的是,您应该使用try-with-resources
pihentagy 2015年

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

但是,通常操作系统已经足够缓冲了,对于较小的文件来说就不用担心了。并不是说硬盘头会分别读取每个字节(硬盘是上面有磁性编码信息的旋转玻璃板,有点像我们用来保存数据的怪异图标:P)。
Maarten Bodewes,2016年

6
@Maarten Bodewes:大多数设备都有一种块传输,因此,并非每个read()都会导致实际的设备访问,但是每个字节进行一次OS调用已经足以破坏性能。虽然包裹InputStreamBufferedInputStream代码之前,会降低OS-电话和显著减轻性能缺点,该代码将仍然执行从一个缓冲到另一个不必要的手动复制工作。
Holger

4

Java 9最终将为您提供一个不错的方法:

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

4
这和InputStram.readAllBytes()单线有什么区别?
Slava Semushin

2

我知道为时已晚,但在这里我认为这是更易读的解决方案...

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

4
您应该使用try-with-resources。
维克多·斯塔夫萨

如果出现错误,您需要在finally块中进行最后的整理,否则可能导致内存泄漏。
MGDavies

2

Java 8方法(感谢BufferedReaderAdam 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'),可能不合适。


4
那是为了String。OP正在要求byte[]
FrozenFire '17

不仅仅是\r这可能是一个问题。此方法将字节转换为字符,然后再次返回(使用InputStreamReader的默认字符集)。在默认字符编码中无效的任何字节(例如,在Linux上为UTF-8,则为-1)将被破坏,甚至有可能更改字节数。
seanf '18

似乎这是一个很好的答案,但面向文本。买家当心。
Wheezil '18

1

我试图用修复垃圾数据的方法来编辑@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不需要关闭。尝试/最终构造被省略,以提高可读性


1

请参阅InputStream.available()文档:

特别重要的是要认识到您一定不能使用此方法来调整容器的大小,并假定您可以读取整个流而无需调整容器的大小。这样的调用者可能应该将读取的所有内容写入ByteArrayOutputStream并将其转换为字节数组。另外,如果您正在读取文件,则File.length返回文件的当前长度(尽管假设文件的长度不能更改,但读取文件本质上是不道德的)。


1

如果出于某种原因不在表中,则将其包装在DataInputStream中,只需使用read对其进行锤击,直到它得到-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;
}

1

在将S3对象转换为ByteArray的同时,很少有AWS事务出现延迟。

注意:S3对象是PDF文档(最大大小为3 mb)。

我们正在使用选项#1(org.apache.commons.io.IOUtils)将S3对象转换为ByteArray。我们注意到S3提供了将S3对象转换为ByteArray的内置IOUtils方法,请您确认什么是将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对象转换为字节数组


0

另一种情况是在向服务器发送请求并等待响应之后,通过流获取正确的字节数组。

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

0

如果使用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);

注意,上面的最后一行处理在读取流时文件被截断的情况,如果您需要处理这种情况,但是如果在读取流时文件变,则byte []数组中的内容将不会加长为了包括新文件内容,该数组将被截断为旧长度inputStreamLength


0

我用这个

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

2
与答案添加一些解释如何回答帮助OP在固定电流问题
ρяσѕρєяķ

0

这是我的复制粘贴版本:

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

2
尽管此代码段可以解决问题,但提供说明确实有助于提高您的帖子质量。请记住,您将来会为读者回答这个问题,而这些人可能不知道您提出代码建议的原因。
Ferrybig '16

0

Java 7及更高版本:

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

20
sun.misc.IOUtils不是“ Java 7”。它是专有的,特定于实现的类,在其他JRE实现中可能不存在,并且可以在下一发行版中的任何警告下消失。
Holger


0

这是一个优化的版本,它试图避免尽可能多地复制数据字节:

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

0

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
    }

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

关闭和冲洗Bos浪费了键盘点击次数。关闭输入流更有可能提供帮助。一次读取一个字节效率很低。请参阅numan的答案。
akostadinov
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.