IO流

1.flush()：强行把缓冲区的数据放入到输出流中

   close()：关闭输出流，之后再使用输出流对象会报错（stream  closed异常）

2.输入流——对应的——》输出流

　　01.字节输入流的基类InputStream ————》字节输出流的基类OutputStream

　　02.子类FileInputStream（按字节进行读取数据，中文会出现乱码）————》子类FileOutputStream　

　　03.字符输入流Reader————》字符输出流Writer

　　04.子类InputStreamReader(FileReader)————》子类OutputStreamWriter(FileWriter)

　　05.子类BufferedReader（效率高，有默认的缓冲区可以逐行读取）————》子类BufferedWriter

　　06.二进制文件的读取DataInputStream（输入流）————》DataOutputStream（输出流）

3.输入输出流都是相对于计算机的内存而言的。

　　01.所有的输入流都有读的方法

　　02.所有的输出流都有写的方法

4.编码格式

　　01.utf-8：中文字符以及中文都是占3个字节，数字和字母都是占1个

　　02.gbk：中文字符以及中文都是占2个字符

5.只能创建一层目录

@Test
    public void test01() {
        File file = new File("f:/hello");
        file.mkdir();
    }

6.同时创建多层目录

@Test
    public void test02() {
        File file = new File("f:/hello/hello");
        file.mkdirs();
    }

7.创建或删除文件以及一些常用的方法

@Test
    public void test03() throws IOException {
        File file = new File("f:/IO");
        // 首先判断文件是否存在
        if (!file.exists()) {
            // 创建文件成功
            if (file.createNewFile()) {
                System.out.println("文件创建成功");
                System.out.println("创建的是否是文件" + file.isFile());
                System.out.println("文件的名称" + file.getName());
                System.out.println("文件的大小" + file.length());
                System.out.println("文件的绝对路径" + file.getAbsolutePath());
            }
        } else {
            // 文件已经存在，选择删除文件
            if (file.delete()) {
                System.out.println("文件删除成功");
            }
        }
    }

8.使用FileInputStream读取文件的内容

