Java中的IO流①——IO流的体系、字节流、try...catch异常处理

概述

---

IO流的分类

IO流的体系

---

这四个类都是抽象类，所以需要实现类对象才能使用--->

字节流

---

FileInputStream-->

书写细节

代码示范

此时文件a.txt内容为abcde

使用char强转和read方法调用五次read方法-->

    public static void main(String[] args) throws IOException {
        /*
        演示：字节输入流FileInputStream
        实现需求：读取文件中的数据(暂时不写中文)
        实现步骤：
            创建对象
            读取数据
            释放资源
         */

        //1.创建对象
        FileInputStream fis = new FileInputStream("myio\\a.txt");
        //2.读取数据
        int b1 = fis.read();
        System.out.println((char)b1);//a
        int b2 = fis.read();
        System.out.println((char)b2);//b
        int b3 = fis.read();
        System.out.println((char)b3);//c
        int b4 = fis.read();
        System.out.println((char)b4);//d
        int b5 = fis.read();
        System.out.println((char)b5);//e
        //3.释放资源
        fis.close();
    }

使用char强转和read方法调用六次read方法-->最后一个值为-1

    public static void main(String[] args) throws IOException {
        /*
        演示：字节输入流FileInputStream
        实现需求：读取文件中的数据(暂时不写中文)
        实现步骤：
            创建对象
            读取数据
            释放资源
         */

        //1.创建对象
        FileInputStream fis = new FileInputStream("myio\\a.txt");
        //2.读取数据
        int b1 = fis.read();
        System.out.println((char)b1);//a
        int b2 = fis.read();
        System.out.println((char)b2);//b
        int b3 = fis.read();
        System.out.println((char)b3);//c
        int b4 = fis.read();
        System.out.println((char)b4);//d
        int b5 = fis.read();
        System.out.println((char)b5);//e
        int b6 = fis.read();
        System.out.println((char)b6);//
        //3.释放资源
        fis.close();
    }

循环读取-->
?

    public static void main(String[] args) throws IOException {
        /*
        字节输入流的循环读取
         */

        //1.创建对象
        FileInputStream fis = new FileInputStream("myio\\a.txt");
        //2.循环读取
        int b;
        while ((b = fis.read()) != -1){
            System.out.println((char)b);
        }
        /*
        结果：
        a
        b
        c
        d
        e
         */
        //3.释放资源
        fis.close();
    }

---

FileOutputStream-->

?书写细节

代码示范

先创建一个空的txt文件：a.txt

一次写一个字节数据-->

    public static void main(String[] args) throws IOException {
        /*
    演示：字节输出流FileOutputStream
    实现需求：写出一段文字到本地文件中(暂时不写中文)
    实现步骤：
        创建对象
        写出数据
        释放资源
     */

        //1.创建对象
        //写出 输出流 OutputStream
        FileOutputStream fos = new FileOutputStream("myio\\a.txt");
        //2.写出数据
        fos.write(97);
        //3.释放资源
        fos.close();
    }

结果-->>文件中添加了a

一次写一个字节数组数据-->

        public static void main(String[] args) throws IOException {
        //1.创建对象
        FileOutputStream fos = new FileOutputStream("myio\\a.txt");
        //2.写出数据
        byte[] bytes = {97, 98, 99, 100, 101};
        fos.write(bytes);
        //3.释放数据
        fos.close();
        }

结果-->>文件中添加了abcde

一次写一个字节数组的部分数据-->

    public static void main(String[] args) throws IOException {
        //1.创建对象
        FileOutputStream fos = new FileOutputStream("myio\\a.txt");
        //2.写出数据
        byte[] bytes = {97, 98, 99, 100, 101};
        fos.write(bytes,1,2);
        //3.释放数据
        fos.close();
    }

结果-->>文件中添加了bc

换行-->

    public static void main(String[] args) throws IOException {
        /*
            换行写：
                再次写出一个换行符
                Windows：\r\n
                Linux：\n
                Mac：\r
                细节：
                在Windows操作系统中，java对回车换行进行了优化
                虽然完整是\r\n，但是我们写其中一个\r或者\n
                java也可以实现换行，因为java在底层会自动补全
                建议：
                不要省略
         */

        //1.创建对象
        FileOutputStream fos = new FileOutputStream("myio\\a.txt");
        //2.写出数据
        String str1 = "kankelaoyezhenshuai";
        byte[] bytes1 = str1.getBytes();
        fos.write(bytes1);

        //再次写出一个换行符
        String warp = "\r\n";
        byte[] bytes2 = warp.getBytes();
        fos.write(bytes2);

        String str2 = "666";
        byte[] bytes3 = str2.getBytes();
        fos.write(bytes3);
        //释放资源
        fos.close();
    }

