流

---------------------------------------------------I/O-------------------------------------------------
源数据源----->程序------>目标数据源
（输入流）读入    （输出流）读出
输入输出流是相对计算机内存而言


1.按流向划分
输出流 
    OutputStream,Writer
输入流
    InputStream,Reader
    
2.按处理数据单元划分
----------------------------字节流--------------------------
1.    输入流
        （基类）InputStream
        方法：int read()  返回值是字节对应的整型数字
              int read(byte[] b)  返回值是字节的个数（b的长度）
              int read(byte[] b,int off,int len)  将读取的第一个字节存储在元素b[off]中
              void close()
              int available() 可以从输入流中读取的字节数目
        (子类)FileInputStream
        方法：FileInputStream(File file)
              FileInputStream(String name)
        实现步骤
            引入相关类-->构造文件输入流，FileInputStream对象-->读取文本文件的数据-->关闭文件流对象
            
2.    输出流 ★★string变成getByte变成字节★★
        （基类）OutputStream
        方法：int write()  
              int write(byte[] b)  
              int write(byte[] b,int off,int len)  
              void close()
              void flush()  强制把缓冲区的数据写到输出流中
        (子类)FileOutputStream ★如果相应的文件不存在，自动创建一个空的文件★
        方法：FileOutputStream(File file)    
              FileOutputStream(String name)
              FileOutputStream(String name,boolean append) 覆盖原来的内容
        实现步骤
            引入相关类-->构造文件输出流，FileOutputStream对象-->把数据写入文本文件-->关闭文件流对象
            
--------------------------字符流-------------------------------
1.    输入流
        （基类）Reader
        (子类)InputStreamReader
        方法：InputStreamReader（InputStream in）
              InputStreamReader（InputStream in,String charsetName） 编码格式
       （孙子类）FileReader ★★只能按照本地平台默认的字符编码来读★★
        方法：FileReader（File file）
              FileReader（String pathName,boolean append）
◆◆◆ (孙子类2)BufferedReader
        实现步骤
            引入相关类-->构造BufferedReader和FileReader对象-->调用read()方法读取数据-->流对象关闭close()
              
2.    输出流
        （基类）Writer
        (子类)OutputStreamWriter
        方法：OutputStreamWriter（OutputStream in）
              OutputStreamWriter（OutputStream in,String charsetName） 编码格式
        （孙子类）FileWriter ★★只能按照本地平台默认的字符编码来读★★
                    本地平台的字符编码获得：system.getProperty("file.encoding");
        方法：FileWriter（File file）
              FileWriter（String pathName,boolean append）
◆◆◆ (孙子类2)BufferedWriter
        实现步骤
            引入相关类-->构造BufferedWriter和FileWriter对象-->调用write()方法写数据-->流对象的清空和关闭flush()和close()
            


-------------------------序列化和反序列化--------------------
序列化：将对象的状态写到特定的流中的过程
反序列化：从特定的流中获取数据重新构建对象的过程

如果对象可以实现实现Serializable接口，那么该对象可以序列化或反序列化
序列化
步骤:
    实现Serializable接口--->创建对象输出流--->调用writeObject()方法将对象写入文件--->关闭对象输出流
                        ObjectOutputStream

反序列化
步骤:
    实现Serializable接口--->创建对象输入流--->调用readObject()方法读取对象--->关闭对象输入流
                        ObjectInputStream

范例：
public class Student implements Serializable{
    private int id;
    private int age;
    private String name;
    //当不想序列化属性时，可以加上transient
    private transient String password;

    public Student() {}
    
    public Student(int id, int age, String name, String password) {
        super();
        this.id = id;
        this.age = age;
        this.name = name;
        this.password = password;
    }

    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

public class ObjectSerDemo {
    public static void main(String[] args) {
        FileOutputStream fos = null;
        ObjectOutputStream oos = null;
        ObjectInputStream ois = null;
        try {
            //创建对象序列化需要的输出流
            fos = new FileOutputStream("E:\Java实训课总结\2016.3.26\stu.txt");
            oos = new ObjectOutputStream(fos);
            //创建对象
            Student stu = new Student(1,18,"张三","12345");
            //序列化对象
            oos.writeObject(stu);
            //反序列化
            ois = new ObjectInputStream(new FileInputStream("E:\Java实训课总结\2016.3.26\stu.txt"));
            Student stu1 = (Student)ois.readObject();
            System.out.println("反序列化后：" );
            System.out.println("学号：" + stu1.getId());
            System.out.println("年龄：" + stu1.getAge());
            System.out.println("姓名：" + stu1.getName());
            System.out.println("密码：" + stu1.getPassword());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            //关闭流
            try {
                oos.close();
                fos.close();
                ois.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}