java io流学习笔记

柔光的暖阳◎ 2023-10-14 13:07 41阅读 0赞

### PS:大部分来源于参考资料的原话,总结的很好我就没改。 ###

### 1. IO 流能干什么 ###

通过IO我们能对硬盘文件进行读和写。(网络数据的传输也涉及到io)。

### 2. IO流的分类 ###

按照 流的方向 进行分类：分为输入、输出流。

往内存中去：叫做**输入(Input)**。或者叫做**读(Read)**。  
从内存中出来：叫做**输出(Output)**。或者叫做**写(Write)**。

按照 读取数据方式 不同进行分类：  
按照 字节 的方式读取数据，一次读取1个字节byte，等同于一次读取8个二进制位。  
这种流是万能的，什么类型的文件都可以读取。包括：文本文件，图片，声音文件，视频文件 等…

按照 字符 的方式读取数据的，一次读取一个字符.  
这种流是为了方便读取 普通文本文件 而存在的，这种流不能读取：图片、声音、视频等文件。只能读取 纯文本文件，连word文件都无法读取。

注意：  
纯文本文件，不单单是.txt文件，还包括 .java、.ini、.py 。总之只要 能用记事本打开 的文件都是普通文本文件。

### 3.IO流的顶层父类 ###

\- 字节输入流：顶层父类：InputStream --> 抽象类 常见子类：FileInputStream  
\- 字节输出流：顶层父类：OutputStream --> 抽象类 常见子类：FileOutputStream  
\- 字符输入流：顶层父类：Reader --> 抽象类 常见子类：FileReader  
\- 字符输出流：顶层父类：Writer --> 抽象类 常见子类：FileWriter

### 4.Java要掌握的流（16个） ###

1.文件专属：

*  java.io.FileInputStream（掌握）
 *  java.io.FileOutputStream（掌握）
 *  java.io.FileReader
 *  java.io.FileWriter

2.转换流：（将字节流转换成字符流）

*  java.io.InputStreamReader
 *  java.io.OutputStreamWriter

3.缓冲流专属：

*  java.io.BufferedReader
 *  java.io.BufferedWriter
 *  java.io.BufferedInputStream
 *  java.io.BufferedOutputStream

4.数据流专属：

*  java.io.DataInputStream
 *  java.io.DataOutputStream

5.标准输出流：

*  java.io.PrintWriter
 *  java.io.PrintStream（掌握）

6.对象专属流：

*  java.io.ObjectInputStream（掌握）
 *  java.io.ObjectOutputStream（掌握）

7.File文件类

*  java.io.File

### 5.输入流 ###

PS: 下面很多try,catch 捕获异常,都不是我写的，当然第一次写的话，可以自己敲一下，但是alt + z 直接快捷生成。

另外，就是那几个常用的方法(我自己觉得),其实会写前几个,其实剩余都比较好记住。

我的conf.txt文件和src在同一个目录。

![046212490c734f1e99a79ff389aa84b0.png][]

#### FileInputStream ####

![b6dc1db73dcd411399757e1e98de4104.png][]

