Java(十八)

知识点一:IO流

IO流：数据从源节点到目标结点的移动。

*              字节流         字符流
* 输入流      InputStream     Reader
* 输出流      OutputStream    Writer

知识点二:文件流

文件流：File前缀

字节文件输入流：FileInputStream

字节文件输出流：FileOutStream

字符文件输入流：FileReader

字符文件输出流：FileWriter

读文本文件：FIleReader

写文本文件：FIleWriter

写二进制文件：FileOutStream

处理文件的步骤：

1）创建流对象，建立通道

2）通过流对象的相关方法处理数据

3)关闭流

缓冲区：就是一个数组，读取硬盘和中的数据通常必须是要使用缓冲区，为的是提升效率。

（1）三步骤读取文本文件

@Test
    public void test1() throws Exception {
        //1) 创建流对象, 建立通道
        FileReader fileReader = new FileReader("一个文件"); // 当前目录下, 项目目录.
        //2) 通过流对象的相关方法处理数据
        int ch;
        while ((ch = fileReader.read()) != -1) { // 读一个字符, 返回字符的Unicode码值
            System.out.print((char) ch);
        }
        //3) 关闭流
        fileReader.close();

    }

(2)处理读取的异常

@Test
    public void test2() {
        //1) 创建流对象, 建立通道
        FileReader fileReader = null;
        try {
            fileReader = new FileReader("一个文件2");
            // 处理数据
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } finally {
            //3) 关闭流
            if (fileReader != null) {
                try {
                    fileReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

(3)读取文本文件的升级版

提取步骤为：

①直接声明引用变量

②try catch finally

③在finally中关闭流

④在catch中处理异常

⑤在try中创建流对象

⑥在try中处理数据

@Test
    public void test3() {
        int line = 1;
        System.out.print(line++ + " ");
        // 1) 直接声明引用变量, 并赋值为null
        FileReader fileReader = null;
        // 2) try catch finally
        try {
            // 5) 在try中创建流对象
            fileReader = new FileReader("一个文件");
            // 6) 在try中继续处理数据
            int ch;
            while ((ch = fileReader.read()) != -1) { // 只要读到的数据不是-1, 就一直读, 直到-1为止
                // 处理已经读到的数据
                System.out.print((char)ch);
                if (ch == 10) {
                    System.out.print(line++ + " ");
                }
            }
        } catch (Exception e) {
            // 4) 在catch中处理异常
            e.printStackTrace();
        } finally {
            // 3) 在finally中关闭流
            if (fileReader != null) {
                try {
                    fileReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }

（4）写文本文件

@Test
    public void test4() {
        FileWriter fileWriter = null;
        try {
            fileWriter = new FileWriter("写文本文件"); // 写文件时,文件会自动创建
            fileWriter.write('我');
            fileWriter.write('和');
            fileWriter.write('你');
            fileWriter.write(13);
            fileWriter.write(10);

            fileWriter.write('1');
            fileWriter.write('2');
            fileWriter.write('3');
            fileWriter.write('\r');
            fileWriter.write('\n');

            fileWriter.write('c');
            fileWriter.write('y');
            fileWriter.write('d');
            fileWriter.write(13);
            fileWriter.write(10);

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (fileWriter != null) {
                try {
                    fileWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

（5）借助缓冲区读取数据

@Test
    public void test5() {
        // 缓冲区 : 就是一个数组, 读取硬盘中的数据通常必须要使用缓冲区, 为的是提升效率.
        FileReader fileReader = null;
        try {
            fileReader = new FileReader("ArrayList.java");
            char[] buf = new char[200];
            // 从输入流中读取批量的字符到字符数组中去, 实际读了多少个字符由返回值决定.
            int count; // count是实际读到的字符数
            while ((count = fileReader.read(buf)) != -1) { // 如果文件读完了再读就会返回-1
                // 处理已经读到的数据. 以实际读的个数为准.
                for (int i = 0; i < count; i++) {
                    System.out.print(buf[i]);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (fileReader != null) {
                try {
                    fileReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }

(6)利用缓冲区写文件

@Test
    public void test6() {
        FileWriter fileWriter = null;
        try {
            fileWriter = new FileWriter("使用缓冲写文件");
            String[] content = {"2394872984u23o4u2842384u23894u23",
                                "我是字符串, 来写我吧, 我要写入文件了1",
                                "我是字符串, 来写我吧, 我要写入文件了2",
                                "我是字符串, 来写我吧, 我要写入文件了3",
                                "我是字符串, 来写我吧, 我要写入文件了4",
                                "我是字符串, 来写我吧, 我要写入文件了5",
                                "我是字符串, 来写我吧, 我要写入文件了6",
                                "我是字符串, 来写我吧, 我要写入文件了7",
                                "我是字符串, 来写我吧, 我要写入文件了8",
                                "非机动车asjaslfjalskdflasdflasjflajsdfljasdlfjlasjdf"};
            for (int i = 0; i < content.length; i++) {
                char[] array = content[i].toCharArray();
                //fileWriter.write(array); // 写数组中的所有字符到输出流中.
                fileWriter.write(array, 7, array.length - 7); // 写数组中的字符时, 从下标6开始写, 第3个参数是要写的字符个数
                fileWriter.write(13);
                fileWriter.write(10);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (fileWriter != null) {
                try {
                    fileWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

测试：// 创建一个字符串数组, 包含一些姓名, 写一个文件name.txt, 写入所有的名到文件中.

FileWriter fileWriterName = null;
        try {
            fileWriterName = new FileWriter("name.txt");
            String[] name ={"马云",
                    "马化腾",
                    "李彦宏",
                    "张一鸣"};
            for (int i = 0; i < name.length; i++) {
                char[] names = name[i].toCharArray();

                    fileWriterName.write(names,1,names.length - 1);
                    fileWriterName.write(13);
                    fileWriterName.write(10);

            }

        }finally {
            if(fileWriterName != null){
                try {
                    fileWriterName.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

知识点三：缓冲流

缓冲流：Buffered，内部自带缓冲区，并提供了更强大的读写功能

BufferedReader

BufferedWriter

@Test
    public void test7() {
        FileReader fileReader = null;
        BufferedReader bufferedReader = null;
        try {
            fileReader = new FileReader("FileCopy.java.bak");
            bufferedReader = new BufferedReader(fileReader); // 通过构造器完成对象关联, 高级流对象关联低级流对象.
            String line;
            while ((line = bufferedReader.readLine()) != null) { // readLine()是最有价值方法.
                System.out.println(line); // line中不包含换行符了.
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 只关闭高级流
            if (bufferedReader != null) {
                try {
                    bufferedReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

@Test
    public void test8() {
        FileWriter fileWriter = null;
        BufferedWriter bufferedWriter = null;
        try {
            fileWriter = new FileWriter("使用高级流写文本");
            bufferedWriter = new BufferedWriter(fileWriter); // 高级流包装低级流
            String[] content = {"283947298429842894289374",
                                "我也是内容, 要求写入1",
                                "我也是内容, 要求写入2",
                                "我也是内容, 要求写入3",
                                "我也是内容, 要求写入4",
                                "我也是内容, 要求写入5",
                                "我也是内容, 要求写入6",
                                "239842389423984桂圆黄果树瀑布fllkajlkfjasldkjf"};
            for (int i = 0; i < content.length; i++) {
                bufferedWriter.write(content[i]);
                bufferedWriter.newLine(); // 可以写入跨平台的换行, 最有价值方法.
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (bufferedWriter != null) {
                try {
                    bufferedWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

知识点四：自定义流

ObjectInputStream

ObjectOutStream

@Test
    public void test9() {
        FileOutputStream fos = null;
        BufferedOutputStream bos = null;
        ObjectOutputStream oos = null;
        try {
            fos = new FileOutputStream("二进制文件");
            bos = new BufferedOutputStream(fos);
            oos = new ObjectOutputStream(bos);

            oos.writeInt(20);
            oos.writeBoolean(true);
            oos.writeBoolean(false);
            oos.writeLong(30L);
            oos.writeDouble(3.14);

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (oos != null) {
                try {
                    oos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

@Test
    public void test10() {
        FileInputStream fis = null;
        BufferedInputStream bis = null;
        ObjectInputStream ois = null;
        try {
            fis = new FileInputStream("二进制文件");
            bis = new BufferedInputStream(fis);
            ois = new ObjectInputStream(bis);

            ois.readInt();

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (ois != null) {
                try {
                    ois.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }