Java零基础（13）IO流

I：Input
O：Output
一、概念：流是内存与存储设备之间传输数据的通道
二、分类：
        1. 方向--->方向相对于JVM来讲
            输入流：将存储设备中的数据读写到JVM中（硬盘--->JVM）
            输出流：将JVM中的数据写入到存储设备中（JVM--->硬盘）
        2. 单位
            字节流：以字节为单位，可以读写所有数据（字节是计算机中处理数据的最小单位，任何数据都可以按照字节传输）
            字符流：以字符为单位，可以读写文本数据（传输数据的单位是字符，可以处理字符编码问题）
        3. 功能
            节点流：实际传输数据的流（如：电线中铜芯）
            过滤流：增强节点流功能 （如:外层中的绝缘胶布）
三、字节流
        1.1 字节流父类
            OutputStream:表示字节输出流的所有类的超类
            InputStream:表示字节输入流的所有类的超类
        1.2 字节节点流
            1. FileInputStream:
                按方向：输入流  按单位：字节流  按功能：节点流
                a.构造方法 
                    FileInputStream(String name ;    //name--->字符串类型的路径，通过文件路径获取输入流
                b.方法
                    public void close();   //关闭流
                    public int read();     //每次从文件中读取一个字节，并把读到的内容返回（ASCII编码规范）
                                           //读到文件的末尾返回-1
                    如：
                        FileInputStream f = new FileInputStream("D:\\abc.txt");  //创建字节输入流 
                        int i=0;
                        while((i=f.read()) != -1){   // i=65   65 != -1
                            System.out.print((char)i); // (char)65;
                        }
                    
                    public int read(byte[] b);  //每次从文件中读取b.length个数据，存入byte数组里面
                                                //返回值表示读到的字节数
                    如：
                        byte[] b=new byte[5];
                        int le=0;
                        while((le=f.read(b)) != -1){   // 第一次   b={A B C D E }  第二次 b={F g }
                            for (int i = 0; i < le; i++) {
                                System.out.print((char)b[i]);
                            }
                        }
                                                
            2. FileOutputStream:
                按方向：输出流  按单位：字节流  按功能：节点流
                a.构造方法
                    FileOutputStream(String name);   //根据路径创建文件输出流
                    FileOutputStream(String name, boolean append); //追加方式去写内容，追加为true  不追加为false
                b.方法
                    public void close();   //关闭流
                    public void write(int b); //将单个字节输入到文件中
                    public void write(byte[] b); //将一组字节内容写入到文件中
                    如：
                        FileOutputStream f=new FileOutputStream("D:\\a.java",true); //字节输出流创建OK
                        String s="Hello World ";
                        byte[] b=s.getBytes();  //数组中存储单个字节的内容
                        f.write(b);  //将byte[]数组内容写入到指定位置
                        f.close();   //关闭流
    1.3 字节过滤流
            1. ObjectInputStream/ObjectOutputStream
                1.1 读写对象，使用流传输对象，所有能序列化的对象必须实现Serializable接口
                1.2 构造方法
                        ObjectOutputStream(OutputStream out);  //封装输出过滤流
                        ObjectInputStream(InputStream in);     //封装输入过滤流

                1.3 ObjectOutputStream方法
                        public void flush();  //清空缓冲区
                        public final void writeObject(Object obj);  //写一个对象
                    ObjectInputStream方法
                        public final Object readObject();           //读取一个对象
                如：//创建节点流
                    FileOutputStream fos=new FileOutputStream("d:\\gzy.txt");
                    //创建过滤流或者封装过滤流
                    ObjectOutputStream oos=new ObjectOutputStream(fos);
                    //写数据
                    Student s1=new Student("zs",18);
                    Student s2=new Student("ls",20);
                    oos.writeObject(s1);
                    oos.writeObject(s2);
                    //关闭流
                    oos.flush();  //清空缓冲区
                    oos.close();
                注：1. 序列化对象时，必须保证其所有属性均可序列化
                    2. 如不参加序列化的属性，需要通过 transient 修饰为临时属性
                    3. 序列化集合属性时，需要保证其所有元素均可序列化、
            2. DataOutputStream/DataInputStream
                    1. 增强了读写八种基本类型和字符串功能
            3. BufferedOutputStream/BufferedInputStream
                    1. 缓冲流，提高了IO效率，减少了访问存储设备的次数
                    2. 数据存储在缓冲区内，关闭前，需要调用 flush() 清空缓冲区 整个写入到文件中
    
            4. 字符编码（规定字符和数字之间的对应关系）
                    ASCII：最早的编码方式，规定了英文字母还有英文标点对应的编码
                    GB2312：简体中文（GBK子集）
                    GBK：简体中文（超大字符集）
                    UTF-8：一种国际通用的编码格式，包括简体和繁体中文
                    注：英文字母、标点不会产生乱码
四、字符流
        1. 字符流父类
            Reader----->字符输入流
            Writer----->字符输出流
        2.     字符节点流
            InputStreamReader / OutputStreamWriter
            2.1 InputStreamReader
                构造方法：
                    InputStreamReader(InputStream in); 
                    InputStreamReader(InputStream in, Charset cs);
                    注：桥转换流，用于将字节流转换成字符流，并设置字符的解码格式
                方法：
                    public int read(); //读取单个字符
            2.2 OutputStreamWriter
                    OutputStreamWriter(OutputStream out);
                    OutputStreamWriter(OutputStream out, Charset cs);
                    注：桥转换流，用于将字符流转换成字节流，并设置字符的编码格式
                方法：
                    public void write(int c); //写入单个字符
            3.3 利用桥转换进行编程
                1. 创建字节节点流
                2. 桥转换成字符流
                3. 在字符流的基础上封装过滤流
                4. 读/写数据
                5. 关闭流
        3. 字符缓冲流
            BufferedReader / PrintWriter
            3.1 BufferedReader  输入流 字符流 过滤流
                构造方法：
                    BufferedReader(Reader in);  //增强字符流功能，提供了缓冲区功能
                方法：
                    public String readLine();   //每次读取一行内容 读到文件末尾返回null
            3.2 PrintWriter     输出流 字符流 过滤流
                构造方法：
                    PrintWriter(Writer w);      //缓冲区功能  增强了字符流功能 可以写八种基本类型 字符串类型 对象类型
                方法：
                    print();  println();          //八种基本类型参数或者对象都OK 对象是写入的是toString方法的返回值
五、File
        1. 概念：
                代表硬盘上的一个文件或者文件夹
        2. 方法
                createNewFile(); //创建一个文件
                mkdir(); //创建一个文件夹
                delete(); //删除文件或者文件夹
                getPath(); //获取路径
                getName(); //获取文件或者文件夹名
                getAbsolutePath(); //获取绝对路径
                listFiles(); //获取所有文件