public class IODemo1 {
        public static void main(String[] args)  {
            File file = new File("conf.txt");
            FileInputStream inputStream = null;
            try {
                inputStream = new FileInputStream(file);
    
                byte[] bytes = new byte[3]; // 做缓存用的，一次最多4个字节
                int redCount = 0;
    
                // inputStream去读取,而每次读取到的字节文件存放到bytes中。
                while ((redCount = inputStream.read(bytes)) != -1){ // read读取值是字节数量,读取不到返回-1
                    System.out.println("转换后的字符:"+new String(bytes, "UTF-8"));
                    System.out.println("读取字节数量:"+redCount);
                    System.out.println("----------------");
                }
    
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }finally {
                // 失败与否都要关闭io
                if(inputStream != null){ // 判断文件是否为null
                    try{
                        inputStream.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
    
        }
    }

#### InputStreamReader ####

就是有这么一种写法。

将字节输入流转换字符输入流。

public class IODemo {
        public static void main(String[] args)  {
            File file = new File("conf.txt");
            FileInputStream inputStream = null;
            InputStreamReader inputStreamReader = null;
            try {
                 inputStream = new FileInputStream(file);
                 inputStreamReader = new InputStreamReader(inputStream,"UTF-8"); // 转换为为字符输入流
    
                byte[] bytes = new byte[3]; // 做缓存用的，一次最多4个字节
                char[] chars = new char[1];
                int redCount = 0;
    
                // inputStream去读取,每次读取到字节存放到bytes中。
                //while ((redCount = inputStream.read(bytes)) != -1){ // read读取值是字节数量,读取不到返回-1
                //    System.out.println("转换后的字符:"+new String(bytes, "GBK"));
                //    System.out.println("读取字节数量:"+redCount);
                //}
                System.out.println("---------------");
                // 对一个文件不能同时开2个输入流
                while ((redCount = inputStreamReader.read(chars)) != -1){
                    System.out.println("读取字符数量:"+redCount);
                    for (char aChar : chars) { // 遍历缓冲字符数组
                        System.out.println(aChar);
                    }
                    System.out.println("将字符数组转换成字符串:"+ new String(chars));
                    System.out.println("---------------");
                }
    
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }finally {
                // 失败与否都要关闭io
                if(inputStreamReader != null){
                    try{ // 流的关闭要区分顺序，先关闭外层也就是包装那一层
                        inputStreamReader.close();
                        inputStream.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
    
    
        }
    }

#### FileReader ####

文件字符读取的形式

![257703b661ca43df9c05611d84089ff4.png][]

public class FileReaderDemo {
        public static void main(String[] args) {
            File file = new File("conf.txt");
            FileReader fileReader = null;
            try {
                char[] chars = new char[4];
                int readCount = 0;
                fileReader = new FileReader(file);
                while ((readCount = fileReader.read(chars)) != -1){
                    System.out.println(new String(chars));
                }
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }finally {
                if(fileReader != null){
                    try {
                        fileReader.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
    
        }
    }

#### BufferedReader ####

![0675cc2ac1e0432d8b2edd8fcc8a9c46.png][]

自带缓存的字符输入流。构造参数是一个字符输入流。

public class BufferReaderDemo {
        public static void main(String[] args) throws IOException {
            FileReader fileReader = new FileReader("conf.txt");
            // 当一个流的构造方法中需要一个流的时候，这个被传进来的流叫做：节点流。
            // 外部负责包装的这个流，叫做：包装流，还有一个名字叫做：处理流。
            // 像当前这个程序来说：FileReader就是一个节点流。BufferedReader就是包装流/处理流。
            BufferedReader bufferedReader = new BufferedReader(fileReader);
    
            String str = null;
            while ((str = bufferedReader.readLine()) != null){ // readLine()方法读取一个文本行，但不带换行符。
                System.out.println(str);
            }
    
            bufferedReader.close(); // 关闭最外层即可
        }
    }

#### ObjectInputStream ####

反序列化对象

// 反序列化
            ObjectInputStream oin = new ObjectInputStream(new FileInputStream("conf1.txt"));
            Object o = oin.readObject();
            System.out.println(o);

### 6.输出流 ###

#### FileOutputStream ####

![5eb5e973d65347ae97e9093c3389b515.png][]

public class IoDemo2 {
        public static void main(String[] args) {
            File file = new File("conf.txt");
            FileOutputStream outputStream = null;
            try {
                outputStream = new FileOutputStream(file,true); // 开启文件追加模式
                String wls = "万乐姝";
                byte[] bytes = wls.getBytes(StandardCharsets.UTF_8); // 将string转换为字节文件
                outputStream.write(bytes); // 写入
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }finally {
                if(outputStream != null){
                    try {
                        outputStream.flush(); // 先刷新在关闭，否则可能有bug
                        outputStream.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
    
        }
    }

#### OutputStreamWriter ####

public class IoDemo2 {
        public static void main(String[] args) {
            File file = new File("conf.txt");
            FileOutputStream outputStream = null;
            OutputStreamWriter outputStreamWriter = null;
            try {
                outputStream = new FileOutputStream(file,true); // 开启文件追加模式
                outputStreamWriter = new OutputStreamWriter(outputStream);
                outputStreamWriter.write("万乐姝");
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }finally {
                if(outputStream != null){
                    try {
                        outputStreamWriter.flush(); // 先关闭外层流
                        outputStreamWriter.close();
                        outputStream.flush();
                        outputStream.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
    
        }
    }

#### FileWriter ####

![c2d1a10922dc42deaa5b3ad8cbf6f4e2.png][]

public class FileWriterDemo {
        public static void main(String[] args) {
            File file = new File("conf.txt");
            FileWriter fileWriter = null;
            try {
                fileWriter = new FileWriter(file,true); // 开启文件追加模式
                fileWriter.write("卧槽");
            } catch (IOException e) {
                e.printStackTrace();
            }finally {
                try {
                    fileWriter.flush();
                    fileWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

#### BufferedWriter ####

![b3a850325f9149c99ec65bfa836f5b2d.png][]

public class BufferWriterDemo {
        public static void main(String[] args) throws IOException {
            FileWriter fileWriter = new FileWriter("conf.txt",true);
            BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
            bufferedWriter.write("qhxxxx");
            bufferedWriter.close();
    
        }
    }

#### PrintStream ####

![a8016b0be4f54448aedf1d8a1185b10f.png][]

我们平时用的控制台打印语句就是PrintStream对象

#### ![d59e5356408649d3bba989f3d62da217.png][] ####

改变流的输出方向

**`System.setOut(PrintStream对象)`**

PrintStream printStream = new PrintStream(new FileOutputStream("conf.txt"));
            printStream.println("\n121212"); // 输出到conf.txt
            System.setOut(printStream); // 改变流的输出方向
    
            System.out.println("\n完了数"); // 输出到conf.txt了
            System.out.println("121212");

#### ObjectOutputStream ####

对新手感觉用处不大

要被序列化的对象必须实现 Serializable 接口

// 序列化
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(new             
            FileOutputStream("conf1.txt"));
            objectOutputStream.writeObject(new User("qhx","1232323"));
            objectOutputStream.flush();
            objectOutputStream.close();

### 7.配置properties文件的读取和设置 ###

*  getProperty ( String key)： 用指定的键在此属性列表中搜索属性。也就是通过参数 key ，得到 key 所对应的 value。
 *  load ( InputStream inStream)： 从输入流中读取属性列表（键和元素对）。通过对指定的文件（比如说上面的 test.properties 文件）进行装载来获取该文件中的所有键 - 值对。以供 getProperty ( String key) 来搜索。
 *  setProperty ( String key, String value) ： 调用 Hashtable 的方法 put 。他通过调用基类的put方法来设置 键 - 值对。
 *  store ( OutputStream out, String comments)： 以适合使用 load 方法加载到 Properties 表中的格式，将此 Properties 表中的属性列表（键和元素对）写入输出流。与 load 方法相反，该方法将键 - 值对写入到指定的文件中去。
 *  clear ()： 清除所有装载的 键 - 值对。该方法在基类中提供。

#### 配置文件读取 ####

private static String getKey(String key) {
            Properties properties = new Properties();
            File file = new File(FILE_NAME);
            FileInputStream inputStream = null;
            try {
                inputStream = new FileInputStream(file); // 配置文件
                properties.load(inputStream); // 将配置文件对应的key,value映射到properties的map中。
            } catch (IOException e) {
                e.printStackTrace();
            }finally {
                if(inputStream != null){  // 还是这样关比较好，万一报错就tm关不了
                    try {
                        inputStream.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
            System.out.println(properties.getProperty(key));
        }

#### 配置文件设置 ####

/**
         * 配置文件设置
         *
         * @param key
         * @param value
         * @return
         */
        public static boolean setPropertiesKey(String key,String value) {
            // 判断key是否有重复
            String key1 = getKey(key);
            if(key1 == null){
                return setKey(key,value); 
            }
            return false;
        }
    
        /**
         *  配置文件设置
         *
         * @param key
         * @param value
         * @return boolean
         */
        private static boolean setKey(String key, String value) {
            Properties properties = new Properties();
            File file = new File(FILE_NAME); // 其实有其他配置可以同意下yaml文件里面配置，然后这里面读取，好统一调配。
            FileWriter fileWriter = null;
            try {
                fileWriter = new FileWriter(file,true);
                properties.setProperty(key, value); // 存进map里面
                properties.store(fileWriter,""); // 将map对应的键值对写进输出流。这个comments 最后写入的时候是个注释
            } catch (IOException e) {
                // 卧槽我加入设置key,value失败，肯定调到这个逻辑
                return false;
            } finally {
                if (fileWriter != null) {  // 还是这样关比较好，万一报错就tm关不了
                    try {
                        fileWriter.flush();
                        fileWriter.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
            return true;
        }
    
    }

### 8.File ###

在java中file对象表示**文件、目录**的抽象表示形式。

![737aff9f417744e895d021e9c6a8627c.png][]

#### 案例:递归实现遍历文件目录 ####

public class FileDemo {
        public static void main(String[] args) {
            getChildrenFile("src",1);
        }
    
    
        // 递归则子文件所有目录
        public static void getChildrenFile(String fileName,int y){ // fileName 文件路径名,y 是目录等级
            File file = new File(fileName);
            StringBuffer stb = new StringBuffer();
            // 根据目录等级追加几条 "-"
            for (int i = 0; i < y; i++) {
                stb.append("-");
            }
            // 遍历子文件
            for (String name: file.list()) {
                System.out.println(stb + name); // 目录等级 + 文件路径名,并且换行
                String childrenName = fileName + "/"+name;
                if(new File(childrenName).isDirectory()){ // 判断子文件是否是递归，是的话仍执行
                    getChildrenFile(childrenName,y+1); // 同样下一级目录等级 + 1
                }
            }
          }
    
        }

### 参考资料 ###

[Java IO流 详解（字节流、字符流、输入流、输出流、刷新）\_输入流 输出流 更新流\_肥兄的博客-CSDN博客][Java IO_ _ _ _-CSDN]

[Java IO流（超详细！）\_一个快乐的野指针~的博客-CSDN博客][Java IO_-CSDN]

[046212490c734f1e99a79ff389aa84b0.png]: https://img-blog.csdnimg.cn/046212490c734f1e99a79ff389aa84b0.png
[b6dc1db73dcd411399757e1e98de4104.png]: https://img-blog.csdnimg.cn/b6dc1db73dcd411399757e1e98de4104.png
[257703b661ca43df9c05611d84089ff4.png]: https://img-blog.csdnimg.cn/257703b661ca43df9c05611d84089ff4.png
[0675cc2ac1e0432d8b2edd8fcc8a9c46.png]: https://img-blog.csdnimg.cn/0675cc2ac1e0432d8b2edd8fcc8a9c46.png
[5eb5e973d65347ae97e9093c3389b515.png]: https://img-blog.csdnimg.cn/5eb5e973d65347ae97e9093c3389b515.png
[c2d1a10922dc42deaa5b3ad8cbf6f4e2.png]: https://img-blog.csdnimg.cn/c2d1a10922dc42deaa5b3ad8cbf6f4e2.png
[b3a850325f9149c99ec65bfa836f5b2d.png]: https://img-blog.csdnimg.cn/b3a850325f9149c99ec65bfa836f5b2d.png
[a8016b0be4f54448aedf1d8a1185b10f.png]: https://img-blog.csdnimg.cn/a8016b0be4f54448aedf1d8a1185b10f.png
[d59e5356408649d3bba989f3d62da217.png]: https://img-blog.csdnimg.cn/d59e5356408649d3bba989f3d62da217.png
[737aff9f417744e895d021e9c6a8627c.png]: https://img-blog.csdnimg.cn/737aff9f417744e895d021e9c6a8627c.png
[Java IO_ _ _ _-CSDN]: https://blog.csdn.net/m0_60489526/article/details/120004119
[Java IO_-CSDN]: https://blog.csdn.net/qq_44715943/article/details/116501936