Java学习记录5——IO流技术

基本概念和IO入门
  数据源data source，提供数据的原始媒介。常见的数据源有：数据库、文件、其他程序、内存、网络连接、IO设备。
数据源分为：源设备、目标设备。
1.源设备：为程序提供数据，一般对应输入流。
2.目标设备：程序数据的目的地，一般对应输出流。

第一个简单的IO流程序及深入理解

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();
            }
        }

Java中流的概念细分
按流的方向分类：

  1. 输入流：数据流向是数据源到程序(以InputStream、Reader结尾的流)。
  2. 输出流：数据流向是程序到目的地(以OutPutStream、Writer结尾的流)。

按处理的数据单元分类：

  1. 字节流：以字节为单位获取数据，命名上以Stream结尾的流一般是字节流，如FileInputStream、FileOutputStream。
  2. 字符流：以字符为单位获取数据，命名上以Reader/Writer结尾的流一般是字符流，如FileReader、FileWriter。

按处理对象不同分类：

  1. 节点流：可以直接从数据源或目的地读写数据，如FileInputStream、FileReader、DataInputStream等。
  2. 处理流：不直接连接到数据源或目的地，是”处理流的流”。通过对其他流的处理提高程序的性能，如BufferedInputStream、BufferedReader等。处理流也叫包装流。
  （节点流处于IO操作的第一线，所有操作必须通过它们进行;处理流可以对节点流进行包装，提高性能或提高程序的灵活性。）

文件字节流
在使用文件字节流时，我们需要注意以下两点：

1. 为了减少对硬盘的读写次数，提高效率，通常设置缓存数组。相应地，读取时使用的方法为：read(byte[] b);写入时的方法为：write(byte[ ] b, int off, int length)。

byte[] buffer = new byte[1024];
file.read(buffer)
/*public int read(byte[] b)
         throws IOException
从该输入流读取最多b.length字节的数据到字节数组。*/

2. 程序中如果遇到多个流，每个流都要单独关闭，防止其中一个流出现异常后导致其他流无法关闭的情况。

finally {
	//两个流需要分别关闭
	try {
	    if (fos != null) {
	        fos.close();
	    }
	} catch (IOException e) {
	    e.printStackTrace();
	}
	try {
	    if (fis != null) {
	        fis.close();
	    }
	} catch (IOException e) {
	    e.printStackTrace();
	}
}

文件字符流
  前面介绍的文件字节流可以处理所有的文件，但是字节流不能很好的处理Unicode字符，经常会出现“乱码”现象。所以，我们处理文本文件，一般可以使用文件字符流，它以字符为单位进行操作。

缓冲字节流
  当对文件或者其他数据源进行频繁的读写操作时，效率比较低，这时如果使用缓冲流就能够更高效的读写信息。因为缓冲流是先将数据缓存起来，然后当缓存区存满后或者手动刷新时再一次性的读取到程序或写入目的地。

 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);
	    }
	}

缓冲字符流
  BufferedReader/BufferedWriter增加了缓存机制，大大提高了读写文本文件的效率，同时，提供了更方便的按行读取的方法：readLine(); 处理文本时，我们一般可以使用缓冲字符流。

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();
}

注意

  1. readLine()方法是BufferedReader特有的方法，可以对文本文件进行更加方便的读取操作。
  2. 写入一行后要记得使用newLine()方法换行。

字节数组流
  ByteArrayInputStream和ByteArrayOutputStream经常用在需要流和数组之间转化的情况!
  说白了，FileInputStream是把文件当做数据源。ByteArrayInputStream则是把内存中的”某个字节数组对象”当做数据源。

byte[] b = "abcdefg".getBytes();
ByteArrayInputStream bais = null;
StringBuilder sb = new StringBuilder();
bais = new ByteArrayInputStream(b);
while ((temp = bais.read()) != -1) {
    sb.append((char) temp);
    num++;
}
System.out.println(sb);
System.out.println("读取的字节数：" + num);

数据流
  数据流将“基本数据类型与字符串类型”作为数据源，从而允许程序以与机器无关的方式从底层输入输出流中操作Java基本数据类型与字符串类型。
  DataInputStream和DataOutputStream提供了可以存取与机器无关的所有Java基础类型数据(如：int、double、String等)的方法。
  DataInputStream和DataOutputStream是处理流，可以对其他节点流或处理流进行包装，增加一些更灵活、更高效的功能。

DataOutputStream dos = null;
DataInputStream dis = null;
FileOutputStream fos = null;
FileInputStream  fis = null;
fos = new FileOutputStream("D:/data.txt");
fis = new FileInputStream("D:/data.txt");
//使用数据流对缓冲流进行包装，新增缓冲功能
dos = new DataOutputStream(new BufferedOutputStream(fos));
dis = new DataInputStream(new BufferedInputStream(fis));
//将如下数据写入到文件中
dos.writeBoolean(true);
dos.writeInt(10);
dos.writeUTF("心悦则呈");
dos.flush();//刷新此数据输出流。目的是将流中数据写入到文件中
System.out.println("char: " + dis.readBoolean());
System.out.println("int: " + dis.readInt());
System.out.println("String: " + dis.readUTF());

  使用数据流时，读取的顺序一定要与写入的顺序一致，否则不能正确读取数据。

对象流
  数据流只能实现对基本数据类型和字符串类型的读写，并不能读取对象（字符串除外）如果要对某个对象进行读写操作，我们需要对象流
  ObjectInputStream/ObjectOutputStream是以“对象”为数据源，但是必须将传输的对象进行序列化与反序列化操作。
注意

  1. 对象流不仅可以读写对象，还可以读写基本数据类型。
  2. 使用对象流读写对象时，该对象必须序列化与反序列化。
  3. 系统提供的类(如Date等)已经实现了序列化接口，自定义类必须手动实现序列化接口。

转换流
   InputStreamReader/OutputStreamWriter用来实现将字节流转化成字符流。

对象序列化的作用有如下两种：

  1. 持久化： 把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中，比如：休眠的实现。以后服务器session管理，hibernate将对象持久化实现。
  2. 网络通信：在网络上传送对象的字节序列。比如：服务器之间的数据通信、对象传递。

注意

  1. static属性不参与序列化。
  2. 对象中的某些属性如果不想被序列化，不能使用static，而是使用transient修饰。
  3. 为了防止读和写的序列化ID不一致，一般指定一个固定的序列化ID。

装饰器模式简介
  装饰器模式是GOF23种设计模式中较为常用的一种模式。它可以实现对原有类的包装和装饰，使新的类具有更强的功能。
  一个完整的Javabean，要用set和get方法，以及一个空构造器(无参构造器)，这时我们还可在在里面自定义很多方法，其实就是对类的装饰。
  IO流体系中大量使用了装饰器模式，让流具有更强的功能、更强的灵活性。

FileInputStream fis = new FileInputStream(src);
BufferedInputStream bis = new BufferedInputStream(fis);

  显然BufferedInputStream装饰了原有的FileInputStream，让普通的FileInputStream也具备了缓存功能，提高了效率。 大家举一反三，可以翻看本章代码，看看还有哪些地方使用了装饰器模式。