流的基本概念
在java.io包中File类是唯一一个与文件本身有关的程序处理类，但是File只能操作文件本身，却不能操作文件内容。在实际的开发中，IO操作的核心意义在于：输入与输出操作。而对于程序，输入和输出可能来自于不同的环境，例如：通过电脑连接服务器进行浏览时，实际上客户端发出了一个信息，而服务端接收到此信息后进行回应处理。
对于服务端或者是客户端实质上传递的就是一种数据流的处理形式，而所谓的数据流指的就是字节数据。而对于这种流的处理形式在java.io包中提供有两类支持：
- 字节处理流：OutputStream()（输入字节流）、InputStream()（输入字节流）；
- 字符处理流：Writer（输出字符流）、Reader（输入字符流）；
所有的流操作都应采用如下统一的步骤进行，下面以文件处理的流程为例：
- 如果进行文件读写操作，则一定要通过File类找到一个文件路径；
- 通过字节流或字符流的子类为父类对象进行实例化；
- 利用字节流或字符流中的方法实现数据的输入与输出操作；
- 流的操作属于资源操作，资源操作必须进行关闭处理；
字节输出流：OutputStream
子节的数据以byte类型为主实现的操作，在进行字节内容输出的时候，可以使用OutputStream类完成，这个类的基本定义如下：
public abstract class OutputStream extends Object implements Closeable, Flushable{}
public interface Closeable extends AutoCloseable{
void close() throws IOException;
}
public interface Flushable{
void flush() throws IOException;
}
可以发现这个类实现了两个接口，于是基本的对应关系如下：
OutputStream类定义的是一个公共的输出操作标准，在这个操作标准中定义有三个内容输出的方法：
- 输出单个字节数据：public abstract void write(int b) throws IOException；
- 输出一组字节数据：public void write(byte[] b) throws IOException；
-
输出部分字节数据：public void write(byte[] b, int off, int len) throws IOException；
需要注意的是OutputStream是一个抽象类，而抽象类如果想要获得实例化对象就需要通过子类实例的向上转型完成。如果想要进行文件内容处理操作，可以使用子类FileOutputStream。
FileOutputStream的构造方法：
- 【覆盖】构造方法：public FileOutputStream(File file) throws FileNotFoundException；
- 【追加】构造方法：public FileOutputStream(File file, boolean append) throws FileNotFoundException
范例：使用FileOutputStream类实现内容输出
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
public class JavaApiDemo {
public static void main(String[] args) throws Exception {
String dirPath = "/Users/fzc/Documents/mydir/mldn.txt";
File file = new File(dirPath);
//判断父目录是否存在，不存在则创建目录
if(file.getParentFile().exists()==false){
file.getParentFile().mkdirs();
}
OutputStream output=new FileOutputStream(file);
String str="www.baidu.com";//输出内容
output.write(str.getBytes());//将字符串转为字节数组
output.close();//关闭资源
}
}
本程序是采用了标准的形式实现了输出的操作处理，并且在整体的处理中，只是创建了文件的父目录，并没有创建文件，而在执行后发现在内容写入前，文件如果不存在会自动创建。另外要注意的是，由于OutputStream的子类也属于AutoCloseable的接口子类，所以对于close()方法也可以简化使用。是否使用自动的关闭取决于项目的整体结构，另外还要注意的是，整个程序中最终是输出了一组的字节数据，但是千万别忘记，OutputStream类中定义的输出方法有三个。
范例：自动关闭处理
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
public class JavaApiDemo {
public static void main(String[] args) throws Exception {
String dirPath = "/Users/fzc/Documents/mydir/mldn.txt";
File file = new File(dirPath);
//判断父目录是否存在，不存在则创建目录
if(file.getParentFile().exists()==false){
file.getParentFile().mkdirs();
}
try (OutputStream output=new FileOutputStream(file,true)){
String str="www.baidu.com\r\n";//输出内容
output.write(str.getBytes());//将字符串转为字节数组
}catch (IOException e){
e.printStackTrace();
}
}
}
字节输入流：InputStream
与OutputStream对应的一个流就是字节输入流，InputStream类主要实现的就是字节数据读取，该类定义如下：
public abstract class InputStream extends Object implements Closeable{}
在InputStream类中定义有如下几个核心方法：
- 读取单个字节数据：
public abstract int read() throws IOException、如果读取到底，返回-1； - 读取一组字节数据：
public int read(byte[] b) throws IOException、返回的读取的个数，如果读到底，返回-1； - 读取一组字节数据的部分内容：
public int read(byte[] b, int off, int len) throws IOException；
InputStream类属于一个抽象类，这时应该依靠它的子类来进行对象实例化，如果要从文件读取可以使用FileInputStream子类。
FileInputStream的构造方法：
- 构造方法：public FileInputStream(File file) throws FileNotFoundException；
范例：使用FileInputStream读取文件数据
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
public class JavaApiDemo {
public static void main(String[] args) throws Exception {
String dirPath = "/Users/fzc/Documents/mydir/mldn.txt";
File file = new File(dirPath);
InputStream input=new FileInputStream(file);
byte[] data=new byte[1024];//开辟一个缓冲区读取数据
int len=input.read(data);//读取数据,数据全部保存在字节数组中，并返回读取个数
System.out.println("【"+new String(data,0,len)+"】");
input.close();
}
}
对于字节输入流中最为棘手的问题就在于：使用read()方法读取的时候只能以字节数组为主进行接收。
从JDK1.9开始，InputStream类中增加了一个新的方法：public byte[] readAllBytes() throws IOException；不过现在并不建议使用该方法在开发中使用，如果要读取的内容量非常大，程序可能直接卡死。
范例：使用readAllBytes()读取文件数据
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
public class JavaApiDemo {
public static void main(String[] args) throws Exception {
String dirPath = "/Users/fzc/Documents/mydir/mldn.txt";
File file = new File(dirPath);
InputStream input=new FileInputStream(file);
byte[] data=input.readAllBytes();//读取全部数据
System.out.println("【"+new String(data)+"】");
input.close();
}
}
字符输出流：Writer
使用OutputStream字节输出流进行数据输出时使用的都是字节类型的数据，但很多情况下字符串的输出更为方便，因此java.io包在JDK1.1时又推出了字符输出流：Writer，这个类的定义如下：
public abstract class Writer extends Object implements Appendable, Closeable, Flushable{}
在Writer类中提供了几个输出的操作方法：
- 输出字符数组：public void write(char[] cbuf) throws IOException；
- 输出字符串：public void write(String str) throws IOException；
- 追加内容：public Writer append(CharSequence csq) throws IOException；
范例：使用Writer类的子类FileWriter进行文件输出
import java.io.File;
import java.io.FileWriter;
public class JavaApiDemo {
public static void main(String[] args) throws Exception {
String dirPath = "/Users/fzc/Documents/mydir/mldn.txt";
File file = new File(dirPath);
if (!file.getParentFile().exists()) {
file.getParentFile().mkdirs();//父目录一定要存在
}
// Writer fileWriter=new FileWriter(file, true);//内容追加
Writer fileWriter = new FileWriter(file);//内容覆盖
String str = "www.baid.com\r\n";
fileWriter.write(str);
fileWriter.append("中国人民万岁！");
fileWriter.close();
}
}
使用Writer输出的最大优势在于可以直接利用字符串完成。Writer是字符流，字符处理的优势在于中文数据处理。
字符输入流：Reader
Reader是实现字符输入流的一种类型，其本身属于一个抽象类，这个类的定义如下：
public abstract class Reader extends Object implements Readable, Closeable{}
public interface Readable{}
Reader类中并没有像Writer类一样提供有整个字符串的输入处理操作，因此只能够利用字符数组来实现接收：
- 读取单个字符：public int read() throws IOException；
- 读取一组数据：public int read(char[] cbuf) throws IOException；
- 读取数组部分数据：public abstract int read(char[] cbuf, int off, int len) throws IOException；
范例：实现数据读取
import java.io.File;
import java.io.FileReader;
import java.io.Reader;
public class JavaApiDemo {
public static void main(String[] args) throws Exception {
String dirPath = "/Users/fzc/Documents/mydir/mldn.txt";
File file = new File(dirPath);
if(file.exists()){
Reader reader= new FileReader(file);
char[] data=new char[1024];
int len=reader.read(data);
System.out.println("读取内容："+new String(data,0,len));
reader.close();
}
}
}
字符流读取的时候只能够按照数组的形式来实现处理操作。
字节流与字符流的区别
通过以上一系列的分析，已经了解了字节流和字符流的基本操作，但是对于这两类流依然是存在区别的，重点来分析一下输出的操作。在使用OutputStream和Writer输出时，最后都使用了close()方法进行了关闭处理。
在使用OutputStream进行输出时，如果没有使用close()方法关闭输出流会发现内容依然可以正常的输出；在使用Writer进行输出时，如果没有使用close()方法关闭输出，内容将无法进行输出，因为Writer使用到了缓冲区，当使用close()方法时实际上会强制刷新缓冲区，将内容进行输出，如果没有关闭，那么将无法进行输出操作，如果此时想要在不关闭的情况下将缓冲区的内容进行输出，可以使用flush()方法强制刷新缓冲区，写入内容。而字节流在进行输出处理时并不会使用到缓冲区，使用缓冲区的字符流更加适合于中文数据处理，所以在日后的开发中，如果涉及包含中文信息的输出，一般都会使用字符流进行处理，但是从另一个角度上，字节流和字符流的基本处理形式是相似的，由于IO大多情况下都是进行数据的传输使用（二进制），所以字节流也是非常重要的。
范例：使用Writer并强制刷新缓冲区
import java.io.File;
import java.io.FileWriter;
import java.io.Writer;
public class JavaApiDemo {
public static void main(String[] args) throws Exception {
String dirPath = "/Users/fzc/Documents/mydir/mldn.txt";
File file = new File(dirPath);
if (!file.getParentFile().exists()) {
file.getParentFile().mkdirs();//父目录一定要存在
}
// Writer writer=new FileWriter(file, true);//内容追加
Writer writer = new FileWriter(file);//内容覆盖
String str = "www.baid.com\r\n";
writer.write(str);
writer.flush();//强制刷新缓冲区，写入内容
writer.append("中国人民万岁！");
writer.close();
}
}
转换流 InputStreamReader与OutputStreamWriter
所谓的转换流指的是可以是实现字节流和字符流操作的功能转换，例如：进行输出时OutputStream需要将内容变为字节数组后才能输出，而Writer可以直接输出字符串，这一点是便利的，因此就有人提出需求所需要提供一种转换的机制，来实现不同流类型的转换操作，为此java.io包中提供了两个类：InputStreamReader、OutputStreamWriter；
InputStreamReader：
public class InputStreamReader extends Reader{}
构造方法：public InputStreamReader(InputStream in);
OutputStreamWriter：
public class OutputStreamWriter extends Writer{}
构造方法：public OutputStreamWriter(OutputStream out);
通过类的继承结构与构造方法可以发现，所谓的转换就处理就是将接收到的字符流对象通过向上转型变成字符流对象
范例：观察转换
import java.io.*;
public class JavaApiDemo {
public static void main(String[] args) throws Exception {
String dirPath = "/Users/fzc/Documents/mydir/mldn.txt";
File file = new File(dirPath);
if (!file.getParentFile().exists()) {
file.getParentFile().mkdirs();//父目录一定要存在
}
OutputStream outputStream=new FileOutputStream(file);
Writer writer=new OutputStreamWriter(outputStream);
writer.write("www.baidu.com\r\n");
writer.close();
}
}
观察一下FileWriter类和FileReader类的继承关系
FileWriter：
public class FileWriter extends OutputStreamWriter{}
构造方法：public InputStreamReader(InputStream in);
FileReader：
public class FileReader extends InputStreamReader{}
构造方法：public OutputStreamWriter(OutputStream out);
实际上所谓的缓存都是指的是程序中间的一道处理缓冲区。
文件拷贝
在操作系统中，这个命令的主要功能是可以实现文件的拷贝处理，现在要求模拟这个命令，指定源文件路径和拷贝的目标路径实现文件的拷贝处理。
需求分析：
- 需要实现文件的拷贝操作，那么就有可能拷贝各种类型的文件，因此选择字节流；
- 在进行拷贝时需要考虑不到大文件的拷贝问题；
实现方案
- 方案一：使用InputStream将全部要拷贝的内容直接读取到程序中，而后一次性输出到目标文件；
如果拷贝的文件过大，程序极有可能会卡死； - 方案二：采用部分拷贝，读取一部分输出一部分数据，核心的操作方法：
- InputStream：public int read(byte[] b) throws IOException；
- OutputStream：public void write(byte[] b, int off, int len) throws IOException；
范例：实现文件拷贝处理
import java.io.*;
/**
* 定义一个文件操作的工具类
*/
class FileUtil {
private File srcFile;//源文件
private File desFile;//目标文件路径
public FileUtil(String src, String des) {
this(new File(src), new File(des));
}
public FileUtil(File srcFile, File desFile) {
this.srcFile = srcFile;
this.desFile = desFile;
}
/**
* 文件拷贝
*
* @return 拷贝是否成功
*/
public boolean copy() throws IOException {
if (srcFile.exists()==false) {
System.out.println("拷贝的源文件不存在");
return false;//源文件不存在拷贝失败
}
if (desFile.getParentFile().exists() == false) {
desFile.getParentFile().mkdirs();//创建父目录
}
byte[] data = new byte[1024];//开辟一个缓冲区
InputStream input = null;
OutputStream output = null;
try {
input = new FileInputStream(srcFile);
output = new FileOutputStream(desFile);
int len = 0;
//1、读取数据到数组之中，随后返回读取的个数
//2、判断个数==-1，如果不是则进行写入
//
// do {
// len = input.read(data);
// if(len!=-1){
// output.write(data, 0, len);
// }
// } while (len != -1);
//更为简便的写法
while ((len=input.read(data))!=-1){
output.write(data,0,len);
}
return true;
} catch (IOException e) {
throw e;
} finally {
if (input != null) {
input.close();
}
if (output != null) {
output.close();
}
}
}
}
public class JavaApiDemo {
public static void main(String[] args) throws Exception {
String src = "/Users/fzc/Documents/mydir/mldn.txt";
String des = "/Users/fzc/Documents/mydir/mldn_copy.txt";
FileUtil fileUtil = new FileUtil(src, des);
System.out.println(fileUtil.copy() ? "文件拷贝成功！" : "文件拷贝失败！");
}
}
需要注意的是，上面的范例是属于文件拷贝最原始的实现，从JDK1.9开始，InputStream和Reader类中都追加了数据转存的处理操作方法：
- 【JDK1.9】InputStream：
public long transferTo(OutputStream out) throws IOException； - 【JDK10】Reader：
public long transferTo(Writer out) throws IOException；
范例：使用转存的方式处理
import java.io.*;
/**
* 定义一个文件操作的工具类
*/
class FileUtil {
private File srcFile;//源文件
private File desFile;//目标文件路径
public FileUtil(String src, String des) {
this(new File(src), new File(des));
}
public FileUtil(File srcFile, File desFile) {
this.srcFile = srcFile;
this.desFile = desFile;
}
/**
* 文件拷贝
*
* @return 拷贝是否成功
*/
public boolean copy() throws IOException {
if (srcFile.exists()==false) {
System.out.println("拷贝的源文件不存在");
return false;//源文件不存在拷贝失败
}
if (desFile.getParentFile().exists() == false) {
desFile.getParentFile().mkdirs();//创建父目录
}
byte[] data = new byte[1024];//开辟一个缓冲区
InputStream input = null;
OutputStream output = null;
try {
input = new FileInputStream(srcFile);
output = new FileOutputStream(desFile);
//一定要注意JDK版本问题
input.transferTo(output);
return true;
} catch (IOException e) {
throw e;
} finally {
if (input != null) {
input.close();
}
if (output != null) {
output.close();
}
}
}
}
public class JavaApiDemo {
public static void main(String[] args) throws Exception {
String src = "/Users/fzc/Documents/mydir/mldn.txt";
String des = "/Users/fzc/Documents/mydir/mldn_copy.txt";
FileUtil fileUtil = new FileUtil(src, des);
System.out.println(fileUtil.copy() ? "文件拷贝成功！" : "文件拷贝失败！");
}
}
范例：实现文件夹拷贝
import java.io.*;
/**
* 定义一个文件操作的工具类
*/
class FileUtil {
private File srcFile;//源文件
private File desFile;//目标文件路径
public FileUtil(File srcFile, File desFile) {
this.srcFile = srcFile;
this.desFile = desFile;
}
public boolean copyDir()throws IOException {
this.copyImpl(srcFile);
return true;
}
private void copyImpl(File file)throws IOException{
if(file.isDirectory()){
File[] results=file.listFiles();
if(results!=null){
for (File res:results){
copyImpl(res);
}
}
}else{
String newFilePath=file.getPath().replace(srcFile.getPath()+File.separator,"");
File newFile=new File(desFile,newFilePath);//目标路径
copyFileImpl(file,newFile);
}
}
private boolean copyFileImpl(File srcFile,File desFile)throws IOException{
if (desFile.getParentFile().exists() == false) {
desFile.getParentFile().mkdirs();//创建父目录
}
byte[] data = new byte[1024];//开辟一个缓冲区
InputStream input = null;
OutputStream output = null;
try {
input = new FileInputStream(srcFile);
output = new FileOutputStream(desFile);
int len = 0;
//1、读取数据到数组之中，随后返回读取的个数
//2、判断个数==-1，如果不是则进行写入
//
// do {
// len = input.read(data);
// if(len!=-1){
// output.write(data, 0, len);
// }
// } while (len != -1);
//更为简便的写法
// while ((len=input.read(data))!=-1){
// output.write(data,0,len);
// }
//一定要注意JDK版本问题
input.transferTo(output);
return true;
} catch (IOException e) {
throw e;
} finally {
if (input != null) {
input.close();
}
if (output != null) {
output.close();
}
}
}
/**
* 文件拷贝
*
* @return 拷贝是否成功
*/
public boolean copy() throws IOException {
if (srcFile.exists()==false) {
System.out.println("拷贝的源文件不存在");
return false;//源文件不存在拷贝失败
}
this.copyFileImpl(srcFile,desFile);
return true;
}
}
public class JavaApiDemo {
public static void main(String[] args) throws Exception {
String src = "/Users/fzc/Documents/mydir";
String des = "/Users/fzc/Documents/mydir_copy";
File srcFile=new File(src),desFile=new File(des);
FileUtil fileUtil = new FileUtil(srcFile, desFile);
if(srcFile.isFile()){
System.out.println(fileUtil.copy() ? "文件拷贝成功！" : "文件拷贝失败！");
}else{
System.out.println(fileUtil.copyDir() ? "目录拷贝成功！" : "目录拷贝失败！");
}
}
}
本程序是IO操作的核心代码，如果理解了本程序，整个IO处理机制也就非常容易理解了。
