IO继承关系、字节流和字符流
在Java中，可从中读出一系列数据的对象称为“输入流（InputStream）”，而能向其中写入一系列数据的对象称为“输出流（OutputStream）”。Java的输出/输入都是通过继承抽象类InputStream和OutputStream（面向字节）、Reader和writer（面向字符）来实现的。
一、IO流对象层次关系
二、IO 基本操作
在java.io包中流的操作主要有字节流、字符流两大类，两者都有输入和输出的操作。在字节流中输出数据主要使用OutputStream类完成，输入使用InputStream类。在字符流中输出主要是使用Writer类完成，输入主要使用Reader类完成。
在Java中IO操作也有相应的步骤，以文件的操作为例，主要的操作流程如下：
（1） 使用File类打开一个文件。
（2） 通过字节流或字符流的子类指定输出位置。
（3） 进行读/写操作。
（4） 关闭输入/输出。
下面分别介绍如何使用字节流或字符流保存或读取数据。
三、字节流
字节流主要存操作byte类型数据，以byte数组为准，主要操作类是OutputStream类和InputStream类。
1.字节输出流：OutputStream
OutputStream是整个IO包中字节输出流的最大父类，此类的定义如下：
public abstract class OutputStream extends Objectimplements Closeable, Flushable从以上定义中可以发现，OutputStream是一个抽象类，如果要是使用此类，则首先必须通过子类实例化对象。如果现在操作的是一个文件，则可以使用FileOutputStream类，通过向上转型后，可以为OutputStream实例化，在OutputStream类中的主要操作方法：
// 关闭此输出流并释放与此流有关的所有系统资源
public void close() throws IOException
// 刷新此输出流并强制写出所有缓冲的输出字节。
public void flush() throws IOException
// 将 b.length 个字节从指定的 byte 数组写入此输出流
public void write(byte[] b) throws IOException
// 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流
public void write(byte[] b, int off, int len) throws IOException
范例：向文件中写入字符串。
public class OutputStreamDemo {
/**
* 向文件中写入字符串
*/
public static void main(String[] args) throws IOException {
// 1.使用File类，找到一个将字符串写入的文件
File file = new File("E:" + File.separator + "ops.txt");
// 2.通过子类FileOutputStream实例化OutputStream
OutputStream outputStream = null;
try {
outputStream = new FileOutputStream(file);
// 3.进行写操作
String str = "Hello world!";
byte[] b = str.getBytes();
outputStream.write(b);
} finally {
try {
// 4.关闭输出流
outputStream.close();
} catch (IOException e) {
throw new RuntimeException("关闭字符输出流失败！");
}
}
}
}
①提问：通过上面的例子，我们发现将字符串写入到文件中，但是我们再次运行时会发现，新写入的字符串将过去的覆盖了，我们该如何解决了？
回答：
此时我们应该使用FileOutPutStream的另外一个构造方法：
// 如果第二个参数为 true，则将字节写入文件末尾处，而不是写入文件开始处。
public FileOutputStream(File file, boolean append) throws FileNotFoundException
②提问：如何增加换行？
回答：如果要换行，则直接在字符串要换行处加一个"\r\n"。在windows操作系统中“\r\n”表示换行，但是在Linux操作系统中“\n”表示换行，解决办法，如下：
private static final String FILE_SEPARATOR = System.getProperty("line.separator");2.字节输入流
既然程序可以向文件中写入内容，则也可以通过InputStream从文件中将内容读取出来。InputStream类的定义如下：
public abstract class InputStreamextends Objectimplements Closeable与OutputStream类一样，InputStream本身也是一个抽象类，需要依靠子类来实现，如果从文件中读取数据，子类是FileInputStream。InputStream的主要方法：
// 返回此输入流下一个方法调用可以不受阻塞地从此输入流读取（或跳过）的估计字节数
public int available() throws IOException
// 关闭此输入流并释放与该流关联的所有系统资源。
public void close() throws IOException
// 将输入流中最多 len 个数据字节读入 byte 数组
public int read(byte[] b, int off, int len) throws IOException
范例：从文件中读取内容。
public class InputStreamDemo {
public static void main(String[] args) throws IOException {
// 1.使用File类，找到一个将字符串写入的文件
File file = new File("E:" + File.separator + "ops.txt");
InputStream inputStream = null;
try {
// 2.实例化字节输入流 InputStream对象
inputStream = new FileInputStream(file);
// 3.进行读操作
byte[] bs = new byte[1024];
int len = 0;
while ((len = inputStream.read(bs)) != -1) {
System.out.println(new String(bs, 0, len));
}
} finally {
try {
// 4.关闭资源
inputStream.close();
} catch (IOException e) {
throw new RuntimeException("关闭输入字节流失败！");
}
}
}
}
①问题：上面程序中，开辟的byte数据大小为1024，而实际的内容只有12个字节，显然开辟的空间太大，该怎么解决了？
回答：
byte[] bs = new byte[(int) file.length()];此程序明确知道了要读取的内容为14字节，所以可以定义（int）file.length()大小的空间，如果不确定大小，不建议使用此种方法。
四、字符流
在程序中一个字符等于两个字节，那么Java提供了Reader和Writer两个专门操作字符流的类。
1.字符输出流Writer
此类的定义如下：
public abstract class Writer extends Objectimplements Appendable, Closeable, Flushable关于对Appendable接口的说明，此接口的定义如下：
public interface Appendable {
Appendable append(char c) throws IOException;
Appendable append(CharSequence csq, int start, int end) throws IOException
Appendable append(CharSequence csq) throws IOException
}此接口表示的是内容可以被追加，接受的参数是CharSequence，实际上String类也实现了此接口，所以可以直接通过此接口的方法向输出流中追加内容。
Writer的主要方法：
// 关闭此流，但要先刷新它
public abstract void close()throws IOException
// 刷新该流的缓冲
public abstract void flush() throws IOException
// 写入字符串
public void write(String str) throws IOException
// 写入字符数组
public void write(char[] cbuf) throws IOException
范例：向文件中写入数据
File file = new File("E:" + File.separator + "w.txt");
Writer out = new FileWriter(file);
String str = "hello world!";
out.write(str);
out.close();
2.字符输入流Reader
Reader是使用字符的方式从文件中读取数据，Reader类的定义如下：
public abstract class Reader extends Objectimplements Readable, CloseableReader类的常用方法：
// 关闭该流并释放与之关联的所有资源
public abstract void close()throws IOException
// 读取单个字符
public int read() throws IOException
// 将字符读入数组
public int read(char[] cbuf) throws IOException
范例：从文件中读取内容
File file = new File("E:" + File.separator + "w.txt");
Reader reader = new FileReader(file);
char[] c = new char[1024];
int len = 0;
while ((len = reader.read(c)) != -1) {
System.out.println(new String(c, 0, len));
}
reader.close();
五、字节流与字符流的区别
字节流与字符流使用非常相似，两者除了操作代码上的不同之外，是否还有其他的不同了？
实际上字节流在操作时本身不会用到缓冲区（内存），是文件本身操作的，二字符流在操作时使用了缓冲区，通过缓冲区在操作文件。
下面一两个写文件的操作为主进行比较，但是在操作时字节流和字符流的操作完成之后都不关闭输出流。
范例：使用字节流不关闭执行
File file = new File("E:" + File.separator + "ops.txt");
OutputStream outputStream = new FileOutputStream(file);
String str = "Hello world!";
byte[] b = str.getBytes();
outputStream.write(b);
// 关闭输出流
// outputStream.close();
没有关闭字节流操作，但是文件中也依然存在输出的内容，证明字节流是直接操作文件本身的。下面使用字符流，观察效果
范例：使用字符流不关闭执行
File file = new File("E:" + File.separator + "w.txt");
Writer out = new FileWriter(file);
String str = "hello world!";
out.write(str);
// 关闭输出流
// out.close();
程序运行之后发现文件中没有任何内容，这是因为字符流操作使用了缓冲区，而在关闭字符流时会强制性的将缓冲区中的内容进行输出，但是如果程序没有关闭，则缓冲区中的内容是无法输出的，所以得出结论：字符流使用缓冲区，而字节流没有使用缓冲区。
①问题：什么是缓冲区？
回答：可以简单地把缓冲区理解为一段特殊的内存。
某些情况下，一个程序频繁地操作一个资源（如文件），则性能会很低，此时为了提升性能，就可以将一部分数据暂时读入到内存的一块区域中，以后直接从此区域中读取数据即可，因为读内存速度比较快，这样提高性能。
强制性清空缓冲区
OutputStream的flush()方法。
②问题：使用字节流好还是字符流好？
回答：字节流更好。所有的文件在硬盘或者在传输时都是以字节的方式进行的，包括图片等，而字符是只有在内存中才使用。
范例：文件复制
1.实现要求，在dos命令中存在一个文件的复制命令（copy）,copy命令的语法格式如下：
copy 源文件 目标文件
下面使用Java完成以上功能，程序运行时可以按照如下格式进行：
java Copy 源文件 目标文件
2.思路，从运行格式中发现，要输入源文件和目标文件的路径，可以使用命令行参数完成，必须对输入的参数进行验证，如果输入的参数不是两个，或者源文件不存在，则程序给出错误信息并退出。
是选择字节流还是字符流，因为要复制的文件不一定都是文本文件，也可能包含图片或者声音，所以使用字节流。
两种操作方式：
将源文件中的内容全部读取到内存，并一次性写入到目标文件中。
不要将源文件中的内容全部都取进来，而是使用边读边写的方式。
很显然，使用边读边写更好，文件内容过多，则内存是无法装的。
public class Copy {
public static void main(String[] args) {
if (args.length != 2) {
System.out.println("输入的参数不正确！");
System.out.println("例：java Copy 源文件路径 目标文件路径");
System.exit(1); // 系统退出
}
File source = new File(args[0]); // 源文件的File对象
File target = new File(args[1]); // 目标文件的File对象
if (!source.exists()) {
System.out.println("源文件不存在！");
System.exit(1);
}
InputStream inputStream = null;
OutputStream outputStream = null;
try {
inputStream = new FileInputStream(source);
outputStream = new FileOutputStream(target);
if (inputStream != null && outputStream != null) {
int len = 0;
byte[] bs = new byte[1024];
while ((len = inputStream.read(bs)) != -1) {
outputStream.write(bs, 0, len);
}
System.out.println("复制完成！");
}
} catch (IOException e) {
System.out.println("复制失败！");
throw new RuntimeException(e.getMessage());
}
finally {
if (outputStream != null) {
try {
outputStream.close();
} catch (IOException e) {
throw new RuntimeException("输出关闭流失败！");
}
}
if (inputStream != null) {
try {
inputStream.close();
} catch (IOException e) {
throw new RuntimeException("输入关闭流失败！");
}
}
}
}
}