java初级12(持续更新)

IO流

IO流
    定义
        数据的读入写出,文件的上传下载
    流
        一连串流动的数据,以先入先出的方式进行传输-->流就是管道
    数据源---->io---->目的地
    数据源
        数据的来源
    目的地
        数据流向的位置
    分类
        操作单元分
            字节流
                万能流
            字符流
                纯文本内容
        流向分
            以程序为中心
                输入流
                输出流
        功能分
            节点流
                真实能做读入写出的
            功能流
                增强节点流的功能,提高节点流的性能
        流之间的分类是相辅相成的
    java.io包

File
    InputStream
        字节输入流中最上层父类
        文件流
            FileInputStream 文件字节输入流->节点流  字节流  输入流
            操作文件,数据源为文件,使用文件字节输入流
        字节数组流
            ByteArrayInputStream 字节数组输入流 ->节点流  字节流  输入流
            操作字节数组,数据源是字节输入,使用字节数组输入流
        操作
            1.构建流
                InputStream is = new FileInputStream(src);
                FileInputStream(File file) 通过打开与实际文件的连接来创建 FileInputStream ，该文件由文件系统中的 File对象 file命名。
            2.int read()
                每次读入一个字节数,返回读入到的字节,读不到返回-1
                循环读入
                    int num = -1;
                        记录每次读到的字节
                    while((num=is.read())!=-1){System.out.println((char)num);}
                提高效率,每次读入一组(字节数组)的数据
                    byte[] car = new byte[1024];
                    int read(byte[]) 每次读入一个字节数组的数据,返回读入到字节数组中数据的个数,没有读到返回-1
                    int len = is.read(car);
                    System.out.println(new String(car,0,len));
                当内容比较多,需要重复读入,每次读入一个字节数组中的数据
                    byte[] car = new byte[2];
                    int len = -1; //记录每次读入到数组中数据的个数
                    while((len = is.read(car))!=-1){System.out.println(new String(car,0,len));}
                byte[] readAllBytes()
                    从输入流中读取所有剩余字节。
            3.关闭
                .close
    OutputStream
        字节流输出流最上层父类
        FileOutputStream 文件字节输出流 -> 节点流
            目的地为文件
        ByteArrayOutputStream 字节数组输出流 -> 节点流
            目的地为字节数组
        注意
            在输出流写出的时候,如果目的地文件不存在,系统会自动创建目的地文件,如果目的地文件所在路径不存在,抛出异常
            java.io.FileNotFoundException:(系统找不到指定的路径。)
        操作
            1.构建流,指定目的地
                OutputStream os = new FileOutputStream("D://test.txt");
                    构建流,指定目的地
                OutputStream os = new FileOutputStream("D://BBB/test2.txt",true);
                    boolean参数->true为追加  false为覆盖
            2.写出
                .write(参数);
                    参数可以是数组
            3.刷出
                .flush();
            4.关闭
                .close();

字节流实现文件拷贝
    数据源-->输入流-->程序-->输出流-->目的地
    步骤
        1.构建流(输入流  输出流)
        2.读入写出
        3.刷出
        4.关闭 (后打开的先关闭)

功能流缓冲流 Buffered
    使用
        包裹节点流使用
            1.构建流
                InputStream is = new BufferedInputStream(new FileInputStream("D://test.txt"));
                OutputStream os = new BufferedOutputStream(new FileOutputStream("D://test1.txt"));
            2.读入写出
                byte[] car = new byte[1024];
                int len = -1;
                while((len = is.read(car))!=-1){os.write(car,0,len);}
            3.刷出
                os.flush();
            4.关闭
                os.close();
                is.close();
    加快节点流的读写效率
    字节缓冲流
        字节输入缓冲流 BufferedInputStream
        字节输出缓冲流 BufferedOutputStream
        无新增方法,可以发生多态
    字符缓冲流