结果-->>

续写-->

    public static void main(String[] args) throws IOException {
        /*
            续写：
                如果需要续写，打开续写开关即可
                开关位置：创建对象的第二个参数
                默认false：表示关闭续写，此时创建对象会清空文件
                手动传递true：表示打开续写，此时创建对象不会清空文件
         */

        //1.创建对象
        FileOutputStream fos = new FileOutputStream("myio\\a.txt",true);
        //2.写出数据
        String str1 = "kankelaoyezhenshuai";
        byte[] bytes1 = str1.getBytes();
        fos.write(bytes1);

        //再次写出一个换行符
        String warp = "\r\n";
        byte[] bytes2 = warp.getBytes();
        fos.write(bytes2);

        String str2 = "666";
        byte[] bytes3 = str2.getBytes();
        fos.write(bytes3);
        //释放资源
        fos.close();
    }

结果-->>

小结

练习-->文件拷贝

    public static void main(String[] args) throws IOException {
        //文件拷贝
        //核心思想：边读边写

        //创建对象
        FileInputStream fis = new FileInputStream("myio\\a.txt");
        FileOutputStream fos = new FileOutputStream("myio\\b.txt");

        //拷贝
        int b;
        while ((b = fis.read()) != -1){
            fos.write(b);
        }

        //规则：先开的最后关闭
        fos.close();
        fis.close();
    }

FileInputStream读取的问题

一次只读取一个字节导致效率慢

解决方案

字节数组返回值：获取了几个字符

读取abcde时，第三次会出现只读取e的情况，只获取了一个元素，而数组中存放了两个，只会覆盖一半，所以使用时应该加上起始索引和结束索引

代码示范

try...catch异常处理

未来在springboot框架中一般使用抛出异常，try...catch掌握即可

由于代码太过繁琐，Java做出了简化方案，提出了接口

接口：AutoCloseable

特点：特定情况下，可以自动释放资源

代码演示

基本做法-->

    public static void main(String[] args) {
        //创建对象
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream("myio\\a.txt");
            fos = new FileOutputStream("myio\\a.txt");
            //拷贝
            int len;
            byte[] bytes = new byte[2];
            while ((len = fis.read(bytes)) != -1){
                fos.write(bytes,0,len);
            }
        } catch (IOException e){
            //e.printStackTrace();
        } finally {
            //释放资源
            if(fos != null){
                try {
                    fos.close();
                } catch (IOException e){
                    e.printStackTrace();
                }
            }
            if(fis != null){
                try {
                    fis.close();
                } catch (IOException e){
                    e.printStackTrace();
                }
            }
        }
    }

JDK7方案-->

    public static void main(String[] args) {
        /*
            JDK7：IO流中捕获异常的写法

            try后面的小括号写创建对象的代码
                注意：只有实现AutoCloseable接口的类，才能在小括号中创建对象

         */

        try(FileInputStream fis = new FileInputStream("myio\\a.txt");
            FileOutputStream fos = new FileOutputStream("myio\\a.txt")){
            //拷贝
            int len;
            byte[] bytes = new byte[2];
            while ((len = fis.read(bytes)) != -1){
                fos.write(bytes,0,len);
            }
        }catch (IOException e){
            e.printStackTrace();
        }
    }

JDK9方案-->

    public static void main(String[] args) throws FileNotFoundException {
        /*
            JDK9：IO流中捕获异常的写法
         */
        FileInputStream fis = new FileInputStream("myio\\a.txt");
        FileOutputStream fos = new FileOutputStream("myio\\a.txt");
        try(fis;fos){
            //拷贝
            int len;
            byte[] bytes = new byte[2];
            while ((len = fis.read(bytes)) != -1){
                fos.write(bytes,0,len);
            }
        }catch (IOException e){
            e.printStackTrace();
        }
    }