问题描述
有两个问题。
-
如果编码为 bis.read() 而不是 bis.read(bys)，程序实际上会做什么？ （无论如何它都可以工作，但速度要慢得多。）
-
为什么 bos.write(bys) 比 bos.write(bys,len) 快得多？ （我预计两者在运行中的速度相同。）
谢谢！
public class copyFileBfdbytes {
public static void main(String[] args) throws IOException {
FileInputStream fis = new FileInputStream("d:/Test1/M1.MP3");
BufferedInputStream bis = new BufferedInputStream(fis);
FileOutputStream fos = new FileOutputStream("d:/Test2/M2.mp3");
bufferedoutputstream bos = new bufferedoutputstream(fos);
byte[] bys = new byte[8192];
int len;
while ((len = bis.read(bys)) != -1){
// while ((len = bis.read()) != -1){ // 1. Why does it still work when bys in bis.read() is missing?
bos.write(bys);
// bos.write(bys,len); // 2. Why is this slower than bos.write(bys)?
bos.flush();
}
fis.close();
bis.close();
fos.close();
bos.close();
}
}
解决方法
首先，您似乎只想按原样复制文件。有更简单的方法（甚至可能是更高效的方法）来做到这一点。
其他复制数据的方法
复制文件
如果您需要的只是复制示例中的实际文件，您可以简单地使用：
package example;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
public class SO66024231 {
public static void main(String[] args) throws IOException {
Files.copy(Paths.get("d:/Test1/M1.MP3"),Paths.get("d:/Test2/M2.mp3"));
}
}
这很可能是最容易描述的（例如，其他开发人员实际上看到了您想要做什么）并且可以由底层系统非常有效地完成。
将数据从任何来源复制到任何目的地（InputStream to OutputStream）
如果您需要将数据从任何 InputStream 传输到任何 OutputStream，您可以使用 InputStream#transferTo(OutputStream) 方法：
package example;
import java.io.*;
public class SO66024231 {
public static void main(String[] args) throws IOException {
try (InputStream fis = new FileInputStream("d:/Test1/M1.MP3")) {
try (OutputStream fos = new FileOutputStream("d:/Test2/M2.mp3")) {
fis.transferTo(fos);
}
}
}
}
深入描述您的问题
注意：我将一般性地讨论 InputStream 和 OutputStream。您使用了 BufferedInputStream 和 BufferedOutputStream。这些是内部缓冲数据的特定实现。这个内部缓冲与我接下来要讲的缓冲无关！
输入流
InputStream#read() 和 InputStream#read(byte[]) 之间存在根本区别。
InputStream#read() 从 InputStream 读取一个字节并返回它。如果 Stream 耗尽（没有更多数据），则返回值为 int 或 0-255 范围内的 -1。
package example;
import java.io.*;
public class SO66024231 {
public static void main(String[] args) throws IOException {
final byte[] myBytes = new byte[]{-1,3,4,5,6,7,8,127};
printAllBytes(new ByteArrayInputStream(myBytes));
}
public static void printAllBytes(InputStream in) throws IOException {
int currByte;
while ((currByte = in.read()) != -1) {
System.out.println((byte) currByte);// note the cast to byte!
}
// prints: -1,127
}
}
InputStream#read(byte[]) 然而，完全不同。它采用 byte[] 作为参数，用作缓冲区。然后它（在内部）尝试用目前可以获得的尽可能多的字节填充给定的缓冲区，并返回它已填充的实际字节数或 -1（如果 Stream 是累死了。
示例：
package example;
import java.io.*;
public class SO66024231 {
public static void main(String[] args) throws IOException {
final byte[] myBytes = new byte[]{-1,127};
printAllBytes(new ByteArrayInputStream(myBytes));
}
public static void printAllBytes(InputStream in) throws IOException {
final byte[] buffer = new byte[2];// do not use this small buffer size. This is just for the example
int bytesRead;
while ((bytesRead = in.read(buffer)) != -1) {
// loop from 0 to bytesRead,!NOT! to buffer.length!!!
for (int i = 0; i < bytesRead; i++) {
System.out.println(buffer[i]);
}
}
// prints: -1,127
}
}
不好的例子： 现在是一个不好的例子。以下代码包含编程错误，请勿使用！
我们现在从 0 循环到 buffer.length，但我们的输入数据正好包含 9 字节。这意味着，在最后一次迭代中，我们的缓冲区将只填充一个字节。我们缓冲区中的第二个字节不会被触及。
package example;
import java.io.*;
public class SO66024231 {
/**
* ERROURNOUS EXAMPLE!!! DO NOT USE
*/
public static void main(String[] args) throws IOException {
final byte[] myBytes = new byte[]{-1,127};
printAllBytes(new ByteArrayInputStream(myBytes));
}
public static void printAllBytes(InputStream in) throws IOException {
final byte[] buffer = new byte[2];// do not use this small buffer size. This is just for the example
int bytesRead;
while ((bytesRead = in.read(buffer)) != -1) {
for (int i = 0; i < buffer.length; i++) {
System.out.println(buffer[i]);
}
}
// prints: -1,127,8 <-- see; the 8 is printed because we ignored the bytesRead value in our for loop; the 8 is still in our buffer from the previous iteration
}
}
输出流
既然我已经描述了阅读的不同之处，我将向您描述写作的不同之处。
首先，正确的例子（使用OutputStream.write(byte[],int,int)）：
package example;
import java.io.*;
import java.util.Arrays;
public class SO66024231 {
public static void main(String[] args) throws IOException {
final byte[] myBytes = new byte[]{-1,127};
final byte[] copied = copyAllBytes(new ByteArrayInputStream(myBytes));
System.out.println(Arrays.toString(copied));// prints: [-1,127]
}
public static byte[] copyAllBytes(InputStream in) throws IOException {
final ByteArrayOutputStream bos = new ByteArrayOutputStream();
final byte[] buffer = new byte[2];
int bytesRead;
while ((bytesRead = in.read(buffer)) != -1) {
bos.write(buffer,bytesRead);
}
return bos.toByteArray();
}
}
还有一个不好的例子：
package example;
import java.io.*;
import java.util.Arrays;
public class SO66024231 {
/*
ERRORNOUS EXAMPLE!!!!
*/
public static void main(String[] args) throws IOException {
final byte[] myBytes = new byte[]{-1,8] <-- see; the 8 is here again
}
public static byte[] copyAllBytes(InputStream in) throws IOException {
final ByteArrayOutputStream bos = new ByteArrayOutputStream();
final byte[] buffer = new byte[2];
int bytesRead;
while ((bytesRead = in.read(buffer)) != -1) {
bos.write(buffer);
}
return bos.toByteArray();
}
}
这是因为，就像在我们使用 InputStream 的示例中一样，如果我们忽略 bytesRead，我们将向 OutputStream 写入一个我们不想要的值：来自前一次迭代的字节 8。这是因为在内部，OutputStream#write(byte[])（在大多数实现中）只是 OutputStream.write(buffer,buffer.length) 的快捷方式。这意味着它会将整个缓冲区写入 OutputStream。