JavaSE（十六）IO流

File类

• File 文件 位于java.io包中

• File对象 能代表文件或者目录（文件夹）

File常用方法

public class FileExercise {
    public static void main(String[] args) {
        System.out.println(fibonacci(50));
    }
​
    /**
     * 斐波那契数列实现
     *
     * @param num
     * @return
     */
    public static int fibonacci(int num) {
        if (num == 0 || num == 1) {
            return num;
        }
        return fibonacci(num - 1) + fibonacci(num - 2);
    }
​
    private static void method4() {
        //菜单打印
        File file = new File("./res");
        printPath(file, "|  ");
    }
​
    /**
     * 方法的递归 自己调用自己
     *
     * @param file
     */
    public static void printPath(File file, String op) {
        File[] children = file.listFiles();
        for (int i = 0; i < children.length; i++) {
            File child = children[i];
            System.out.println(op + child.getName());
            if (child.isFile()) {
            } else {
                //如果是目录 递归调用
                printPath(child, op + "|  ");
            }
        }
​
    }
​
    /**
     * 常用方法
     */
    private static void method3() {
        File file = new File("./res");
        System.out.println("此对象所代表的文件或目录 是否存在：" + file.exists());
        System.out.println("文件 字节大小:  " + file.length());
        System.out.println("获取文件或目录的名称：" + file.getName());
        System.out.println("判断是否是文件：" + file.isFile());
        System.out.println("判断是否是目录：" + file.isDirectory());
        System.out.println(" 获取父路径： " + file.getParent());
        System.out.println(" 获取路径： " + file.getPath());
        System.out.println(" 获取绝对路径： " + file.getAbsolutePath());
        /*try {
            //当文件不存在的时候新建成功，前提条件是父路径必须存在
            System.out.println("创建新文件： " + file.createNewFile());
        } catch (IOException e) {
            e.printStackTrace();
        }*/
        System.out.println(" 新建目录： " + file.mkdir());
        System.out.println(" 创建级联目录：" + file.mkdirs());
        //返回当前目录的直接孩子
        File[] files = file.listFiles();
        for (File child : files) {
            System.out.println(child.getName());
        }
    }
​
    /**
     * 2-构造方法
     */
    private static void method2() {
        File file1 = new File("./res/a.txt");
        File file2 = new File("./res", "a.txt");
        File parent = new File("./res");
        File file3 = new File(parent, "a.txt");
        System.out.println(file2.exists());
    }
​
    /**
     * 1-路径写法
     */
    private static void method1() {
        //1 绝对路径 从盘符开始的路径 \是转义 \\才是\
        File file = new File("E:\\workspace\\pro54\\res");
        //2 相对路径 参考 相对与当前工程的路径  E:\workspace\pro54
        //  ./ 当前工程路径  ../ 返回上层路径
        File file2 = new File("./a.txt");
        System.out.println("此对象所代表的文件或目录 是否存在：" + file.exists());
        System.out.println("此对象所代表的文件或目录 是否存在：" + file2.exists());
    }
}

IO流

• I input输入 O output输出 ； 输入输出流

• 需要和外部程序交互数据 必须使用IO流

• IO分类 如果按照流的方向：输入流 输出流；站着Java程序的角度看

• IO 如果按照流的处理单位不同：字节流（对流中数据一个字节一个字节的处理） 字符流（对流中数据一个字符一个字符的处理）

• 字节输入流、字节输出流；字符输入流 字符输出流

1.1.字节流

• InputStream 是抽象类 是所有字节输入流的父类

• OutputStream是抽象类 是所有字节输出流的父类；

• 字节流（对流中数据一个字节一个字节的处理）

1.1.1.文件字节流

1，基本方法

