• 让你深入理解Java IO流

    聾缓冲流

    （1）带有缓冲区的字符输入流；使用这个流的时候 不需要自定义char数组 ，或者说不需要自定义byte数组；自带缓冲！

    （2）读取数据时， 可以一次性读取一行

    （3）这里只讲解字符缓冲流： java.io.BufferedReader 和 java.io.BufferedWriter ；字节缓冲流使用方法是一样的

    （4）BufferedReader和BufferedWriter都是包装流！

    1.字符输入流BufferedReader

    1. "prettyprint hljs java" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto;">package com.bjpowernode.java.io;
    2.  
    3. import java.io.BufferedReader;
    4. import java.io.FileNotFoundException;
    5. import java.io.FileReader;
    6.  
    7. public class BufferedReaderTest01 {
    8.     public static void main(String[] args) throws Exception {
    9.         FileReader reader = new FileReader("file");
    10.         // 当一个流的构造方法中需要一个流的时候，这个被传进来的流叫做：节点流。
    11.         // 外部负责包装的这个流，叫做：包装流或者叫做：处理流。
    12.         // FileReader就是一个节点流。BufferedReader就是包装流/处理流。
    13.         BufferedReader br = new BufferedReader(reader); // 只能传字符流
    14.  
    15.         // 优点：一次能读一行；但不带换行符！
    16.         String s = null;
    17.         while((s = br.readLine()) != null){ // br.readLine()返回的是一个字符串
    18.             System.out.println(s);
    19.         }
    20.  
    21.         // 关闭流,只需要关闭最外层流就行，里面的节点流会自动关闭。
    22.         br.close();
    23.  
    24.     }
    25. }

    2.字符输出流BufferedWriter

    1. "prettyprint hljs gradle" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto;">package com.bjpowernode.java.io;
    2.  
    3. import java.io.*;
    4.  
    5. public class BufferedWriterTest01 {
    6.     public static void main(String[] args) throws IOException {
    7.         // 创建带有缓冲区的字符输出流
    8.         BufferedWriter writer = new BufferedWriter(new FileWriter("file"));
    9.  
    10.         // 开始写
    11.         writer.write("hello world!");
    12.         writer.write("\n");
    13.         writer.write("hello kitty!");
    14.  
    15.         // 刷新
    16.         writer.flush();
    17.         // 关闭最外层
    18.         writer.close();
    19.     }
    20. }<

    聾转换流

    1.OutputStreamWriter

    1. <pre class="hljs" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 0.75em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto;">BufferedWriter：带有缓冲的字符输出流。
    2. OutputStreamWriter：转换流
    3.  
    1. "prettyprint hljs gradle" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto;">package com.bjpowernode.java.io;
    2.  
    3. import java.io.*;
    4.  
    5. public class BufferedWriterTest01 {
    6.     public static void main(String[] args) throws IOException {
    7.         // 创建带有缓冲区的字符输出流
    8.         BufferedWriter writer = new BufferedWriter(new FileWriter("file"));
    9.  
    10.         // 如果想要使用字节输出流，还是需要OutputStreamWriter进行流的转换
    11.         // 如果使用的是字节流
    12.         OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("file"));
    13.         BufferedWriter writer1 = new BufferedWriter(osw);
    14.  
    15.         // 合并在一起
    16.         BufferedWriter writer1 = new BufferedWriter(new OutputStreamWriter
    17.         (new FileOutputStream("file")));
    18.  
    19.         // 开始写
    20.         writer.write("hello world!");
    21.         writer.write("\n");
    22.         writer.write("hello kitty!");
    23.  
    24.         // 刷新
    25.         writer.flush();
    26.         // 关闭最外层
    27.         writer.close();
    28.     }
    29. }

    2.InputStreamReader

    BufferedReader(reader)，里面只能传字符流；那如果是字节流怎么办呢？

    1. "prettyprint hljs java" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto;">package com.bjpowernode.java.io;
    2.  
    3. import java.io.*;
    4.  
    5. public class BufferedReaderTest02 {
    6.     public static void main(String[] args) {
    7.  
    8.         FileInputStream fis = null;
    9.         try {
    10.             // 字节流
    11.             fis = new FileInputStream("file");
    12.             // 通过转换流转换（InputStreamReader将字节流转换成字符流）
    13.             // fis是节点流。reader是包装流。
    14.             InputStreamReader reader = new InputStreamReader(fis);
    15.             // 把转换成字符流的字节流，传过来
    16.             // reader是节点流。br是包装流。
    17.             BufferedReader br = new BufferedReader(reader);
    18.  
    19.             // 上面进行合并
    20.             BufferedReader br1 = new BufferedReader(new InputStreamReader(new FileInputStream("file")));
    21.  
    22.             // 进行打印
    23.             String s = null;
    24.             while((s = br1.readLine()) != null){
    25.                 System.out.println(s);
    26.             }
    27.  
    28.             // 关闭
    29.             br.close(); // 关闭最外层
    30.  
    31.         } catch (FileNotFoundException e) {
    32.             e.printStackTrace();
    33.         } catch (IOException e) {
    34.             e.printStackTrace();
    35.         } finally {
    36.             if (fis != null) {
    37.                 try {
    38.                     fis.close();
    39.                 } catch (IOException e) {
    40.                     e.printStackTrace();
    41.                 }
    42.             }
    43.         }
    44.     }
    45. }

    聾数据流

    1.DataOutputStream

    （1）java.io.DataOutputStream：数据专属的流；也是一个包装流！

    （2）这个流可以 将数据连同数据的类型一并写入文件 。

    （3）注意：这个文件不是普通文本文档。（这个文件使用记事本打不开）

    1. "prettyprint hljs java" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto;">package com.bjpowernode.java.io;
    2.  
    3. import java.io.DataOutputStream;
    4. import java.io.FileOutputStream;
    5.  
    6. public class DataOutputStreamTest01 {
    7.     public static void main(String[] args) throws Exception{
    8.         // 创建数据专属的字节输出流（写）
    9.         DataOutputStream dos = new DataOutputStream(new FileOutputStream("file")); //生成的这个文件，记事本打不开
    10.         // 写数据
    11.         byte b = 100;
    12.         short s = 200;
    13.         int i = 300;
    14.         long l = 400L;
    15.         float f = 3.0F;
    16.         double d = 3.14;
    17.         boolean sex = false;
    18.         char c = 'a';
    19.         // 写；把数据以及数据的类型一并写入到文件当中
    20.        dos.writeByte(b);
    21.        dos.writeShort(s);
    22.        dos.writeInt(i);
    23.        dos.writeLong(l);
    24.        dos.writeFloat(f);
    25.        dos.writeDouble(d);
    26.        dos.writeBoolean(sex);
    27.        dos.writeChar(c);
    28.  
    29.         // 刷新
    30.         dos.flush();
    31.  
    32.         // 关闭最外层
    33.         dos.close();
    34.     }
    35. }

    2.DataInputStream

    （1）DataInputStream：数据字节输入流。

    （2）DataOutputStream写的文件，只能使用DataInputStream去读。并且读的时候你需要提前知道写入的顺序；读的顺序需要和写的顺序一致。才可以正常取出数据 。

    1. "prettyprint hljs gradle" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto;">package com.bjpowernode.java.io;
    2.  
    3. import java.io.DataInputStream;
    4. import java.io.FileInputStream;
    5.  
    6. public class DataInputStreamTest01 {
    7.     public static void main(String[] args) throws Exception {
    8.         // 创建数据专属的字节输入流（读）
    9.         DataInputStream dis = new DataInputStream(new FileInputStream("file"));
    10.         // 开始读
    11.         byte b = dis.readByte();
    12.         short s = dis.readShort();
    13.         int i = dis.readInt();
    14.         long l = dis.readLong();
    15.         float f = dis.readFloat();
    16.         double d = dis.readDouble();
    17.         boolean sex = dis.readBoolean();
    18.         char c = dis.readChar();
    19.         // 打印
    20.  
    21.         System.out.println(b);
    22.         System.out.println(s);
    23.         System.out.println(i);
    24.         System.out.println(l);
    25.         System.out.println(f);
    26.         System.out.println(d);
    27.         System.out.println(sex);
    28.         System.out.println(c);
    29.  
    30.         // 关闭流
    31.         dis.close();
    32.     }
    33. }

    聾标准输出流

    1.PrintStream

    （1）jva.io.PrintStream：标准的字节输出流。默认输出到控制台。

    （2）标准输出流 不需要手动close()关闭 。

    （3）可以 通过System.setOut()方法改变输出流的方向

    1. "prettyprint hljs gradle" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto;">package com.bjpowernode.java.io;
    2.  
    3. import java.io.FileOutputStream;
    4. import java.io.PrintStream;
    5.  
    6. public class PrintStreamTest {
    7.     public static void main(String[] args) throws Exception {
    8.         System.out.println("hello world");
    9.         // 实际上上述代码可以拆分成
    10.         PrintStream ps = System.out;
    11.         ps.println("hello world");
    12.  
    13.         // 可以改变标准输出流的输出方向；
    14.         // 例如：标准输出流不在指向控制台，指向log文件
    15.         PrintStream printStream = new PrintStream(new FileOutputStream("log"));
    16.         // 修改输出方向
    17.         System.setOut(printStream);
    18.  
    19.         // 输出
    20.         System.out.println("Hello World"); //不会再输出到控制台，而是到log文件
    21.  
    22.     }
    23. }

    2.日志工具类

    那么标准输出流PrintStream有什么用呢？我们不妨写一个简单的日志工具类！

    日志框架

    1. "prettyprint hljs typescript" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto;">package com.bjpowernode.java.io;
    2.  
    3. import java.io.FileNotFoundException;
    4. import java.io.FileOutputStream;
    5. import java.io.PrintStream;
    6. import java.text.SimpleDateFormat;
    7. import java.util.Date;
    8.  
    9. // 日志工具
    10. public class Logger {
    11.     // 记录日志的方法
    12.    public static void log(String msg) {
    13.        try {
    14.            PrintStream out = new PrintStream(new FileOutputStream("log.txt",true));
    15.            // 改变流的方向
    16.            System.setOut(out);
    17.            // 获取系统当前时间
    18.            Date nowDate = new Date();
    19.            // 格式类型转换
    20.            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
    21.            String myNowdate = sdf.format(nowDate);
    22.            // 打印
    23.            System.out.println(myNowdate+":"+msg);
    24.  
    25.        } catch (FileNotFoundException e) {
    26.            e.printStackTrace();
    27.        }
    28.  
    29.    }
    30. }

    日志测试

    1. class="prettyprint hljs cpp" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto;">package com.bjpowernode.java.io;
    2.  
    3. public class LoggerTest {
    4.     public static void main(String[] args) {
    5.         // 测试日志工具类
    6.         Logger.log("调用了System类的gc()方法，建议启动垃圾回收");
    7.         Logger.log("调用了UserService的doSome()方法");
    8.         Logger.log("用户尝试进行登录，验证失败");
    9.  
    10.         // 在log.txt打印的结果
    11.        /* 2022-07-22 08:47:49 667:调用了System类的gc()方法，建议启动垃圾回收
    12.         2022-07-22 08:47:49 703:调用了UserService的doSome()方法
    13.         2022-07-22 08:47:49 714:用户尝试进行登录，验证失败*/
    14.     }
    15. }

    聾File类的理解

    java.io.File

    1、File类和四大家族没有关系，所以File类不能完成文件的读和写。

    2、File对象代表什么？

    文件和目录路径名的抽象表示形式。

    C:\Drivers 这是一个File对象

    C:\Drivers\Lan\Realtek\Readme.txt 也是File对象。

    一个File对象有可能对应的是目录，也可能是文件 ；File只是一个路径名的抽象表示形式； 不能通过File完成文件的读和写

    1.常用方法1

    （1） exists() 方法：判断当前文件是否存在

    （2） creatNewFile() 方法：以文件的形式创建出来

    （3） mkdir() 方法：以目录的形式创建出来； 创建多重目录mkdirs() 方法

    （4）获取当前文件的父路径：

    方法1： 使用 getParent() ，返回的是一个 String

    方法2：使用 getParentFile()

    ，返回的是一个

    File

    ；和上面效果是一样的

    （5） getAbsolutePath() 方法：获取当前文件的绝对路径

    1. "prettyprint hljs gradle" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto;">package com.bjpowernode.java.io;
    2.  
    3. import java.io.File;
    4.  
    5. public class FileTest01 {
    6.     public static void main(String[] args) throws Exception {
    7.         // 创建File对象
    8.         File f1 = new File("D:\\file");
    9.         // 1、判断当前文件是否存在；exists()方法
    10.         System.out.println(f1.exists()); // false
    11.  
    12.         // 2、如果D:\file不存在，则以文件的形式创建出来；createNewFile()方法
    13.         if (!f1.exists()) {
    14.             f1.createNewFile();
    15.         }
    16.  
    17.         // 3、如果D:\file不存在，则以目录的形式创建出来；mkdir()方法
    18.         if (!f1.exists()) {
    19.             f1.mkdir();
    20.         }
    21.  
    22.         // 4、创建多重目录；mkdirs()方法
    23.         File f2 = new File("D:/a/b/c/d");
    24.         if (!f2.exists()) {
    25.             f2.mkdirs();
    26.         }
    27.  
    28.         // 5、获取当前文件的父路径
    29.         File f3 = new File("D:\\python学习\\PyCharm Community Edition 2021.2.2");
    30.         // 第一种：使用getParent()，返回的是一个String
    31.         String parentPath = f3.getParent();
    32.         System.out.println(parentPath); // D:\python学习
    33.         // 第二种：使用getParentFile()，返回的是一个File；效果是一样的
    34.         File parentFile = f3.getParentFile();
    35.         System.out.println(parentFile); // D:\python学习
    36.  
    37.         // 6、获取当前文件的绝对路径
    38.         File f4 = new File("file");
    39.         System.out.println(f4.getAbsolutePath()); // C:\Users\86177\IdeaProjects\JavaSe1\file
    40.  
    41.     }
    42. }

    2.常用方法2

    （1） getName() ：获取当前文件的名字

    （2） isDirectory() ：判断是否是一个目录

    （3） isFile() ：判断是否是一个文件

    （4） lastModified() ：获取文件最后一次修改时间；得到的是毫秒数，返回long型

    （5） length() ：获取文件大小，结果是字节

    1. "prettyprint hljs gradle" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto;">package com.bjpowernode.java.io;
    2.  
    3. import java.io.File;
    4. import java.text.SimpleDateFormat;
    5. import java.util.Date;
    6.  
    7. public class FileTest02 {
    8.     public static void main(String[] args) {
    9.         File  f1 = new File("C:\\Java学习\\javaSE学习\\2.1JavaSE进阶笔记\\javase\\Copy02.java");
    10.         // 1、获取文件名，getName()方法
    11.         System.out.println("文件名:"+f1.getName()); // 文件名:Copy02.java
    12.  
    13.         // 2、判断是否是一个目录，isDirectory()方法
    14.         System.out.println(f1.isDirectory()); // false
    15.  
    16.         // 3、判断是否是一个文件，isFile()方法
    17.         System.out.println(f1.isFile()); // true
    18.  
    19.         // 4、获取文件最后一次修改时间，lastModified()方法
    20.         // 得到的是毫秒数
    21.         long modifytTime = f1.lastModified();
    22.         // 将总毫秒数转换成日期
    23.         Date date = new Date(modifytTime);
    24.         // 格式化
    25.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
    26.         System.out.println(sdf.format(date)); //2020-03-11 14:35:46 154
    27.  
    28.         // 5、获取文件大小，length()方法
    29.         System.out.println(f1.length()); //1490 字节
    30.  
    31.     }
    32. }

    3.listFiles方法

    File中的 listFiles方法 ； 获取当前目录下所有的子文件 ； 返回的是一个File[]数组

    1. "prettyprint hljs gradle" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto;">package com.bjpowernode.java.io;
    2.  
    3. import java.io.File;
    4.  
    5. public class FileTest03 {
    6.     public static void main(String[] args) {
    7.         File f = new File("C:\\Java学习\\javaSE学习\\2.1JavaSE进阶笔记\\javase\\chapter15\\src");
    8.         // 调用listFiles()方法，返回的是一个File[]数组
    9.         File[] files = f.listFiles();
    10.         // 用增强for循环打印
    11.         for(File file :files){
    12.             System.out.println(file.getAbsolutePath()); // 获取所有子目录的绝对路径
    13.             System.out.println(file.getName()); //获取所有子目录的文件名
    14.         }
    15.  
    16.     }
    17. }
  • 相关阅读:
    完美解决Django项目生成的requirements.txt文件不能使用的问题
    携手并进 | 云畅科技与华商智造院签署战略合作协议
    华为HCIP安全 VPN学习笔记 密码学基础：基本框架介绍
    计算机毕业设计ssm软件工匠p1rs1系统+程序+源码+lw+远程部署
    设计人工智能产品：技术可能性、用户合意性、商业可行性
    Element Plus中Cascader 级联选择器（选择任意一级选项 - 更改下拉框选中方式）
    AI问答-医疗：什么是“手术报台”
    TFA-Amino modifier CPG 500；TFA氨基改性剂CPG 500
    C++_跨平台编译_cmakefile中_添加内容
    Redis基础详解
  • 原文地址：https://blog.csdn.net/weixin_62421895/article/details/126174004