Java中IO流基础知识总结，附实例演示

我会带着你远行 2021-09-09 09:40 237阅读 0赞

**目录**

1.创建文件对象

2.文件的常用方法

3.流概念

4.字节流

5.字符流

6.缓存流

7.数据流

8.对象流

--------------------

> **Java中级进价，下面梳理下IO流的一些重要知识，结合实例**

### 1.创建文件对象 ###

*  使用绝对路径创建，如：
    
        File f1=new File("E:/demo.txt");
 *  使用相对路径，即相对项目路径，如：
    
        File f2 = new File("demo.txt");
 *  以某个文件对象作为父目录创建文件对象，如：
    
        File f3=new File(f1, "demo1.txt");

### 2.文件的常用方法 ###

public class Test {
        public static void main(String[] args) {
            File f1=new File("E:/demo.txt");
            System.out.println("判断文件是否存在：" + f1.exists());
            System.out.println("判断是否是文件夹：" + f1.isDirectory());
            System.out.println("判断是否是文件：" + f1.isFile());
            System.out.println("获取文件长度：" + f1.length());
            System.out.println("文件最后修改时间" + (new Date(f1.lastModified())));
            System.out.println("文件重命名："+f1.renameTo(new File("E:/demo1.txt")));
            System.out.println("以字符数组的形式返回当前文件下的所有文件："+f1.list());
            System.out.println("以文件形式获取所在文件夹：" + f1.getParentFile());
            
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDEwNzE0MA_size_16_color_FFFFFF_t_70][]

### 3.流概念 ###

流:**即一系列的数据；**

**输入流InputStream是字节输入流，也是一个抽象类，只提供方法声明，没有具体方法的实现**

**同理输出流OutputStream也是**

**文件输入流：**

public class Test {
        public static void main(String[] args) {
            File file = new File("E:/demo.txt");
    //        流基于文件对象
            try (FileInputStream fileInputStream = new FileInputStream(file)) {
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

**文件输出流：**

public class Test {
        public static void main(String[] args) {
            File file = new File("E:/demo.txt");
            try (FileOutputStream fileOutputStream = new FileOutputStream(file)) {
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

###  4.字节流 ###

以字节流的形式读取文件内容，如：

待读取文件：

![20210811120640455.png][]

public class Test1 {
        public static void main(String[] args) throws IOException {
    //        读取文件
            File file = new File("E:/Test1.txt");
    //        创建文件的输入流
            FileInputStream fis = new FileInputStream(file);
    //        创建字节数组，其长度为文件的长度
            byte[] all = new byte[(int) file.length()];
    //        以字节流的形式读取文件的所有内容
            fis.read(all);
    //        输出结果
            for (byte b : all) {
                System.out.println(b);
            }
    //        用完就关闭流
        }

读取结果：（我们用的是字节流形式传输，故输出的是字母对应的ASCII码值）

![20210811120704196.png][]

以字节流的形式向文件写入数据：

public class Test2 {
        public static void main(String[] args) throws IOException {
    //      以字节流的形式写入文件
    //        准备文件
            FileOutputStream fileOutputStream=null;
            try {
                File f = new File("E:/Test1.txt");
    //        创建字节数组
                byte[] data = {88, 89};
    //        创建输出流
                fileOutputStream = new FileOutputStream(f);
                fileOutputStream.write(data);
    //        关闭输出流
            }finally {
                assert fileOutputStream != null;
                fileOutputStream.close();
            }
    
        }

查看文件，可以看到XY（ASCII分别对应88,89）

![20210811121144869.png][]

###  5.字符流 ###

字符流专门用于字符形式的读取和写入数据，有Reader字符输入流，Writer字符输出流，其中FileReader也是字符输入流，是Reader的子类，FileWriter同理

**使用字符流的形式读取文件内容**，如：

![20210811121658405.png][]

public class Test {
        public static void main(String[] args) {
    
    //        用字符流读取文件的内容
            File file = new File("E:/Test1.txt");
    //        创建字符流
            try (FileReader reader = new FileReader(file)) {
    //            创建字符数组
                char[] chars = new char[(int) file.length()];
                reader.read(chars);
                for (char aChar : chars) {
                    System.out.print(aChar);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

读取结果：

![20210811121924667.png][]

** 使用字符流的方式向文件写入数据，如：**

public class Test {
        public static void main(String[] args) {
    
    //使用字符流将字符串写入文件
            File file = new File("E:/Test1.txt");
    //        准备一个字符串
            String hello_word = "I love java";
    //        将字符串转成字符数组
            char[] chars = hello_word.toCharArray();
    //        创建基于文件的Writer
            try (FileWriter writer = new FileWriter(file)) {
    //            以字符流的形式写入文件
                writer.write(chars);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

查看写入结果：

![20210811122341786.png][]

### ** 6.缓存流** ###

先看字节流和字符流，每一次读写操作（即每读写一个字节或者字符）都会访问硬盘，当读写频率比较高的时候，如此不断地反复访问硬盘，其性能会大大较低，故引入缓存流，缓存流在进行读写操作的时候，会先把要操作的数据先写到缓存区，等缓存区达到一定量的时候，再一次性写入硬盘中去，这样就能在一定程度上减少读写操作。

**使用缓存流读取文件**，如：

待读取文件：

![20210811123331312.png][]

public class Test {
        public static void main(String[] args) throws FileNotFoundException {
    //          缓存流的使用
    //        读取文件
            File file = new File("E://Test2.txt");
    //        创建文件流
            try (FileReader reader = new FileReader(file)) {
    //            创建缓存流（要建立在已有的流之上）
                BufferedReader bufferedReader = new BufferedReader(reader);
                while (true) {
    //               每次读一行
                    String s = bufferedReader.readLine();
    
                    if (s == null) {
                        break;
                    }
                    System.out.println(s);
                }
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
    
        }
    }

读取结果：

![20210811123442333.png][]

**使用缓存流写入文件**，如：

public class Test {
        public static void main(String[] args) throws FileNotFoundException {
    //        使用缓存流写入文件
            File file = new File("E:/Test3.txt");
    //        创建文件流
            try (FileWriter writer = new FileWriter(file)) {
                PrintWriter printWriter = new PrintWriter(writer);
                printWriter.println("happy day");
                printWriter.println("I want to travel!");
            } catch (IOException e) {
                e.printStackTrace();
            }
    
        }
    }

写入结果：

![20210811123736151.png][]

###  7.数据流 ###

使用数据流可以进行数据的格式化读写，数据流也是建立在已有的流基础上，要注意写和读的顺序要一致，不然会出错，如：

public class Test {
    //    数据流写入文件
        public static void write() {
            File file = new File("E:/Test4.txt");
            try (FileOutputStream fileOutputStream = new FileOutputStream(file)) {
                DataOutputStream dataOutputStream = new DataOutputStream(fileOutputStream);
    //            使用数据流写入数据
                dataOutputStream.writeUTF("word");
                dataOutputStream.writeInt(34);
                dataOutputStream.writeBoolean(false);
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    //    数据流读取文件
        public static void read() {
            File file = new File("E:/Test4.txt");
            try (FileInputStream fileInputStream = new FileInputStream(file)) {
                DataInputStream dataInputStream = new DataInputStream(fileInputStream);
                String s = dataInputStream.readUTF();
                int i = dataInputStream.readInt();
                boolean b = dataInputStream.readBoolean();
                System.out.println("读取到的整数：" +i );
                System.out.println("读取到的布尔值" +b);
                System.out.println("读取到的字符串"+s);
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        public static void main(String[] args) {
    //        用数据流进行读写操作
            write();
            read();
        }
    }

![20210811131027512.png][]

###  8.对象流 ###

对象流**指的是可以直接把一个对象以流的形式传输给其他的介质**，比如硬盘  
一个**对象以流的形式进行传输，叫做序列化**。 该对象所对应的类，必须是实现Serializable接口

如：

public class Student implements Serializable {
        public String name;
        public int age;
    
        public Student(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        @Override
        public String toString() {
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }

public class Test {
        public static void main(String[] args) throws IOException, ClassNotFoundException {
            Student stu = new Student("小明", 22);
            File file = new File("E:/Test5.txt");
            FileOutputStream fileOutputStream = new FileOutputStream(file);
    //        对象输出流
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
            objectOutputStream.writeObject(stu);
    //        对象输入流
            FileInputStream fileInputStream = new FileInputStream(file);
            ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
            Student stu2 = (Student) objectInputStream.readObject();
            System.out.println(stu2);
        }
    }

![20210811133256728.png][]

此外，还有

**System.out 控制台输出数据的  
System.in 从控制台输入数据**

--------------------

综上，以上各种流的关系：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDEwNzE0MA_size_16_color_FFFFFF_t_70 1][]

===============

以上学习参考[how2j教程][how2j]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDEwNzE0MA_size_16_color_FFFFFF_t_70]: /images/20210813/a607c783b6d1468ba49bb4e4c0a0e3e1.png
[20210811120640455.png]: /images/20210813/03d7876461fe41faa60b565ebae05e45.png
[20210811120704196.png]: /images/20210813/b1f59ab584c84fed8957be713ccaecd4.png
[20210811121144869.png]: /images/20210813/96200681cefc432ba984bd686f235053.png
[20210811121658405.png]: /images/20210813/840b9b1aa7ce442d8d11806f2ba7efb0.png
[20210811121924667.png]: /images/20210813/6a6dd9211693442bb2a491a2402cf127.png
[20210811122341786.png]: /images/20210813/59972a4c2c5d40f88de4b4e3d1739544.png
[20210811123331312.png]: /images/20210813/33c180232e1d4aab96ac24b7007ed867.png
[20210811123442333.png]: /images/20210813/7f512b01f7874cd6b1f09b28467b1087.png
[20210811123736151.png]: /images/20210813/9f4696d027a34c9badf6c32bb072e4c6.png
[20210811131027512.png]: /images/20210813/b198724022164a3fad2be44b306522b5.png
[20210811133256728.png]: /images/20210813/50283895993e423f9737f0f5bca14510.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDEwNzE0MA_size_16_color_FFFFFF_t_70 1]: /images/20210813/045f2ee8aec440b2972dc8e987cd9490.png
[how2j]: https://how2j.cn/k/io/io-file/345.html