/**
     * 文件字节输入流
     */
    private static void method2() {
        try {
            FileInputStream fileInputStream = new FileInputStream("./res/a.txt");
            //读进来 read  每调用一次读取一个字节数据 流不可回读
            //每次只读取一个字节 如果返回值为-1 读取完毕
            int num;
            /*while ((num = fileInputStream.read()) != -1) {
                System.out.println(num);
            }*/
            // 一次性读取指定长度的字节数据；
            byte[] nBytes = fileInputStream.readNBytes(15);
            System.out.println(new String(nBytes));
            System.out.println(Arrays.toString(nBytes));
​
            //一次性读取所有字节数据；有可能报OOM错误的
           /* byte[] bytes = fileInputStream.readAllBytes();
            //字符编码 字符解码
            String s = new String(bytes);
            System.out.println(s);
            System.out.println(Arrays.toString(bytes));*/
​
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

2，try新语法

 /**
     * try新语法 自动关闭流对象
     */
    private static void method4() {
        //用完之后 自动关闭流对象 AutoCloseable
        try (FileInputStream fileInputStream = new FileInputStream("./res/a.txt")) {
            int num;
            while ((num = fileInputStream.read()) != -1) {
                System.out.println(num);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

3，文件字节输出流

 /**
     * 文件字节输出流
     */
    private static void method5() {
        //输出流 从Java程序出去
        //文件如果不存在可以新建，但是父路径必须存在;如果布尔值为true表示追加 默认是覆盖
        try (FileOutputStream fileOutputStream = new FileOutputStream("./res/out.txt")) {
            //出去
            fileOutputStream.write(97);
            fileOutputStream.write(98);
            fileOutputStream.write(99);
            byte[] bytes = "中国Java".getBytes();
//            fileOutputStream.write(bytes);
            //起始索引  字节长度
            fileOutputStream.write(bytes, 0, 6);
            System.out.println("写入完毕");
​
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

4，文件拷贝

 /**
     * 实现文件拷贝方式
     */
    private static void method6() {
        try (FileInputStream fileInputStream = new FileInputStream("./res/a.txt");
             FileOutputStream fileOutputStream = new FileOutputStream("./res/b.txt")) {
            //1,
         /*   int num;
            while ((num = fileInputStream.read()) != -1) {
                fileOutputStream.write(num);
            }*/
            //2,
            /*byte[] bytes = fileInputStream.readAllBytes();
            fileOutputStream.write(bytes);*/
            //3,
            fileInputStream.transferTo(fileOutputStream);
            System.out.println("拷贝完成");
​
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

1.1.2.高效字节流

 /**
     * 高效字节流
     */
    private static void method8() {
        try (BufferedInputStream bufferedInputStream =
                     new BufferedInputStream(new FileInputStream("./res/ev1.mp4"));
             BufferedOutputStream bufferedOutputStream =
                     new BufferedOutputStream(new FileOutputStream("./res/ev3.mp4"));
             FileInputStream fileInputStream = new FileInputStream("./res/ev1.mp4");
             FileOutputStream fileOutputStream = new FileOutputStream("./res/ev2.mp4")) {
            //返回值为-1 表示读取完毕
            int read = bufferedInputStream.read();
            byte[] bytes = bufferedInputStream.readAllBytes();
            byte[] readNBytes = bufferedInputStream.readNBytes(10);
            //
            bufferedOutputStream.write(97);
​
           /* //文件拷贝的性能差别
            long start = System.currentTimeMillis();
            fileInputStream.transferTo(fileOutputStream);
            long end = System.currentTimeMillis();
            System.out.println("拷贝结束: " + (end - start));*/
​
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
​
    private static void method7() {
        // 处理流  基础流 内部缓存区稍微处理下
        try (BufferedInputStream bufferedInputStream =
                     new BufferedInputStream(new FileInputStream("./res/ev1.mp4"));
             BufferedOutputStream bufferedOutputStream =
                     new BufferedOutputStream(new FileOutputStream("./res/ev3.mp4"));
             FileInputStream fileInputStream = new FileInputStream("./res/ev1.mp4");
             FileOutputStream fileOutputStream = new FileOutputStream("./res/ev2.mp4")) {
​
            //文件拷贝的性能差别：
            /*long start = System.currentTimeMillis();
            int num;
            while ((num = bufferedInputStream.read()) != -1) {
                bufferedOutputStream.write(num);
            }
            long end = System.currentTimeMillis();
            System.out.println("last: " + (end - start));*/
            System.out.println("拷贝结束");
​
           /* //高效输出流何时进行真正的写： 1,当数组满了 2 流对象关闭 的时候会进行真正的写
            bufferedOutputStream.write(97);
            bufferedOutputStream.write(98);
            bufferedOutputStream.write(98);*/
​
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

1.2.字符流

• 字符流（对流中数据一个字符一个字符的处理）

• 字符流其实 是在字节流的基础上 加入了字符编码和字符解码 ，字符流不能处理二进制文件（音频 视频 图片）只能交给字节流处理

• 字符流常用来处理文本文件

• Reader抽象类 所有字符输入流 的父类 ；Writer 抽象类 所有字符输出流的父类

1.2.1.文件字符流

private static void method9() {
        //输出流 如果文件不存在则新建
        try (FileReader fileReader = new FileReader("./res/swk.jpg");
             FileWriter fileWriter = new FileWriter("./res/swk2.jpg")) {
            //read方法 一次读取一个字符出来
            int num;
            while ((num = fileReader.read()) != -1) {
                System.out.println((char) num);
            }
            //字符输出流对应的方法
            fileWriter.write(97);
            fileWriter.write("java".toCharArray());
            fileWriter.write("python");
            //性能稍高
            fileReader.transferTo(fileWriter);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

文件拷贝

/**
     * 文件字符流
     */
    private static void method10() {
        try (FileReader fileReader = new FileReader("./res/swk.jpg");
             FileWriter fileWriter = new FileWriter("./res/swk2.jpg")) {
            //一次读取一个字符出来
            int num;
            while ((num = fileReader.read()) != -1) {
                fileWriter.write(num);
            }
            //文件拷贝的 性能稍高
            fileReader.transferTo(fileWriter);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

1.2.2.高效字符流

/**
     * 高效字符流
     */
    private static void method11() {
        try (BufferedReader bufferedReader =
                     new BufferedReader(new FileReader("./res/a.txt"));
             BufferedWriter bufferedWriter =
                     new BufferedWriter(new FileWriter("./res/out.txt"))) {
            //read方法 返回值为-1 表示读取完毕
//            int read = bufferedReader.read();
            //readLine方法 一次读取一行 返回值为null表示读取完毕
            String str;
            while ((str = bufferedReader.readLine()) != null) {
                System.out.println(str);
            }
            //字符输出流对应的方法
            bufferedWriter.write(98);
            bufferedWriter.write("java".toCharArray());
            bufferedWriter.write("java");
            //文件拷贝方法
            bufferedReader.transferTo(bufferedWriter);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

1.3.其他流

1.3.1.转换流

• 字节流和字符流之间的转换，桥接作用

/**
     * 输出流的转换
     */
    private static void method13() {
        try (OutputStreamWriter outputStreamWriter = new OutputStreamWriter(System.out)) {
            outputStreamWriter.write("中国abc");
            outputStreamWriter.write("\n");
            outputStreamWriter.write("python");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 输入流的转换
     */
    private static void method12() {
        //字节输入流对象
        /*try (InputStream in = System.in) {
            int num;
            while ((num = in.read()) != 97) {
                System.out.println(num);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }*/
        try (BufferedReader bufferedReader =
                     new BufferedReader(new InputStreamReader(System.in));) {
            String str;
            while (!(str = bufferedReader.readLine()).equals("quit")) {
                System.out.println(str);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

1.3.2.数据处理流

/**
         * 数据处理流
         */
        private static void method14() {
            try (DataOutputStream dataOutputStream =
                         new DataOutputStream(new FileOutputStream("./res/data.txt"));
                 DataInputStream dataInputStream =
                         new DataInputStream(new FileInputStream("./res/data.txt"))) {
                dataOutputStream.writeInt(97);
                dataOutputStream.writeDouble(99.7);
                dataOutputStream.writeFloat(10.2F);
                dataOutputStream.writeUTF("java");
                System.out.println("写入完毕");
                //写入顺序和读取的顺序 必须保持一致
                int i = dataInputStream.readInt();
                System.out.println(i);
                double v = dataInputStream.readDouble();
                System.out.println(v);
                float f = dataInputStream.readFloat();
                System.out.println(f);
                String s = dataInputStream.readUTF();
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

工具类

 /**
     * 工具类Properties
     */
    private static void method16() {
        Properties properties = new Properties();
        try (FileInputStream fileInputStream = new FileInputStream("./res/db.properties")) {
            properties.load(fileInputStream);
           /* Object password = properties.get("password");
            System.out.println(password);
            System.out.println(properties.get("url"));*/
            if (properties.containsKey("password")) {
                String password = properties.getProperty("password");
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

1.3.3.序列化流

• 程序一旦关闭 给此程序分配的内存空间全部回收的；硬盘 持久化保存

• 序列化：把 Java堆内存中的对象 持久化到 存储介质（文件 硬盘）

• 反序列化：把存储介质中的数据 反序列化 为Java堆内存中的对象 （再次恢复为对象）

• 类型必须实现接口Serializable，此接口是标记接口，标记给JVM看的

• 要求此类型内部所有的成员变量也都是可悲序列化

• transient用于修饰成员变量，表示序列化的时候忽略此成员变量的存储

• 序列化版本号；serialVersionUID；序列化和反序列化的过程中，源码不能改动，一旦改动 反序列化失败

private static void method8() {
        try (ObjectOutputStream objectOutputStream =
                     new ObjectOutputStream(new FileOutputStream("./res/obj2.txt"));
             ObjectInputStream objectInputStream =
                     new ObjectInputStream(new FileInputStream("./res/obj2.txt"))) {

            Student stu1 = new Student(101, "张三", new Computer("Dell", 1.9));
            objectOutputStream.writeObject(stu1);
            System.out.println("写入完毕");
            //向上转型
            Object o1 = objectInputStream.readObject();
            System.out.println(o1);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
        }
    }

    private static void method7() {
        try (ObjectOutputStream objectOutputStream =
                     new ObjectOutputStream(new FileOutputStream("./res/obj2.txt"));
             ObjectInputStream objectInputStream =
                     new ObjectInputStream(new FileInputStream("./res/obj2.txt"))) {
            List<Student> list = new ArrayList<>();
            list.add(new Student(101, "张三"));
            list.add(new Student(102, "李四"));
            objectOutputStream.writeObject(list);
            System.out.println("写入完毕");
            //向上转型
            Object o1 = objectInputStream.readObject();
            System.out.println(o1);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
        }
    }

    private static void method6() {
        try (ObjectInputStream objectInputStream =
                     new ObjectInputStream(new FileInputStream("./res/obj.txt"))) {
            //反序列化
            Object o1 = objectInputStream.readObject();
            System.out.println(o1);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    private static void method5() {
        Student stu1 = new Student(101, "张三");
        //序列化
        try (ObjectOutputStream objectOutputStream =
                     new ObjectOutputStream(new FileOutputStream("./res/obj.txt"))) {
            objectOutputStream.writeObject(stu1);
            System.out.println("写入完毕");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static void method4() {
        try (BufferedReader bufferedReader = new BufferedReader(new FileReader("./res/a.txt"));
             BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("./res/b.txt"))) {
            // -1
            int read = bufferedReader.read();
            //一次读取一行数据；返回值是null读取完毕
            String s = bufferedReader.readLine();

            bufferedWriter.write(100);
            bufferedWriter.newLine();
            bufferedReader.transferTo(bufferedWriter);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }