Java IO流的分类

输入流和输出流是相对于程序来说的，数据通过输入流从源设备到程序，通过输出流从程序到目标设备，从而实现数据的传输。

字节流

字节输入流：InputStream(抽象类)

几个主要方法：

int read() 抽象方法。从输入流读取一个8位的字节，把它转换成0~255之间的整数，并返回这一整数

int read(byte[] b) 从输入流读取若干字节，把它们保存到字节数组b中，返回的整数表示读取字节数

int read(byte[] b,int off,int len) 从输入流读取若干字节，把它们保存到字节数组b中，off指定字节数组开始保存数据的起始下标，len表示读取的字节数目

void close() 关闭此输入流并释放与该流关联的所有系统资源

	InputStream in = new FileInputStream("/Users/choumeng/Desktop/IDEA 				 											 Projects/comprehensive/src/main/java/IO/a.txt");
    int b;
    while ((b = in.read()) != -1) {
      System.out.println(b);
    }
    in.close();

字节输出流：OutputStream(抽象类)

void write(int b) 抽象方法。向输出流写入一个字节

void write(byte[] b) 把参数b指定的字节数组的所有字节写到输出流

void write(byte[] b,int off,int len) 将指定byte数组中从偏移量off开始的len个字节写入输出流

void flush() 刷新此输出流并强制写出所有缓冲的输出字节

void close() 关闭此输出流并释放与此流相关的所有系统资源

	// 如果目标文件中有内容，将会被覆盖
	String str = "hello world";
    byte[] b = str.getBytes();
    OutputStream out = new FileOutputStream("/Users/choumeng/Desktop/IDEA 				  											Projects/comprehensive/src/main/java/IO/a.txt");
    out.write(b);
    out.flush();
    out.close();

字节缓冲流：BufferedInputStream、BufferedOutputStream

增强流的性能，装饰者模式

	String sourceFileName = "/Users/choumeng/Desktop/IDEA 															Projects/comprehensive/src/main/java/IO/a.txt";
    String targetFileName = "/Users/choumeng/Desktop/IDEA 															Projects/comprehensive/src/main/java/IO/b.txt";
    InputStream in = new BufferedInputStream(new FileInputStream(sourceFileName));
    OutputStream out = new BufferedOutputStream(new FileOutputStream(targetFileName));
    int b;
    while ((b = in.read()) != -1) {
      out.write(b);
    }
    in.close();
    out.close();

字符流

API与字节流的类似

字符输入流：Reader(抽象类)

int read() char占两个字节，返回值为0 ~ 65535

int read(char cbuf[])

int read(char cbuf[], int off, int len) 抽象方法

void close() 抽象方法

	Reader reader = new FileReader("/Users/choumeng/Desktop/IDEA 														   Projects/comprehensive/src/main/java/IO/a.txt");
    int b;
    while ((b = reader.read()) != -1) {
      // 注意要强转成char类型，否则输出的是字符所代表的ASCII码表中对应的十进制数值
      System.out.println((char) b);
    }
    reader.close();

字符输出流：Writer(抽象类)

void write(int c)

void write(char cbuf[])

void write(char cbuf[], int off, int len) 抽象方法

void flush() 抽象方法

void close() 抽象方法

void write(String str) 调用void write(String str, int off, int len)方法

void write(String str, int off, int len) 底层会将str转换成字符数组，调用write(char cbuf[], int off, int len)方法

	Writer writer = new FileWriter("/Users/choumeng/Desktop/IDEA 					  									   Projects/comprehensive/src/main/java/IO/c.txt");
    String str = "hello";
    writer.write(str);
    writer.close();

字符缓冲流：BufferedReader、BufferedWriter

BufferedReader中有一个重要的方法readLine()，读取一行的数据

	String sourceFileName = "/Users/choumeng/Desktop/IDEA 															Projects/comprehensive/src/main/java/IO/a.txt";
    String targetFileName = "/Users/choumeng/Desktop/IDEA 															Projects/comprehensive/src/main/java/IO/e.txt";
    BufferedReader br = new BufferedReader(new FileReader(sourceFileName));
    BufferedWriter bw = new BufferedWriter(new FileWriter(targetFileName));
    String str;
    while ((str = br.readLine()) != null) {
      bw.write(str);
      // 由于readLine()方法是一次读取一行，所以这里写出一行后，一定要换行
      // 否则每一行数据紧贴着每一行数据
      bw.newLine();
    }
    br.close();
    bw.close();

转换流

InputStreamReader：Reader的子类，将字节输入流包装成字符输入流，方便读取字符

OutputStreamWriter：Writer的子类，将字节输出流包装成字符输出流，方便写入字符

	String sourceFileName = "/Users/choumeng/Desktop/IDEA 															Projects/comprehensive/src/main/java/IO/a.txt";
    String targetFileName = "/Users/choumeng/Desktop/IDEA 															Projects/comprehensive/src/main/java/IO/b.txt";
   	InputStreamReader isr = new InputStreamReader(new FileInputStream(sourceFileName));
    OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(targetFileName));
    int b;
    while ((b = isr.read())!= -1) {
      osw.write((char) b);
    }
    isr.close();
    osw.close();

其他IO流

ByteArrayOutputStream：前面的流都是将文件直接存储到硬盘，有时候我们希望将文件临时存储到缓冲区，方便以后读取。该类会在创建对象时就创建一个byte型数组的缓冲区，当写出数据时，该对象会把所有的数据先写入缓冲区，最后一次性写入文件。

	// 复制文件
	String sourceFileName = "/Users/choumeng/Desktop/IDEA 															Projects/comprehensive/src/main/java/IO/a.txt";
    String targetFileName = "/Users/choumeng/Desktop/IDEA 															Projects/comprehensive/src/main/java/IO/b.txt";
    FileInputStream fis = new FileInputStream(sourceFileName);
    FileOutputStream fos = new FileOutputStream(targetFileName);
    ByteArrayOutputStream baos = new ByteArrayOutputStream();

    int b;
    while ((b = fis.read()) != -1) {
      // 先写入到ByteArrayInputStream对象的byte型数组的缓冲区中
      baos.write(b);
    }
	// 再将ByteArrayInputStream对象的缓冲区中的内容一次性写出到目标文件中
    fos.write(baos.toByteArray());
    fis.close();
    fos.close();
    bais.close();

ByteArrayInputStream：从缓冲区中读取数据

	byte[] bytes = new byte[]{97, 98, 99};
    ByteArrayInputStream bais= new ByteArrayInputStream(bytes);
    int b;
    while ((b = bais.read()) != -1) {
      System.out.println((char) b);
    }
    bais.close();