Java自学课程笔记11

2021年3月25日11点00分
JAVA自学课程笔记11：
    
    流：

        流的定义：
            程序和设备之间嫁接起来的一根用于数据传输的*管道，这个管道上有很多可以实现不同功能的按钮。

            （文件）----00101…--->（程序）
            （文件）<---00101…----（程序）
            （网络）----00101…--->（程序）
            （内存）----00101…--->（程序）

            （文件）---------------------->（程序）    //原始流
                   -------00101…------>        //包裹流（套在原始流上）    //三层的管道
                      ---------------->        //包裹流（套在包裹流上）

            节点流（原始流）为可以从一个特定的数据源（节点）读写数据（如文件、内存）
            处理流（包裹流）是“连接”在已存在的流（节点流或处理流）之上，通过对数据的处理为程序提供更为强大的读写功能。处理流就是包裹在原始节点上的流，相当于包括在管道上的管道。
            
            流和类的关系：
                如果一个类用作设备和程序之间的数据传输，则这个类有一个新名字叫流。
                流一定是类，但类不一定是流。


        java.io包中定义了多个流类型(类或抽象类)来实现输入、输出功能。可以从不同的角度对其进行分类:
            按数据流的方向不同可以分为* 输入流和* 输出流。
            按处理数据单位不同可以分为* 字节流和* 字符流（两个字节一起发送）。
            按照功能不同可以分为* 节点流（原始流）和* 处理流（包裹流(加工处理原始流，套在原始流上)）。

            四大基本抽象流：
                输入流：InputStream（字节流） Reader（字符流）
                输出流：OutputStream（字节流） Writer（字符流）
                （都是抽象类，通常我们使用的都是他们的子类）
            
        流的分类和使用：
            四大基本抽象流
            文件流
            缓冲流
            转换流
            数据流
            Print流
            Object流


        输入流示例：
            import java.io.*;
            public class TestFileReader{
                public static void main(String[] args) throws Exception{
                    FileReader fr = new FileReader("/*带双斜杠的路径*/");
                    int ch;        //read()函数返回结果是整型

                    ch = fr.read();        
                    while(-1 != ch){    //每读完一个，就会fr就会指向下一个字符
                        System.out.printf("%c", (char)ch);    //用char类型输出整型ch
                        ch = fr.read();
                    }
                    fr.close();
                }
            }

        InputStream流中常用方法：（抛出异常：throws IOException）

            public int read()：
                读取一个字节并以整数形式返回，如果读到输入流的末尾则返回-1。//同等的，Reader流中的read()函数应当是读取一个字符。

                FileInputStream fis = new FileInputStream("/*路径*/");
                while(-1!=len)
                    len = fis.read(buf);    //从fis流所关联的路径文件中读取数据，并将读取出来的数据写入buf数组中，返回值是实际写入buf数组的字节个数，如果读到结尾返回-1。

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

            long skip(long n):
                跳过和丢弃此输入流中数据的n个字节（较少使用）

        OutputStream流中常用方法：（抛出异常：throws IOException）

            void write(int b):
                向输出流中写入一个字节数据，该字节数据为参数b的低8位

            void write(byte[] b):
                将一个字节类型数组中的数据写入输出流

            void write(byte[] b, int off, int len):
                将一个字节类型的数组中的指定位置（off）开始的len个字节写入到输出流

            void close():
                关闭流释放内存资源

            void flush():
                将输出流中缓冲的数据全部写出到目的地（仅仅输入流才有flush()方法，输出流没有）

        Reader流的常用方法：（抛出异常：throws IOException）

            int read()：
                读取一个字符并以整数的形式返回(0~255)如果返回-1已到输入流的末尾。

            int read (char[] cbuf)：
                读取一系列字符并存储到一个数组buffer，返回实际读取的字符数，如果读取前已到输入流的末尾返回-1

            int read (char[] cbuf, int offset, int length):
                最多读取length个字符，并存储到一个数组buffer，从length位置开始。返回实际读取的字符数，如果读取前已到输入流的末尾返回-1

            void close ()：
                关闭流释放内存资源

            long skip (1ong n)：
                跳过n个字符不读，返回实际跳过的字节数

        Writer流中常用方法：（抛出异常：throws IOException）

            void write(int c)：
                向输出流中写入一个字符数据,该字节数据为参数c的低16位

            void write(char[] cbuf)：
                将一个字符类型的数组中的数据写入输出流

            void write(char[] cbuf, int offset, int length)：
                将一个字符类型的数组中的从指定位置（offset）开始的length个字符写入到输出流

            void write(String string)：
                将一个字符串中的字符写入到输出流

            void write(String string, int offset, int length):
                将一个字符串从offset开始的length个字符写入到输出流

            void close()：
                关闭流释放内存资源

            void flush()：
                将输出流中缓冲的数据全部写出到目的地


        FileInputStream的使用：
            InputStream是用来读取字节的，是个* 抽象类，我们通常使用的是该类的* 子类（FileReader等流是继承四大基本流的（如reader））。
            FileInputStream是InputStream的子类，利用FileInputStream可以将一个文件的内容按字节为单位读取出来。

            构造函数（常用）：
                public FileInputStream(String fileName):
                    利用该构造函数实现将输入流连接到某个文件的功能。
                    必须对本构造函数抛出的异常进行捕捉。
                    抛出异常：throws FileNotFoundException
            
            FileOutputStream同理，不再赘述。

            FileInputStream和FIleOutputStream可以完成* 所有格式文件的赋值，FileReader和FileWriter只可以完成文本文件的复制，却无法完成视频、图片、音频格式的复制。（因为字节是不需要解码和编码的，将字节转化为字符才存在解码编码的问题。

        缓冲流：
            缓冲流就是带有缓冲区的输入输出流。
            缓冲流可以显著地减少我们对IO访问的次数，保护我们的硬盘。
            缓冲流本身就是* 处理流（包裹流），缓冲流必须得依附于* 节点流（原始流）。缓冲流要“套接”在相应的节点流之上，对读写的数据提供了缓冲的功能，提高了读写的效率，同时增加了一些新的方法。

            J2SDK提供的四种缓冲流常用构造方法：
                BufferedReader(Reader in)
                BufferedReader(Reader in, int sz)    //sz为自定义缓冲区大小
                
                BufferedWriter(Writer out)
                BufferedWriter(Writer out, int sz)

                BufferedInputStream(InputStream in)
                BufferedInputStream(InputStream in, int size)

                BufferedOutputStream(OutputStream out)
                BufferedOutputStream(OutputStream out, int size)

            缓冲输入流支持其父类的mark()和reset()方法（标记之后用reset回到当前位置）
            BufferedReader提供了readLine()方法用于读取一行字符串（以
或
分隔）
            BufferedWriter提供了newLine()用于写入一个行分隔符
            对于输出的缓冲流，写出的数据会先在内存中缓存，使用flush()方法会使内存中的数据立刻写出。