字符流缓冲流
    字符输入缓冲流 BufferedReader
        新增功能: String readLine() 读一行文字。
    字符输出缓冲流 BufferedWriter
        新增功能: void newLine() 写一个行分隔符。
    存在新增功能,不能发生多态
    使用
        1.构建流(输入,输出)
            BufferedReader rd = new BufferedReader(new FileReader("D://test.txt"));
            BufferedWriter rt = new BufferedWriter(new FileWriter("D://dest.txt"));
        2.读写
            String msg = null;
            while((msg=rd.readLine())!=null){rt.write(msg);}
        3.刷出
            rt.flush();
        4.关闭
            rt.close();
            rd.close();

字符流 (纯文本数据)
    Reader  字符输入流
        FileReader 文件字符输入流  ->节点流
    Writer  字符输出流
        FileWriter 文件字符输出流  ->节点流
    通过字符流实现文件拷贝
        1.构建流(输入,输出)
            Reader rd = new FileReader("D://test.txt");
            Writer rt = new FileWriter("D://dest.txt");
        2.读写
            读入 int read() 每次读入一个字符数据
            读入 int read(char[] cbuf)
            将字符读入数组。返回读取的字符数，如果已到达流的末尾，则返回-1
            char[] car = new char[1024];
            int len = -1; //记录每次读入到数组中数据的个数
            while((len=rd.read(car))!=-1){
            //void write(char[] cbuf) 写一个字符数组。
            //void write(char[] cbuf, int off, int len) 写一个字符数组的一部分。
            //void write(int c) 写一个字符。
            //void write(String str) 写一个字符串。
            //void write(String str, int off, int len) 写一个字符串的一部分。
                rt.write(car,0,len);
        3.刷出
            rt.flush();
        4.关闭
            rt.close();
            rd.close();

Data流 功能流
    Data流 | 基本数据类型流 : 读写数据+保留数据类型->基本数据类型|字符串
    是字节流的功能流
    DataInputStream     Data输入流
        新增功能 : readXxx()
    DataOuutputStream   Data输出流
        新增功能 : writeXxx()
    注意
        读入与写出的顺序保持一致
        读入数据的时候必须从源文件中读入,否则抛出异常 java.io.EOFException
    写出
        1.构建输出流
            DataOutputStream os = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(path)));
        2.准备数据
        3.写出
        4.刷出
        5.关闭
    读入
        1.构建输入流
            DataInputStream is = new DataInputStream(new BufferedInputStream(new FileInputStream(path)));
        2.读入
        3.处理数据
        4.关闭

Object流|对象流|引用数据类型流
    字节流的功能流
        ObjectInputStream   反序列化输入流
            新增方法  Object readObject() 从ObjectInputStream中读取一个对象。  等等
        ObjectOutputStream   序列化输出流
            新增方法 void writeObject(Object obj) 将指定的对象写入ObjectOutputStream。
    序列化
        定义
            当实现了序列化的类型默认存在一个序列号
        特点
            序列化与反序列化顺序保持一致
            不是所有的属性都需要序列化 transient
            static的成员不会被序列化
            如果父类实现类序列化接口,子类所有内容都可以进行序列化
            子类实现了序列化接口,只能序列化子类独有的内容
        注意
            将对象数据转为可存储或者可传输的状态的过程
            不是所有类型的数据都能序列化 java.io.Serializable
            如果写出的对象类型没有实现序列化接口,会遇到运行时异常java.io.NotSerializableException
            当类中的成员发生改变,序列号默认会重新生成
        作用
            使用序列号可以实现检查前后版本不一致问题
        解决不同版本的兼容问题
            手动设置序列号
                private static final long serialVersionUID = -1108656603703788489L;
        通过快捷键生成序列号
            1.类型必须实现了序列化接口
            2.Setting中进行配置
            3.双击类名alt+enter,自动生成序列号

CommonsIO
    是一个第三方的开源组件
        是apache的一个开源的工具包,封装了IO操作的相关类,使用Commons IO可以很方便的读写文件,url源代码等。
    使用第三方组件的步骤
        1.对应官网中下载源码 jar
        2.在项目下新建一个文件夹目录lib,lib下存放以后项目所依赖的所有jar包
        3.选中jar包,右键add as lib...
        4.在项目下对应类中进行使用