首先给图了解大概内容，当你忘记一些类的继承关系的时候，可以回过头来看一眼

所有的IO操作都在java.io包之中进行定义，而且整个java.io包实际上就是五个类和一个接口：
• 五个类：File、InputStream、OutputStream、Reader、Wirter
• 一个接口：Serializable

1. 简介字符流和字节流，输入流和输出流
   JDK所提供的所有流类位于java.io包中，都分别继承自以下四种抽象流类。

   • InputStream：继承自InputStream的流都是用于向程序中输入数据的，且数据单位都是字节（8位）。
   • OutputStream：继承自OutputStream的流都是程序用于向外输出数据的，且数据单位都是字节（8位）。
   • Reader：继承自Reader的流都是用于向程序中输入数据的，且数据单位都是字符（16位）。
   • . Writer：继承自Writer的流都是程序用于向外输出数据的，且数据单位都是字符（16位）。
     【输入和输出】是相对于【程序】而言的。以main()为例，main()就相当于程序，当使用输入(InputStream/Reader输入对应程序就是读取数据，当然是Reader)时，是从外界读取数据到main()中，【举例代码】。而输出则是，程序产生的结果输出(OutputStream/Writer输出就是写出，对应Writer)，可以输出到显示屏，控制台，文件系统等。
     【字节流和字符流】大部分文件（图片，视频，音乐等）都是使用字节存放的数据，因此，字节也是用的十分广泛的，但是字节在处理中文的时候，就没有字符流具有优势，因为中文字对应两个字节，而字符也对应两个字节，刚好能对应上，因此，如果有中文处理的时候，优先考虑使用字符流。
     主要的区别：
     • 字节流没有使用到缓冲区，而字符流使用了；
     • 处理各种数据都可以通过字节流完成，而在处理中文的时候使用字符流会更好。

   字节流和字符流的转换：（上代码）

   • 将字节输出流变为字符输出流 OutputStream→ Writer ：用OutputStreamWriter；
   • 将字节输入流变为字符输入流InputStream → Reader：用 InputStreamReader。
2. 文件操作/文件系统（File）（读文件，写文件 上代码）
   在整个java.io包之中，File类是唯一的一个与文件本身操作有关的类，所谓的文件本身指的是：文件的创建、删除、重命名、取得文件大小、修改日期。但是不包括文件内容，切记。

package IO;
import java.io.File;
public class FileDemo {
    public static void main(String[] args) {
        String dirname = "E:"+File.separator+"Demo";
          File f1 = new File(dirname);
          if (f1.isDirectory()) {
             System.out.println( "Directory of " + dirname);
             String s[] = f1.list();
             for (int i=0; i < s.length; i++) {
                File f = new File(dirname + "/" + s[i]);
                if (f.isDirectory()) {
                   System.out.println(s[i] + " is a directory");
                } else {
                   System.out.println(s[i] + " is a file");
                }
             }
          } else {
             System.out.println(dirname + " is not a directory");
        }
    }
}

Directory of E:\Demo
AndroidDemo is a directory
eclipseDemo is a directory
GitHubDemo is a directory

我的电脑【E：/Demo】下面有三个文件目录，所以显示为directory。下面给出File类的方法

1. 文件读取和文件输出
   文件输出
   • FileOutputStream

     
     package IO;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class FileOutputStreamDemo {
public static void main(String[] args) throws IOException {
File file = new File("E:" + File.separator + "hellodemo"

• File.separator + "test.txt"); // 定义文件路径
  if (!file.getParentFile().exists()) { // 父路径不存在
  file.getParentFile().mkdirs(); // 创建父路径
  }
  OutputStream output = new FileOutputStream(file); // 通过子类实例化父类
  String outputdata = "Hello World";// 要输出的数据
  output.write(outputdata.getBytes()); // 输出数据，要将数据变为字节数组输出
  output.close(); // 关闭资源
  }
  }

  -  FileWriter

  package IO;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

public class FileWriterDemo {
public static void main(String[] args) throws IOException {
File file = new File("E:" + File.separator + "hellodemo"

• File.separator + "test.txt"); // 定义文件路径
  if (!file.getParentFile().exists()) {
  file.getParentFile().mkdirs();// 创建父目录
  }
  Writer out = new FileWriter(file);
  String data = "Hello World";
  out.write(data) ; // 直接输出字符串
  out.close() ;

  }
  }

文件输入

 - FileInputStream

package IO;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

