字节流(InputStream和OutputStream)，字节流读写文件，字节流的缓冲区，字节缓冲流

字节流

• 抽象类InputStream和OutputStream是字节流的顶级父类
• 所有的字节输入流都继承自InputStream，所有的输出流都继承子OutputStream

InputStream的常用方法：

int read()
int read(byte b[])
int read(byte b[], int off, int len)
void close()


OutputStream的常用方法：

void write(int b)
void write(byte b[])
void write(byte b[], int off, int len)
void flush()
void close()


注意：InputStream和OutputStream是抽象类，不能被实例化

InputStream和OutputStream提供不同的子类，这些子类的体系结构图如下：

字节流读写文件

概述：

在操作文件时，最常见的就是从一个文件中读取数据并将数据写入到另一个文件，这一过程就是文件的读写，针对文件的读写操作，JDK专门提供两个类，分别是FileInputStream和FileOutputStream

FileInputStream是InputStream的子类，操作文件的字节输入流，专门用于读取文件中的数据

创建一个text.txt文件，在文件中输入&＃8221;hello&＃8221;并保存，然后创建一个读取文件的类，代码如下：

package com.Put;
import java.io.FileInputStream;
public class IO {
public static void main(String[] args) throws Exception{
//创建一个文件字节输入流来读取文件
FileInputStream in = new FileInputStream("text.txt");
//定义一个int类型的变量
int b = 0;
//通过循环来读取文件，当返回值为-1结束循环
while ((b=in.read())!=-1){
System.out.print(b+" ");
// System.out.print((char) b+" "); //h e l l o
}
//关闭流
in.close();
}
//运行结果：104 101 108 108 111
}


简述：

在&＃8221;text.txt&＃8221;文件中，字符’h’ ‘e’ ‘l’ ‘l’ &＃8216;o’各占一个字节，因此最终结果显示的是文件&＃8221;text.txt&＃8221;中的5个字节所对应的ASCLL码值

需要注意的是必须保证文件在相应的目录下存在并且是可读，否则或抛出java.io.FileNotFoundException异常，即文件找不到异常

FileOutputStream是OutputStream的子类，操作文件的字节输出流，用于把数据写入文件

FileOutputStream写入数据时，自动创建了文件out.txt，并自定义的字符串写入到目标文件中，代码如下：

package com.Put;
import java.io.FileOutputStream;
public class IO {
public static void main(String[] args) throws Exception{
//创建文件输出流，并指定文件名称
FileOutputStream out = new FileOutputStream("out.txt");
//定义一个字符串
String str = "hello";
//将字符串转换为字节数组进行写入操作
out.write(str.getBytes());
//关闭流
out.close();
}
}


此外，如果通过FileOutputStream向一个已经存在的文件写入数据，那么该文件的数据首先会被清空，再写入新的数据；如果希望再已存在的文件内容后追加新内容，则可以使用FileOutStream的构造函数FileOutputStream(String fileName,boolean append)来创建文件输出流对象，并把append参数的值设置为true，代码如下：

package com.Put;
import java.io.FileOutputStream;
public class IO {
public static void main(String[] args) throws Exception{
//创建文件输出流，并指定文件名称
FileOutputStream out = new FileOutputStream("out.txt",true);
//定义一个字符串
String str = "world";
//将字符串转换为字节数组进行写入操作
out.write(str.getBytes());
//关闭流
out.close();
}
}


注意：如果append参数为false，存在的数据依然会被清空

文件的拷贝

• 文件的拷贝需要通过输入流来读取源文件的数据，并通过输出流将数据写入新的文件(I/O流成对出现，即输入输出流一起使用)

package com.Put;
import java.io.FileInputStream;
import java.io.FileOutputStream;
public class IO {
public static void main(String[] args) throws Exception{
//创建文件输入流对象读取指定目录下的文件
FileInputStream in = new FileInputStream("E:\\Idea\\JavaSE\\重新学习\\resource\\985.png");
//创建文件输出流对象将读取到的文件内容写到指定目录的文件下
FileOutputStream out = new FileOutputStream("E:\\Idea\\JavaSE\\重新学习\\target\\211.png");
//定义一个int类型的变量
int len = 0;
//获取拷贝文件前的系统时间
long beginTime = System.currentTimeMillis();
//循环将读取到的文件字节信息写入到新文件
while ((len=in.read())!=-1){
out.write(len);
}
//获取拷贝后之后的系统时间
long endTime = System.currentTimeMillis();
//输出拷贝花费时间
System.out.println((endTime-beginTime)+"毫秒");
in.close();
out.close();
}
}


