--------1024
IO流的概念
流是一个抽象、动态的概念，是一连串连续动态的数据集合。
对于输入流而言，数据源就像水箱，流(stream)就像水管中流动着的水流，程序就是我们最终的用户。我们通过流(A Stream)将数据源(Source)中的数据(information)输送到程序(Program)中。
对于输出流而言，目标数据源就是目的地(dest)，我们通过流(A Stream)将程序(Program)中的数据(information)输送到目的数据源(dest)中。
java流概念细分
- 按流的方向分类：
输出流：数据流向是程序到目的地(以OutPutStream、Writer结尾的流)。
- 按处理的数据单元分类：
字符流：以字符为单位获取数据，命名上以Reader/Writer结尾的流一般是字符流，如FileReader、FileWriter。
- 按处理对象不同分类：
处理流：不直接连接到数据源或目的地，是”处理流的流”。通过对其他流的处理提高程序的性能，如BufferedInputStream、BufferedReader等。处理流也叫包装流。节点流处于IO操作的第一线，所有操作必须通过它们进行;处理流可以对节点流进行包装，提高性能或提高程序的灵活性。
IO流类的体系
- InputStream/OutputStream
字节流的抽象类。
- Reader/Writer
字符流的抽象类。
- FileInputStream/FileOutputStream
节点流：以字节为单位直接操作“文件”。
- ByteArrayInputStream/ByteArrayOutputStream
节点流：以字节为单位直接操作“字节数组对象”。
- ObjectInputStream/ObjectOutputStream
处理流：以字节为单位直接操作“对象”。
- DataInputStream/DataOutputStream
处理流：以字节为单位直接操作“基本数据类型与字符串类型”。
- FileReader/FileWriter
节点流：以字符为单位直接操作“文本文件”(注意：只能读写文本文件)。
- BufferedReader/BufferedWriter
处理流：将Reader/Writer对象进行包装，增加缓存功能，提高读写效率。
- BufferedInputStream/BufferedOutputStream
处理流：将InputStream/OutputStream对象进行包装，增加缓存功能，提高 读写效率。
- InputStreamReader/OutputStreamWriter
处理流：将字节流对象转化成字符流对象。
- PrintStream
处理流：将OutputStream进行包装，可以方便地输出字符，更加灵活。
四大IO抽象类
- ·InputStream
此抽象类是表示字节输入流的所有类的父类。InputSteam是一个抽象类，它不可以实例化。 数据的读取需要由它的子类来实现。根据节点的不同，它派生了不同的节点流子类 。
继承自InputSteam的流都是用于向程序中输入数据，且数据的单位为字节(8 bit)。
常用方法：
int read()：读取一个字节的数据，并将字节的值作为int类型返回(0-255之间的一个值)。如果未读出字节则返回-1(返回值为-1表示读取结束)。
void close()：关闭输入流对象，释放相关系统资源。
- · OutputStream
此抽象类是表示字节输出流的所有类的父类。输出流接收输出字节并将这些字节发送到某个目的地。
常用方法：
void write(int n)：向目的地中写入一个字节。
void close()：关闭输出流对象，释放相关系统资源。
- · Reader
Reader用于读取的字符流抽象类，数据单位为字符。
int read(): 读取一个字符的数据，并将字符的值作为int类型返回(0-65535之间的一个值，即Unicode值)。如果未读出字符则返回-1(返回值为-1表示读取结束)。
void close() ： 关闭流对象，释放相关系统资源。
- · Writer
Writer用于写入的字符流抽象类，数据单位为字符。
void write(int n)： 向输出流中写入一个字符。
void close() ： 关闭输出流对象，释放相关系统资源
文件字节流
FileInputStream通过字节的方式读取文件，适合读取所有类型的文件(图像、视频、文本文件等)。Java也提供了FileReader专门读取文本文件。
FileOutputStream 通过字节的方式写数据到文件中，适合所有类型的文件。Java也提供了FileWriter专门写入文本文件。
读取
import java.io.*; public class TestIO2 { public static void main(String[] args) { FileInputStream fis = null; try { fis = new FileInputStream("d:/a.txt"); // 内容是：abc StringBuilder sb = new StringBuilder(); int temp = 0; //当temp等于-1时，表示已经到了文件结尾，停止读取 while ((temp = fis.read()) != -1) { sb.append((char) temp); } System.out.println(sb); } catch (Exception e) { e.printStackTrace(); } finally { try { //这种写法，保证了即使遇到异常情况，也会关闭流对象。 if (fis != null) { fis.close(); } } catch (IOException e) { e.printStackTrace(); } } } }
写入
import java.io.FileOutputStream; import java.io.IOException; public class TestFileOutputStream { public static void main(String[] args) { FileOutputStream fos = null; String string = "北京尚学堂欢迎您！"; try { // true表示内容会追加到文件末尾；false表示重写整个文件内容。 fos = new FileOutputStream("d:/a.txt", true); //该方法是直接将一个字节数组写入文件中; 而write(int n)是写入一个字节 fos.write(string.getBytes()); } catch (Exception e) { e.printStackTrace(); } finally { try { if (fos != null) { fos.close(); } } catch (IOException e) { e.printStackTrace(); } } } }
void write(byte[ ] b)，该方法不再一个字节一个字节地写入，而是直接写入一个字节数组;另外其还有一个重载的方法：void write(byte[ ] b, int off, int length)，这个方法也是写入一个字节数组，但是我们程序员可以指定从字节数组的哪个位置开始写入，写入的长度是多少。
利用文件流实现文件的复制
import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; public class TestFileCopy { public static void main(String[] args) { //将a.txt内容拷贝到b.txt copyFile("d:/a.txt", "d:/b.txt"); } /** * 将src文件的内容拷贝到dec文件 * @param src 源文件 * @param dec 目标文件 */ static void copyFile(String src, String dec) { FileInputStream fis = null; FileOutputStream fos = null; //为了提高效率，设置缓存数组！（读取的字节数据会暂存放到该字节数组中） byte[] buffer = new byte[1024]; int temp = 0; try { fis = new FileInputStream(src); fos = new FileOutputStream(dec); //边读边写 //temp指的是本次读取的真实长度，temp等于-1时表示读取结束 while ((temp = fis.read(buffer)) != -1) { /*将缓存数组中的数据写入文件中，注意：写入的是读取的真实长度； *如果使用fos.write(buffer)方法，那么写入的长度将会是1024，即缓存 *数组的长度*/ fos.write(buffer, 0, temp); } } catch (Exception e) { e.printStackTrace(); } finally { //两个流需要分别关闭 try { if (fos != null) { fos.close(); } } catch (IOException e) { e.printStackTrace(); } try { if (fis != null) { fis.close(); } } catch (IOException e) { e.printStackTrace(); } } } }
注意
在使用文件字节流时，我们需要注意以下两点：
1. 为了减少对硬盘的读写次数，提高效率，通常设置缓存数组。相应地，读取时使用的方法为：read(byte[] b);写入时的方法为：write(byte[ ] b, int off, int length)。
2. 程序中如果遇到多个流，每个流都要单独关闭，防止其中一个流出现异常后导致其他流无法关闭的情况。
文件字符流
前面介绍的文件字节流可以处理所有的文件，但是字节流不能很好的处理Unicode字符，经常会出现“乱码”现象。所以，我们处理文本文件，一般可以使用文件字符流，它以字符为单位进行操作。
使用FileReader与FileWriter实现文本文件的复制
import java.io.FileNotFoundException; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; public class TestFileCopy2 { public static void main(String[] args) { // 写法和使用Stream基本一样。只不过，读取时是读取的字符。 FileReader fr = null; FileWriter fw = null; int len = 0; try { fr = new FileReader("d:/a.txt"); fw = new FileWriter("d:/d.txt"); //为了提高效率，创建缓冲用的字符数组 char[] buffer = new char[1024]; //边读边写 while ((len = fr.read(buffer)) != -1) { fw.write(buffer, 0, len); } } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } finally { try { if (fw != null) { fw.close(); } } catch (IOException e) { e.printStackTrace(); } try { if (fr != null) { fr.close(); } } catch (IOException e) { e.printStackTrace(); } } } }
缓冲字节流
Java缓冲流本身并不具有IO流的读取与写入功能，只是在别的流(节点流或其他处理流)上加上缓冲功能提高效率，就像是把别的流包装起来一样，因此缓冲流是一种处理流(包装流)。
当对文件或者其他数据源进行频繁的读写操作时，效率比较低，这时如果使用缓冲流就能够更高效的读写信息。因为缓冲流是先将数据缓存起来，然后当缓存区存满后或者手动刷新时再一次性的读取到程序或写入目的地。
因此，缓冲流还是很重要的，我们在IO操作时记得加上缓冲流来提升性能。
BufferedInputStream和BufferedOutputStream这两个流是缓冲字节流，通过内部缓存数组来提高操作流的效率。
下面我们通过两种方式(普通文件字节流与缓冲文件字节流)实现一个视频文件的复制，来体会一下缓冲流的好处。
使用缓冲流实现文字的高效复制
import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; public class TestBufferedFileCopy1 { public static void main(String[] args) { // 使用缓冲字节流实现复制 long time1 = System.currentTimeMillis(); copyFile1("D:/电影/华语/大陆/尚学堂传奇.mp4", "D:/电影/华语/大陆/尚学堂越 "+"来越传奇.mp4"); long time2 = System.currentTimeMillis(); System.out.println("缓冲字节流花费的时间为：" + (time2 - time1)); // 使用普通字节流实现复制 long time3 = System.currentTimeMillis(); copyFile2("D:/电影/华语/大陆/尚学堂传奇.mp4", "D:/电影/华语/大陆/尚学堂越 "+"来越传奇2.mp4"); long time4 = System.currentTimeMillis(); System.out.println("普通字节流花费的时间为：" + (time4 - time3)); } /**缓冲字节流实现的文件复制的方法*/ static void copyFile1(String src, String dec) { FileInputStream fis = null; BufferedInputStream bis = null; FileOutputStream fos = null; BufferedOutputStream bos = null; int temp = 0; try { fis = new FileInputStream(src); fos = new FileOutputStream(dec); //使用缓冲字节流包装文件字节流，增加缓冲功能，提高效率 //缓存区的大小（缓存数组的长度）默认是8192，也可以自己指定大小 bis = new BufferedInputStream(fis); bos = new BufferedOutputStream(fos); while ((temp = bis.read()) != -1) { bos.write(temp); } } catch (Exception e) { e.printStackTrace(); } finally { //注意：增加处理流后，注意流的关闭顺序！“后开的先关闭！” try { if (bos != null) { bos.close(); } } catch (IOException e) { e.printStackTrace(); } try { if (bis != null) { bis.close(); } } catch (IOException e) { e.printStackTrace(); } try { if (fos != null) { fos.close(); } } catch (IOException e) { e.printStackTrace(); } try { if (fis != null) { fis.close(); } } catch (IOException e) { e.printStackTrace(); } } } /**普通节流实现的文件复制的方法*/ static void copyFile2(String src, String dec) { FileInputStream fis = null; FileOutputStream fos = null; int temp = 0; try { fis = new FileInputStream(src); fos = new FileOutputStream(dec); while ((temp = fis.read()) != -1) { fos.write(temp); } } catch (Exception e) { e.printStackTrace(); } finally { try { if (fos != null) { fos.close(); } } catch (IOException e) { e.printStackTrace(); } try { if (fis != null) { fis.close(); } } catch (IOException e) { e.printStackTrace(); } } } }
注意
1. 在关闭流时，应该先关闭最外层的包装流，即“后开的先关闭”。
2. 缓存区的大小默认是8192字节，也可以使用其它的构造方法自己指定大小。
缓冲字符流
BufferedReader/BufferedWriter增加了缓存机制，大大提高了读写文本文件的效率，同时，提供了更方便的按行读取的方法：readLine(); 处理文本时，我们一般可以使用缓冲字符流。
使用BufferedReader与BufferedWriter实现文本文件的复制
import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; public class TestBufferedFileCopy2 { public static void main(String[] args) { // 注：处理文本文件时，实际开发中可以用如下写法，简单高效！！ FileReader fr = null; FileWriter fw = null; BufferedReader br = null; BufferedWriter bw = null; String tempString = ""; try { fr = new FileReader("d:/a.txt"); fw = new FileWriter("d:/d.txt"); //使用缓冲字符流进行包装 br = new BufferedReader(fr); bw = new BufferedWriter(fw); //BufferedReader提供了更方便的readLine()方法，直接按行读取文本 //br.readLine()方法的返回值是一个字符串对象，即文本中的一行内容 while ((tempString = br.readLine()) != null) { //将读取的一行字符串写入文件中 bw.write(tempString); //下次写入之前先换行，否则会在上一行后边继续追加，而不是另起一行 bw.newLine(); } } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } finally { try { if (bw != null) { bw.close(); } } catch (IOException e1) { e1.printStackTrace(); } try { if (br != null) { br.close(); } } catch (IOException e1) { e1.printStackTrace(); } try { if (fw != null) { fw.close(); } } catch (IOException e) { e.printStackTrace(); } try { if (fr != null) { fr.close(); } } catch (IOException e) { e.printStackTrace(); } } } }
注意
1. readLine()方法是BufferedReader特有的方法，可以对文本文件进行更加方便的读取操作。
2. 写入一行后要记得使用newLine()方法换行。