public class FileInputStreamDemo {
public static void main(String[] args) throws IOException {
File file = new File("E:" + File.separator + "hellodemo"

• File.separator + "test.txt"); // 定义文件路径
  if (file.exists()) { // 文件存在则可以读取
  InputStream input = new FileInputStream(file) ;
  byte data[] = new byte[1024]; // 假设要读的长度是1024
  int foot = 0; // 操作data数组的脚标
  int temp = 0;
  // 第一步：temp = input.read()，读取一个单个字节，并且将内容给temp变量
  // 第二步：temp != -1，将接收到的temp的数值判断是否为-1，
  //如果为-1则表示退出循环，如果不是，则保存数据
  while ((temp = input.read()) != -1) {
  data[foot++] = (byte) temp; // 保存读取进来的单个字节
  }
  input.close();
  System.out.println("数据:【" + new String(data, 0, foot) + "】");
  }else{
  System.out.println("文件不存在");
  }

  }
  }

 - FileReader

package IO;
import java.io.File;
import java.io.FileReader;
import java.io.Reader;
public class FileReaderDemo {
public static void main(String[] args) throws Exception {
File file = new File("E:" + File.separator + "hellodemo"

• File.separator + "test.txt"); // 定义文件路径
  if (file.exists()) {
  Reader in = new FileReader(file); // 字符输入流
  char data[] = new char[1024]; // 开辟数组
  int len = in.read(data); // 读取数据
  System.out.println("数据:【" + new String(data, 0, len) + "】");
  in.close() ;
  }else{
  System.out.println("文件不存在");
  }
  }
  }

  
  
          在工作中,IO的读取和输出是在所难免的。
  
  4 .打印流（输出）（PrintWriter字符）（PrintStream字节）
  System（输出err/out可以使用PrintStream的 print（）等方法  ，输入in可以使用InputStream的read()等方法）
  ---------System.out →PrintStream 
  ---------System.err →PrintStream  
  ---------System.in →InputStream （结合Scanner使用）
  >out/err/in由系统进行初始化【static】可以直接使用。

5.序列化（Serializable）
作用 ：对象序列化指的是可以将内存中的对象数据（对象属性），进行二进制数据保存，或者传输的一种操作，而如果要想完成这样的二进制操作，那么对象所在的类就必须实java.io.Serializable接口。
需要的两个IO类ObjectInputStream（反序列化）、ObjectOutputStream（序列化）

package IO;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import sun.print.resources.serviceui;

@SuppressWarnings("serial")
class Book implements Serializable{
    private String title;
    private Double price;
    private  transient String content;//瞬时 不会被序列化
    public void setTitle(String title) {
        this.title = title;
    }
    public String getTitle() {
        return title;
    }
    public void setPrice(Double price) {
        this.price = price;
    }
    public Double getPrice() {
        return price;
    }
    public void setContent(String content) {
        this.content = content;
    }
    public String getContent() {
        return content;
    }
    @Override
    public String toString() {
        return "Book [title=" + title + ", price=" + price + ", content=" + content + "]";
    }

}
public class SerializableDemo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        ser();
        //dser();

    }
    /*
     *  序列化
     */
    public static void ser() throws FileNotFoundException, IOException{
         Book book = new Book();
         book.setPrice(12.8);
         book.setTitle("admin");
        ObjectOutputStream oos = new ObjectOutputStream(
                new FileOutputStream(new File("E:" + File.separator + "person.ser")));
        oos.writeObject(book); 
        oos.close();
    }
    /*
     * 反序列化
     */
    public  static void dser() throws FileNotFoundException, IOException, ClassNotFoundException{
          ObjectInputStream ois = new ObjectInputStream(new FileInputStream(
                    new File("E:" + File.separator + "person.ser")));
            Book per = (Book) ois.readObject();  
            ois.close();
            System.out.println(per);
    }
}

     transient  关键字修饰的属性不会被序列化

6.IO的设计模式（装饰者模式 Decorator Pattern）

    用一句话表述：动态地将责任附加到对象上。

是用Decorator去装饰Component、因为实现了同一接口或者抽象类、Decorator同样可以装饰Decorator！通过这种模式我们也可以看出一个设计模式的设计原则：

Classes should be open for extension, but closed for modification!

Decorator Pattern： Attaches additional responsibility to anobject dynamically. Decorators provide a flexible alternative to subclassingfor extending functionality.

可以参考 装饰者设计模式
7.参考文献
网易云课堂李兴华java8 马士兵java《Thinking in Java》《Head First Design Patterns》