简述：

拷贝过程通过while循环将字节逐个进行拷贝，每循环一次，通过FileInputStream的read()方法读取一个字节，并通过FileOutputStream的write()方法将该字节写入指定文件，循环往复，直到读取的长度len为-1，表示读取到文件的末尾，结束循环。文件我使用的是绝对路径(相对绝对都可)。

效果展示：

程序结束耗费地时间：

字节流的缓冲区

通过流的方法拷贝文件时，为了提高传输效率，自定义一个数组作为缓冲区，可以一次性读取多个字节的数据，将数据保存在字节数组中，然后将字节数组的数据一次性写入到新文件中，代码如下：

package com.Put;
import java.io.FileInputStream;
import java.io.FileOutputStream;
public class IO {
public static void main(String[] args) throws Exception{
//创建文件输入流对象读取指定目录下的文件
FileInputStream in = new FileInputStream("E:\\Idea\\JavaSE\\重新学习\\resource\\985.png");
//创建文件输出流对象将读取到的文件内容写到指定目录的文件下
FileOutputStream out = new FileOutputStream("E:\\Idea\\JavaSE\\重新学习\\target\\211.png");
//定义一个int类型的变量
int len = 0;
//定义一个长度为1024的字节数组
byte[] buff = new byte[1024]; //!!!!!!!!!!!!!!!!
//获取拷贝文件前的系统时间
long beginTime = System.currentTimeMillis();
//循环将读取到的文件字节信息写入到新文件
while ((len=in.read(buff))!=-1){ //!!!!!!!!!!!!!!!!!!
out.write(buff,0,len);
}
//获取拷贝后之后的系统时间
long endTime = System.currentTimeMillis();
//输出拷贝花费时间
System.out.println((endTime-beginTime)+"毫秒");
in.close();
out.close();
}
}


简述：在拷贝过程中，使用while循环语句逐渐实现字节文件的拷贝，每循环一次，就从文件读取若干字节填充到数组，并通过变量len记住读入数组的字节数，然后从数组的第一个字节开始，将len个字节写入到新文件。直到len的值为-1，说明已经读到了文件的末尾，循环结束，整个拷贝过程就结束了，最终程序会将整个文件拷贝到目标文件。

运行时间：

字节缓冲流

• 两个带缓冲的字节流，分别是BufferedInputStream和BufferedOutputStream，他们的构造方法中分别接收InputStream和OutputStream类型的参数作为对象，在读取时提供缓冲区功能。

应用程序、缓冲流和底层字节流的关系，如图：

从图可以看出，应用程序时通过缓冲流来完成数据读写的，而缓冲流又是通过底层字节流与设备进行关联的。

BufferedInputStream和BufferedOutputStream这两个缓冲流的用法如下：

package com.Put;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
public class IO {
public static void main(String[] args) throws Exception{
//创建输入输出流字节缓冲流对象
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("E:\\Idea\\JavaSE\\重新学习\\resource\\985.png"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("E:\\Idea\\JavaSE\\重新学习\\target\\211.png"));
//定义一个int类型的变量
int len = 0;
//获取拷贝文件前的系统时间
long beginTime = System.currentTimeMillis();
//通过循环读取输入字节缓冲流中的数据，并通过输出字节缓冲流写入到新文件
while ((bis.read())!=-1) {
bos.write(len);
}
//获取拷贝后之后的系统时间
long endTime = System.currentTimeMillis();
//输出拷贝花费时间
System.out.println((endTime-beginTime)+"毫秒");
//关闭流
bis.close();
bos.close();

}
}


运行结果图：

简述：

创建了BufferedInputStream和BufferedOutputStream这两个缓冲流对象，这两个流内部都定义了一个大小为8192的字节数组，当定义read()和write()方法读取数据时，首先将读写的数据存入到定义的好的字节数组，然后将字节数组一次性读写到文件中。这种方式与字节流的缓冲区相似，都对数据进行了缓冲，提高数据读取的效率。