Java基础回顾---IO（字节流）

    IO流是Java基础中很重要的一个知识点，由于IO流的种类繁多，所以在此对其知识点进行整理，方便自己的回顾，总结。

1.IO流概述

    IO是Input和Output的缩写，即输入、输出。其实所谓的输入、输出都是针对运行的程序（CPU、内存）来说的，输入就是向程序所在的内存输入、 输出就是从内存中向外输出，即输入和输出的参照为为程序（内存），这样就比较容易理解IO，IO关注的是原始数据的读取和到目标媒介的输出。流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称和抽象。流的本质是数据传输（计算机中实际上数据的流动是通过电路，而上面流动的则是电流，电流的电位有低位与高位，即数字的0与1位。从程序的观点来说，通常会将数据目的地(例如内存)与来源(例如文件)之间的数据流动抽象化为一个流(Stream)，而其中流动的则是位数据）。

Java IO中根据数据传输特性将其抽象为各种类，方便直观的进行数据操作,这些都在java.io包下。IO流根据处理数据的不同分为字符流和字节流。根据数据流向的不同，又可分为输入流和输出。按照功能的不同，又可以分为节点流和处理流，节点流是直接从一个源读写数据的流（流没有经过包装和修饰），处理流是在对节点流封装的基础上的一种流，例如FileInputStream是一个节点流，可以直接从文件读取，BufferedInputStream包装在FileInputStream外侧，使其具有缓冲功能，就是处理流。

本章节我们先来详细的讲解一下字节流。

2.字节流

    字节流的关系结构图，如下所示：

2.1 InpuStream | OutputStream

      InputStream是所有输入字节流的父类，它是一个抽象类，它有最常三个方法：即read()、read(byte[] b)、read(byte[] b , int off , int len )。read()对流进行逐个字节的读取，返回的int是字节的int表达方式,返回 0 到 255 范围内的 int 字节值,如果因为已经到达流末尾而没有可用的字节，则返回值 -1 ，由于一次只会读取一个字节，所以效率很低。read(byte[])从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。以整数形式返回实际读取的字节数。OutputStream是所有输出字节流的父类，也是一个抽象类。

2.2 FileInputStream | FileOutputStream

    

/**
	 * 文件流
	 * 
	 */
	public static void testFileIO() throws IOException{
		FileInputStream fin = new FileInputStream(new File("F:\\dandan.txt"));
		FileOutputStream fout = new FileOutputStream(new File("F:\\benben.txt"));
		int len = 0;
		byte[] b = new byte[1024];
		while((len = fin.read(b)) != -1){  //读,使用read(byte[] b)方法
			fout.write(b, 0, len);         //写
		}
		fout.flush();
		
		fin.close();
		fout.close();
	}

2.3 ByteArrayInputStream  |  ByteArrayOutputStream

/**
	 * ByteArrayInputStream ：使用的场景比较少见，在此不再举例
	 * ByteArrayOutputStream:可以将文件中的数据输出到字节数组中
	 */
	public static void testByteArrayIO() throws IOException{
		FileInputStream fis = new FileInputStream(new File("F:\\dandan.txt"));
		ByteArrayOutputStream bos = new ByteArrayOutputStream();
		byte[] b = new byte[1024];
		int len = 0;
		while((len=fis.read(b)) != -1){
			bos.write(b, 0, len);
		}
		System.out.println(new String(bos.toByteArray()));
		
		fis.close();
		bos.close();
	}

2.4 ObjectInputStream | ObjectOutputStream

/**
	 * 对象流
	 * ObjectOutputStream和ObjectInputStream所要读写的对象的类必须实现了Serializable接口
	 * 注意：对象中的transient和static类型成员变量不会被读取和写入
	 */
	public static void testObjectIO() throws IOException, ClassNotFoundException{
		Person p = new Person();
		p.setId("1001");
		p.setName("lixiang");
		p.setAge(23);
		p.setSex("man");
		
		ObjectOutputStream objout = new ObjectOutputStream(new FileOutputStream("F:\\Person.obj"));
		objout.writeObject(p); //将对象写入输出流
		objout.flush();
		objout.close();
		
		ObjectInputStream objin = new ObjectInputStream(new FileInputStream("F:\\Person.obj"));
		Person p1 = (Person) objin.readObject();   //从输入流中读取数据
		System.out.println(p1.toString());
		objin.close(); 
	}
class Person implements Serializable{
    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    
    
    private String id ;
    private String name;
    private int age;
    private transient String sex ;
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    @Override
    public String toString() {
        return "Person [id=" + id + ", name=" + name + ", age=" + age + ", sex=" + sex + "]";
    }
    
}

2.5 DataInputStream  |  DataOutputStream

/**
	 * 数据流：
	 * DataInputStream 和 DataOutputStream是IO流中的装饰流,继承了FilterInputStream和FilterOutStream
	 * 允许按照java的基础数据类型读写流中的数据，使用起来比较方便
	 * @throws IOException 
	 */
	public static void testDataIO() throws IOException{
		
		DataOutputStream dout = new DataOutputStream(new FileOutputStream(new File("F:\\data.txt")));
		dout.writeInt(100);  //写入整数
		dout.writeUTF("good good study");  //写入UTF字符串
		dout.writeDouble(20.16);
		dout.flush();
		dout.close();
		
		DataInputStream dis = new DataInputStream(new FileInputStream(new File("F:\\data.txt")));
		System.out.println(dis.readInt());   //按照写入顺序读出
		System.out.println(dis.readUTF());
		System.out.println(dis.readDouble());
		dis.close();
	}

2.6 BufferedInputStream  |  BufferedOutputStream

/**
	 * 缓冲流
	 * 
	 */
	public static void testBufferedIO() throws IOException{
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream(new File("F:\\dandan.txt")));
		BufferedOutputStream fout = new BufferedOutputStream(new FileOutputStream(new File("F:\\benben.txt")));
		int len = 0;
		byte[] b = new byte[1024];
		while((len = bis.read(b)) != -1){  //读,使用read(byte[] b)方法
			fout.write(b, 0, len);         //写
		}
		fout.flush();
		
		bis.close();
		fout.close();
	}

    在上面，总结了几种常见的字节流的使用方法，其实在大部分场景下，我们很少单独使用某个类来实现IO操作，平时都是几个类合起来使用。Java io本身也是采用了装饰者模式，以后有时间会回顾有关装饰者模式的知识总结。