@Test
    public void test04() {
        InputStream is = null;
        int num = 0;
        try {
            is = new FileInputStream("f:/hello.txt");
            System.out.println("显示可读取的字节数：" + is.available());
            while ((num = is.read()) != -1) {
                System.out.print((char) num);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

9.使用OutputStream写入文件内容

/**
     * 注意：
     *     01.Java项目的编码格式要和输出文件的编码一致，都是UTF-8
     *     02.如果系统中没有指定的文件，会默认创建 
     *     03.如果重复输出，则上次输出的内容会被覆盖；如果不想覆盖，就使用重载在第二个参数的位置输入true
     */
    @Test
    public void test05() {
        OutputStream os = null;
        try {
            os = new FileOutputStream("f:/hello.txt", true);
            os.write("你好，IO流".getBytes());
            os.write("IO流操作".getBytes());
            os.flush();// 强行把缓存区的数据写到输出流中
            os.write("测试flush()".getBytes());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                os.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

10.使用FileReader读取文件内容

@Test
    public void test06() {
        // 获取当前的编码格式
        System.out.println("当前使用的编码格式：" + System.getProperty("file.encoding"));
        Reader reader = null;
        try {
            // 创建输入流Reader
            reader = new FileReader("f:/hello.txt");
            char[] words = new char[1024];
            int num = 0;
            // 字符串的拼接
            StringBuffer buffer = new StringBuffer();
            while ((num = reader.read(words)) != -1) {
                buffer.append(words);
            }
            System.out.println("输出获取的字符串");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                reader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

11.使用BufferedReader读取文件内容

/**
     *创建输入流Reader BufferedReader 和FileReader联合使用效率高
     * 底层有默认的缓冲区，可以逐行读取
     */
    @Test
    public void test07() {
        // 创建BufferedReader对象，传递Reader的对象
        BufferedReader bufferedReader = null;
        Reader reader = null;
        try {
            reader = new FileReader("f:/hello.txt");
            bufferedReader = new BufferedReader(reader);
            String line = null;// 设置变量用于接收读取的内容
            while ((line = bufferedReader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                bufferedReader.close();
                reader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }

12.使用OutputStreamWriter

/**
     *  写入文件（字符流） 输出流 没有文件会自动创建新的文件，会默认覆盖之前的内容
     * @throws IOException
     */
    @Test
    public void test08() throws IOException {
        OutputStream stream = new FileOutputStream("f:/hello.txt", true);
        Writer writer = new OutputStreamWriter(stream);
        writer.write("OutputStreamWriter的练习");
        writer.close();
    }

13. 使用FileWriter写入文件

@Test
    public void test09() throws IOException {
        Writer writer = new FileWriter("f:/hello.txt", true);
        writer.write("FileWriter的练习");
        writer.close();
    }

14.使用BufferedWriter写入文件（字符流）

@Test
    public void test10() throws Exception {
        // 创建输出流对象
        Writer writer = new FileWriter("f:/hello.txt", true);
        // 创建BufferedWriter对象
        BufferedWriter bufferedWriter = new BufferedWriter(writer);
        // 换行
        bufferedWriter.newLine();
        // 写入
        bufferedWriter.write("BufferedWriter的练习1");
        // 换行
        bufferedWriter.newLine();
        // 写入
        bufferedWriter.write("BufferedWriter的练习2");
        bufferedWriter.close();
        writer.close();
        System.out.println("***********把写入的内容读取到控制台上**************");
        Reader reader = new FileReader("f:/hello.txt");
        BufferedReader bufferedReader = new BufferedReader(reader);
        String line = null;
        while ((line = bufferedReader.readLine()) != null) {
            System.out.println(line);
        }
        bufferedReader.close();
        reader.close();
    }

15.使用InputStreamReader解决中文乱码问题

@Test
    public void test11() throws Exception {
        // 创建输入流对象
        InputStream stream = new FileInputStream("f:/hello.txt");
        // 使用InputStreamReader来解决乱码
        InputStreamReader reader = new InputStreamReader(stream, "utf-8");
        // 读取
        BufferedReader bufferedReader = new BufferedReader(reader);
        String line = null;
        while ((line = bufferedReader.readLine()) != null) {
            System.out.println(line);
        }
        bufferedReader.close();
        reader.close();
        stream.close();
    }

16.读取2进制文件

@Test
    public void test12() throws Exception {
        // 创建输入流
        InputStream is = new FileInputStream("f:/mini.mp3");
        // 读取2进制文件
        DataInputStream dis = new DataInputStream(is);
        System.out.println("******复制文件到另一个目录********");
        // 创建输出流
        OutputStream os = new FileOutputStream("f:/hello/mimi.mp3");
        // 以2进制的方式输出到指定的目录
        DataOutputStream dos = new DataOutputStream(os);
        int data;
        while ((data = dis.read()) != -1) {
            // 把mini.mp3的内容复制到mimi.mp3文件中
            dos.write(data);
        }
        // 关闭流
        dos.close();
        os.close();
        dis.close();
        is.close();
    }

 17.java IO流的分类

　　01.按流向分类

　　　　001.输入流：InputStream     Reader

　　　　002.输出流：OutputStream　　writer

　　02.按照数据处理划分

　　　　001.字节流：

　　　　　　（1）输入流：InputStream　　FileInputStream

　　　　　　（2）输出流：OutputStream　　FileOutputStream

　　　　002.字符流：

　　　　　　（1）输入流：

　　　　　　　　　　Reader

　　　　　　　　　　　　InputStreamReader(解决乱码问题)　　FileReader

　　　　　　　　　　　　BufferedReader(带缓存区，可以逐行读取)

　　　　　　（2）输出流：

　　　　　　　　　　Writer

　　　　　　　　　　　　OutputStreamWriter　　FileReader

　　　　　　　　　　　　BufferedWriter