63. （FileInputStream）输入字节流

IO分类：
    按照数据流向分类：
        输入流
        
        输出流
    
    按照处理的单位划分：
        字节流：字节流读取的都是文件中的二进制数据，读取到的二进制数据不会经过任何处理
        
        字符流：字符流读取的数据都是以字符为单位的，字符流也是读取的文件的二进制数据，只不过会把这些二进制数据转换成我们能识别的字符
                字符流 =  字节流 + 解码

输入字节流：
------------------|InputStream  所有输入字节流的基类  抽象类
-----------|FileInputStream  读取文件数据的输入字节流  throws FileNotFoundException
       
FileInputStream中的一些方法：

    构造方法：
    FileInputStream(File file)   通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定。
    
    其中的一些方法：
    read() 从此输入流中读取一个数据字节，如果已到达文件末尾，则返回 -1。throws IOException

    read(byte[] b)  throws IOException
        把读取的数据存储到字节数组中，并返回本次读取到字节数组中去的字节大小，如果一个也没有返回-1
        注意：
            1.这里的每次读取到字符数组中是采用覆盖的方式，也就是第一次如果读取到字符数组中的数据是aaa第二次只读取了bb，那么现在数组中的数据是bba。
            2.read(byte b[])方法实际上是调用了 read(byte b[], int off, int len)方法

    read(byte[] b, int off, int len)   从此输入流中将最多 len 个字节的数据读入一个 byte 数组中。
    
    close() 关闭此文件输入流并释放与此流有关的所有系统资源  throws IOException

    注意：
        当我们在创建通道的时候，也就是实例化FileInputStream的时候，里面的指针会指向0，当我们每读取一个数据字节指针都会加一
        
读取文件的步骤：
    
    1.找到目标文件
    2.建立数据通道
    3.读取文件
    4.关闭通道(释放资源)

建议把实例看了后再看这个(百度的)：

    java中字符a和数字97的关系：
    
        将一个字符常量放到一个字符变量中，实际是将该字符的相应的ASCII代码放到存储单元中。
        如‘a’的ASCII代码为十进制数97，c1='a'，在内存中是以97的二进制01100001存储的。
        字符数据以ASCII码存储，它的存储形式就与整数的存储形式类似。这样使字符型数据和整型数据之间可以通用。
        字符数据只占一个字节，它只能存放0~255范围内的整数。 注意：java中的char范围是0-65535 这个可能随着电脑不同和操作系统不同而不同
    
    为什么无参的read()方法的返回值是int类型而不是byte？
    
        Java中的数字都是有符号数，假如我们用一个byte类型去接收流中的字节码的话，
        那么假如刚好字节流里的字节码是-1的反码，那这个时候，read()返回了一个-1，
        那我们怎么知道read()是到达了流的末端还是字节码就是-1呢。
        而假如我们使用int类型的c来接收这些字节码，就不会出现这样的问题，高位补零，
        接收到的字节码放在最低的八位上，这样就能保证这些字节码都是“正数”

下面是分别用read()方法和read(byte[] b)读取数据

注意：在效率上面来说使用缓冲数组也就是用read(byte[] b)读取数据效率要高很多

public class Demo1 {
    public static void main(String[] args){
        
        readFile1();
        System.out.println("
---------");
        readFile2();
    }
    
    //read(byte[] b)  把读取的数据存储到字节数组中，并返回本次读取到字节数组中去的字节大小，如果一个也没有返回-1
    public static void readFile1(){
        FileInputStream fileInputStream = null;
        try {
            //找到目标文件
            File file = new File("D:\新建文件夹 (2)\a.txt");
            //建立数据通道
            fileInputStream = new FileInputStream(file);
            //读取文件（因为一次只能都取一个数据字节所以我们要用循环读出所有内容）
            int content = 0;
            //条件：如果已到达文件末尾，read()会返回 -1
            while((content = fileInputStream.read())!=-1) {
                //我们读取的是一个ASCII码，所以我们要把它强转成我们能看得懂的字符
                System.out.print((char)content);
            }
        }catch(IOException e){
            //这里用了一个运行时异常包装我们IO异常(编译时异常)发送出去，这样就不会强制让调用者处理异常，使调用者更加灵活
            throw new RuntimeException(e);
        }finally {
            //关闭通道（释放资源）
            //为了确保上面出现异常后，资源不能被释放的情况，我们一般会把关闭资源写在finally块里面
            try{
                fileInputStream.close();
            }catch(IOException e){
                //这里也用了一个运行时异常包装我们IO异常(编译时异常)发送出去
                throw new RuntimeException(e);
            }
        }
    }
    
    //使用read(byte[] b)读取数据  ：从此输入流中将最多 b.length 个字节的数据读入一个 byte数组中。如果没有那么返回-1
    //注意：这里的每次读取到字符数组中是采用覆盖的方式，也就是第一次如果读取到字符数组中的数据是aaa
    //第二次只读取了bb，那么现在数组中的数据是bba。
    public static void readFile2(){
        FileInputStream fileInputStream = null;
        try {
            //找到目标文件
            File file = new File("D:\新建文件夹 (2)\a.txt");
            //建立数据通道
            fileInputStream = new FileInputStream(file);
            //定义变量，存储本次读取的字节大小
            int length = 0;
            //读取文件(创建缓存数组，把读取到的数据存储到数组中）
            //一般字符数组的大小是1024的倍数，这个跟计算机的处理单位有关，“理论”上来说字节数组越大效率越高
            byte[] buf = new byte[1024];
            //条件：如果已到达文件末尾，read()会返回 -1
            while((length = fileInputStream.read(buf))!=-1) {
                //把字符数组转换成字符串并输出
                System.out.println(new String(buf,0,length));
                //本次读取到字符数组的字节大小为
                System.out.println("本次读取的数据的字节大小："+length);
            }
        }catch(IOException e){
            //这里用了一个运行时异常包装我们IO异常(编译时异常)发送出去，这样就不会强制让调用者处理异常，使调用者更加灵活
            throw new RuntimeException(e);
        }finally {
            //关闭通道（释放资源）
            //为了确保上面出现异常后，资源不能被释放的情况，我们一般会把关闭资源写在finally块里面
            try{
                fileInputStream.close();
            }catch(IOException e){
                //这里也用了一个运行时异常包装我们IO异常(编译时异常)发送出去
                throw new RuntimeException(e);
            }
        }
        
    }
}