• 文件操作和IO

     目录

    🥬文件

    🥬File类

    🌵异常

    🌵方法

    🥬文件读取操作

    🥬文件写入操作

     🥬案例

     🥬小结

    🥬文件

    文件的含义（狭义）：在Java中，我们一般谈到文件，都是指一个存储在磁盘上的文件。

    文件的含义（广义）：抛开Java，站在系统的角度来看，操作系统在管理很多软件资源和硬件设备的时候，把这些东西抽象成了一个一个的文件。（显示器/键盘/网卡……抽象成文件）这就是系统中典型的"一切皆文件"思想。

    狭义文件可以分成两个大类：

    1、普通文件

    2、目录文件（文件夹，就是打开这个目录文件，里面还有许多文件）

    广义文件：

    在Java中为了方便我们操作文件，标准库给出了一个File类，因此我们可以通过Fire类来进行操作。

    🥬File类

    构造方法：

    1. File(File parent, String child) //根据父目录 + 孩子文件路径，创建一个新的 File 实例
    2. File(String pathname) //根据文件路径创建一个新的 File 实例，路径可以是绝对路径或者相对路径
    3. File(String parent, String child) //根据父目录 + 孩子文件路径，创建一个新的 File 实例，父目录用//路径表示

    我们比较常用的是第二种：

    File(String pathname) //根据文件路径创建一个新的 File 实例，路径可以是绝对路径或者相对路径

    这里给File传递一个具体的路径，通过路径来指定唯一的一个文件（普通文件或者目录文件）

    比如：

    File file=new File("D:/test.txt");

    这里通过 \  或者 /  来分隔不同层级的目录，一般我们会比较偏向使用 /  ，防止 \  +其他字符被当成转义字符。

    绝对路径和相对路径

    绝对路径：D:\idea project\lianxi\test\src，以一个盘符开头的路径（比如这里的D：就是盘符）。

    相对路径：一般以. 或者..  开头，以工作目录为基准，去找相对应的路径。如果以D:\idea project\lianxi\test\src为基准目录，此时要表示src中的FileDemo1.java，相对路径就可以写作 .\FileDemo1.java，此时.就表示当前的基准目录D:\idea project\lianxi\test\src。

    基准目录：D:\idea project\lianxi\test\src

    表示src中的FileDemo1.java

    相对路径：.\FileDemo1.java

    基准目录：D:\idea project\lianxi\test\src\test.java

    表示src中的FileDemo1.java

    相对路径：..\FileDemo1.java（..表示当前目录的上级目录）

    1. public static void main(String[] args) throws IOException {
    2.         // 这种既没有盘符, 也没有 ./ 和 ../ 的, 这个也是相对路径
    3.         // 相当于省略了 ./
    4.         File file = new File("helloworld.txt");
    5.         //因为此时没有这个文件，我们无法打开，所以我们需要创建这个文件
    6.         file.createNewFile();
    7.         //判断此文件是否存在
    8.         System.out.println(file.exists());
    9.         //判断是否是文件
    10.         System.out.println(file.isFile());
    11.         //判断是否是目录文件
    12.         System.out.println(file.isDirectory());
    13.         //删除文件
    14.         System.out.println(file.delete());
    15.     }

    🌵异常

    throws IOException

    在一些访问IO操作的时候，比如读写文件，操作文件都有可能涉及到这个异常，这个异常是一个受查异常，在使用的时候一定要显示处理，可以使用throws或者try catch来显示捕获。

    创建文件时为什么会抛异常？

    1、没有权限

    2、磁盘空间不够

    文件系统中的权限，典型的就是读和写，会针对不同的用户，给与不同的权限。

    🌵方法

    1. 返回值类型
    2. String   getParent()   返回 File 对象的父目录文件路径
    3.  
    4. String   getName()     返回 File 对象的纯文件名称
    5.  
    6. String   getPath()     返回 File 对象的文件路径
    7.  
    8. String   getAbsolutePath()   返回 File 对象的绝对路径
    9.  
    10. String   getCanonicalPath()  返回 File 对象的修饰过的绝对路径（该省略的省略）
    11.  
    12. boolean   exists()            判断 File 对象描述的文件是否真实存在
    13.  
    14. boolean   isDirectory()    判断 File 对象代表的文件是否是一个目录
    15.  
    16. boolean   isFile()         判断 File 对象代表的文件是否是一个普通文件
    17.  
    18. boolean   createNewFile()   根据 File 对象，自动创建一个空文件。成功创建后返回 true
    19.  
    20. boolean   delete()   根据 File 对象，删除该文件。成功删除后返回 true
    21.  
    22. void   deleteOnExit()   根据 File 对象，标注文件将被删除，删除动作会到JVM 运行结束时才会进行
    23.  
    24. String[]   list()   返回 File 对象代表的目录下的所有文件名
    25.  
    26. File[]   listFiles()   返回 File 对象代表的目录下的所有文件，以 File 对象表示
    27.  
    28. boolean   mkdir()   创建 File 对象代表的目录
    29.  
    30. boolean   mkdirs()   创建 File 对象代表的目录，如果必要，会创建中间目录
    31. boolean   renameTo(File dest)   进行文件改名，也可以视为我们平时的剪切、粘贴操作
    32. boolean   canRead()    判断用户是否对文件有可读权限
    33. boolean   canWrite()    判断用户是否对文件有可写权限

     多级目录的创建：

    1. public static void main(String[] args) {
    2.         File file = new File("test/aaa/bbb");
    3.         System.out.println(file.exists());
    4.         // mk 就是 make . dir 就是 direction 单词的缩写.
    5.         // mkdir 不支持创建多级目录. 但是 mkdirs 能支持.
    6.         file.mkdirs();
    7.         System.out.println(file.exists());
    8.         System.out.println(file.isDirectory());
    9.     }

    移动文件：

    1. public static void main(String[] args) {
    2.         File file = new File("./test.txt");
    3.         File file2 = new File("./out/test.txt");
    4.         file.renameTo(file2);
    5.     }

     renameTo除了可以移动文件位置之外，还可以更改文件名。所谓的文件移动（剪切粘贴），对于操作系统而言，每个文件都有自己的属性，这个属性就是文件的路径，移动操作其实就是修改文件的属性。

     

    file. deleteOnExit()，主要用于一些"临时文件"，意思就是这个临时文件关闭之后就自动删除了。

    就比如我们使用word的时候，打开文件的时候，系统会自动生成一个临时的隐藏文件，如果此时电脑突然掉电，此时临时文件来不及删除，下次启动的时候，office就会自动监测到当前的临时文件存在，于是就能知道上次是异常结束，就会提示用户是否要恢复数据。

    面试题：给你一个list方法，如何遍历一个目录中所有的文件？

    首先我们来看看list怎么使用？

    代码实现：

    1. public class FileDemo4 {
    2.     //通过递归的方式，来罗列出制定目录中所有的文件路径
    3.     public static List result=new ArrayList<>();
    4.     public static void main(String[] args) {
    5.         getAllFiles(".");
    6.         for (String s : result) {
    7.             System.out.println(s);
    8.         }
    9.     }
    10.     public static void getAllFiles(String basePath){
    11.         File file=new File(basePath);
    12.         //如果是普通文件，就直接添加到result中
    13.         if(file.isFile()){
    14.             result.add(basePath);
    15.             //如果是目录文件，则递归，添加每个子目录中的文件
    16.         }else if(file.isDirectory()){
    17.             String[] files=file.list();
    18.             for(String f:files){
    19.                 getAllFiles(basePath+"/"+f);
    20.             }
    21.         }
    22.     }
    23. }

    🥬文件读取操作

    InputStream/FileInputStream：文件读取操作，按照字节为单位进行读文件

    代码示例：

    1. public static void main(String[] args) {
    2.         InputStream inputStream=null;
    3.         try {
    4.             inputStream =new FileInputStream("./test.txt");
    5.             while(true){
    6.                 //逐个字节的方式把文件内容读取出来，每次调用read就可以读取一些数据出来
    7.                 //read的无参版本就是一次读取一个字节
    8.                 //read返回值就是这次操作读到的字节，这个结果的范围是0-255
    9.                 //如果读到文件末尾（EOF，end of file），此时继续read，就会返回-1
    10.                 int b=inputStream.read();
    11.                 if(b==-1){
    12.                     //读取完成
    13.                     break;
    14.                 }
    15.                 System.out.printf("%c",b);
    16.             }
    17.         } catch (IOException e) {
    18.             e.printStackTrace();
    19.         }finally {
    20.             try{
    21.                 //用完记得关闭，防止资源泄露
    22.                 inputStream.close();
    23.             }catch(IOException e){
    24.                 e.printStackTrace();
    25.             }
    26.         }
    27.     }

    此时我们这里使用try catch来捕获异常，同时使用finally来关闭文件（使用流对象，读写文件之后，一定要记得关闭，如果没有关闭，就可能造成资源泄露），但是可以发现finally里面还包含一个try catch，看起来比较繁琐，此时我们使用try with resources语法，可以更好解决这个问题

    1. public static void main(String[] args) {
    2.         try(InputStream inputStream=new FileInputStream("./test.txt")){
    3.             while(true){
    4.             int b=inputStream.read();
    5.               if(b==-1){
    6.                   break;
    7.               }
    8.                 System.out.printf("%c",b);
    9.             }
    10.         }catch(IOException e){
    11.             e.printStackTrace();
    12.         }
    13. }

    把文件的打开放try（）里面，try catch执行完毕之后，会自动将文件关闭 。

    带参数的read：

    1. public static void main(String[] args) {
    2.         try (InputStream inputStream = new FileInputStream("./test.txt")) {
    3.             //一次读取1024个字节
    4.             byte[] buffer = new byte[1024];
    5.             while (true) {
    6.                 int len = inputStream.read(buffer);
    7.                 if (len == -1) {
    8.                     break;
    9.                 }
    10.                 //中文和英文的编码方式不同，英文直接就是ASCII码，中文就需要使用UTF-8或者GBK
    11.                 //一个汉字在UTF-8中，是由3个字节构成的
    12.                 for (int i = 0; i < len; i += 3) {
    13.                     String s = new String(buffer, i, 3, "UTF-8");
    14.                     System.out.print(s);
    15.                 }
    16.             }
    17.         } catch (IOException e) {
    18.             e.printStackTrace();
    19.         }
    20.     }

    这里不仅可以用read来读取文件，也可以用Scanner，Scanner内部持有的InputStream是标准输入，标准输入的这个文件，一般是不关闭的，这个文件是每个进程创建出来之后，操作系统默认打开的文件。

    1. public static void main(String[] args) {
    2.         // 尝试从文件中读取出中文. 借助标准库中内置的处理字符集的方式.
    3.         // Scanner 不光能从控制台读取标准输入, 也可以从文件中读取数据.
    4.         try (InputStream inputStream = new FileInputStream("./test.txt")) {
    5.             // Scanner 里面也有个 close 方法, 这个 close 其实也就是用来关闭 Scanner 内包含的 InputStream
    6.             try (Scanner scanner = new Scanner(inputStream, "UTF-8")) {
    7.                 while (scanner.hasNext()) {
    8.                     String s = scanner.next();
    9.                     System.out.print(s);
    10.                 }
    11.             }
    12.         } catch (IOException e) {
    13.             e.printStackTrace();
    14.         }
    15.     }

    🥬文件写入操作

    OutputStream/FileOutputStream：文件写入操作，按照字节为单位进行写文件。

    例如：按照字节写入：

    1.  public static void main(String[] args) {
    2.         // 一旦按照 OutputStream 的方式打开文件, 就会把文件的原来的内容给清空掉.
    3.         try (OutputStream outputStream = new FileOutputStream("./test.txt")){
    4.             // 写入一个字符
    5.             // outputStream.write('x');
    6.             // 按照字节来写入
    7.             byte[] buffer = new byte[] {
    8.                (byte)'a', (byte)'b', (byte)'c', (byte)'d'
    9.             };
    10.             outputStream.write(buffer);
    11.         } catch (IOException e) {
    12.             e.printStackTrace();
    13.         }
    14.     }

    按照字符串写入：

    1. public static void main(String[] args) {
    2.         // 一旦按照 OutputStream 的方式打开文件, 就会把文件的原来的内容给清空掉.
    3.         try (OutputStream outputStream = new FileOutputStream("./test.txt")){
    4.             // 按照字符串来写入
    5.             String s = "hello world";
    6.             outputStream.write(s.getBytes());
    7.         } catch (IOException e) {
    8.             e.printStackTrace();
    9.         }
    10.     }

    包装之后写入：

    1. public static void main(String[] args) {
    2.         // 使用 PrintWriter 类来包装一下 OutputStream 然后可以更方便的进行写数据.
    3.         try (OutputStream outputStream = new FileOutputStream("./test.txt")) {
    4.             // 使用 PrintWriter 类来包装一下
    5.             try (PrintWriter writer = new PrintWriter(outputStream)) {
    6.                 writer.println("你好世界");
    7.             }
    8.         } catch (IOException e) {
    9.             e.printStackTrace();
    10.         }
    11.     }

    以上几种写入都会覆盖原有内容，以下不会覆盖

    1. public static void main(String[] args) {
    2.         String content="你好，世界";
    3.         try(FileWriter fileWriter=new FileWriter("test.txt",true)){
    4.             fileWriter.write(content);
    5.         }catch (IOException e){
    6.             e.printStackTrace();
    7.         }
    8.     }

    就是第二个参数写成true，这个参数代表是否覆盖原有内容，默认为false。

    刷新缓冲区：flush（）

    计算机读写内存的速度比读写磁盘的速度快的多，所以有些时候为了提高效率，可以使用缓冲区，可以减少直接访问磁盘的次数。

    缓冲区其实就是一段内存空间（这个内存是OutputStream里面自带的），当我们使用write方法来写数据的时候，并不是直接把数据写入磁盘，而是先放到缓冲区中，如果缓冲区满了，或者手动调用flush，才会真的把数据写到磁盘上。（内存和磁盘之间的缓冲区，往往是一个内存空间）

     🥬案例

    1、指定一个目录，扫描这个目录，找到文件名中包含了指定字符的文件，并提示用户是否要删除这个文件，根据用户的输入决定是否要删除

    1. public static void main(String[] args) throws IOException {
    2.         //1、输入待扫描的目录和查询关键词
    3.         System.out.println("请输入需要扫描的根目录（绝对路径");
    4.         Scanner scanner=new Scanner(System.in);
    5.         String root=scanner.next();
    6.         File rootDir=new File(root);
    7.         if(!rootDir.isDirectory()){
    8.             System.out.println("您输入的路径错误！程序直接退出");
    9.             return;
    10.         }
    11.         System.out.println("请输入要查找的文件名中包含的关键词");
    12.         String token=scanner.next();
    13.         //2、递归遍历目录
    14.         //result表示递归的结果，就包含带着所有token关键词的文件名
    15.         List result=new ArrayList<>();
    16.         scanDir(rootDir,token,result);
    17.  
    18.         //3、遍历result，问用户是否要删除
    19.         for(File f:result){
    20.             System.out.println(f.getCanonicalPath()+" 是否要删除(Y/N)");
    21.             String input=scanner.next();
    22.             if(input.equals("Y")){
    23.                 f.delete();
    24.             }
    25.         }
    26.     }
    27.  
    28.     private static void scanDir(File rootDir, String token, List result) throws IOException {
    29.         File[] files=rootDir.listFiles();
    30.         //list返回的是一个文件名（String），使用listFiles直接返回File对象
    31.         if(files==null || files.length==0){
    32.             return;
    33.         }
    34.         for(File f:files){
    35.             if(f.isDirectory()){
    36.                 scanDir(f,token,result);
    37.             }else{
    38.                 if(f.getName().contains(token)){
    39.                     result.add(f.getCanonicalFile());
    40.                 }
    41.             }
    42.         }
    43.     }

    2、复制一个文件，启动程序之后，让用户输入一个文件的路径（绝对路径），要求这个文件是一个普通文件（不是目录文件），然后在指定一个要复制过去的目标目录

    1. public static void main(String[] args) {
    2.         //进行文件复制
    3.         Scanner scanner=new Scanner(System.in);
    4.         System.out.println("请输入需要复制的文件(绝对路径)：");
    5.         String srcPath= scanner.next();
    6.         //打开此文件
    7.         File srcFile=new File(srcPath);
    8.         if(!srcFile.isFile()){
    9.             System.out.println("文件路径错误！程序直接退出");
    10.             return;
    11.         }
    12.         System.out.println("请输入要复制到的目标路径(绝对路径)：");
    13.         String destPath=scanner.next();
    14.         File destFile=new File(destPath);
    15.         //如果destFile已经存在，就不进行复制
    16.         if(destFile.exists()){
    17.             System.out.println("目标文件的路径已经存在！程序直接退出");
    18.             return;
    19.         }
    20.         if(!destFile.getParentFile().exists()){
    21.             //如果目标文件的父级目录不存在，也提示报错
    22.             System.out.println("目标文件的父目录不存在！程序直接退出");
    23.             return;
    24.         }
    25.         //具体进行复制操作
    26.         //打开需要复制的文件，按字节读取，目标文件按字节写入
    27.         try(InputStream inputStream=new FileInputStream(srcFile)){
    28.             OutputStream outputStream=new FileOutputStream(destFile);
    29.             while(true){
    30.                 byte[] buffer=new byte[1024];
    31.                 int len=inputStream.read(buffer);
    32.                 if(len==-1){
    33.                    break;
    34.                 }
    35.                 outputStream.write(buffer,0,len);
    36.             }
    37.             //加flush触发close(其实这里不加也能触发，加了比较好)
    38.             outputStream.flush();
    39.         }catch (IOException e){
    40.             e.printStackTrace();
    41.         }
    42.     }

    什么样的类可以放进try（）中呢？实现Closeable接口的类。

    3、在指定目录中按照文件内容查找，看看是否包含匹配的结果

    1. public static void main(String[] args) throws IOException {
    2.         Scanner scanner=new Scanner(System.in);
    3.         //1、输入一个代搜索的路径
    4.         System.out.println("请输入要扫描的根目录：");
    5.         String rootDir=scanner.next();
    6.         File rootFile=new File(rootDir);
    7.         if(!rootFile.isDirectory()){
    8.             System.out.println("该目录不存在或者不是文件!程序直接退出");
    9.             return;
    10.         }
    11.         //2、输入查询词
    12.         System.out.println("请输入要查询的词:");
    13.         String query=scanner.next();
    14.         //3、遍历目录以及文件，进行匹配
    15.         List result=new ArrayList<>();
    16.         scanDirWithContent(rootFile,query,result);
    17.         //4、把结果打印出来
    18.         for(File f:result){
    19.             System.out.println(f.getCanonicalPath());
    20.         }
    21.     }
    22.  
    23.     private static void scanDirWithContent(File rootFile, String query, List result) {
    24.         File[] files=rootFile.listFiles();
    25.         if(files==null || files.length==0){
    26.             return;
    27.         }
    28.         for(File f:files){
    29.             if(f.isDirectory()){
    30.                 scanDirWithContent(f,query,result);
    31.             }else{
    32.                 if(f.getName().contains(query)){
    33.                     //看看文件名称中是否包含
    34.                     result.add(f);
    35.                     //看看文件内容是否包含
    36.                 }else if(isContentContains(f, query)){
    37.                     result.add(f);
    38.                 }
    39.  
    40.             }
    41.         }
    42.     }
    43.  
    44.     private static boolean isContentContains(File f, String query) {
    45.         //打开f这个文件，依次读取每一行结果，去和query匹配(indexOf)
    46.         StringBuilder stringBuilder=new StringBuilder();
    47.         try(InputStream inputStream=new FileInputStream(f)){
    48.             Scanner scanner=new Scanner(inputStream,"UTF-8");
    49.             while(scanner.hasNextLine()){
    50.                 String line=scanner.nextLine();
    51.                 stringBuilder.append(line+"\n");
    52.             }
    53.         }catch (IOException e){
    54.             e.printStackTrace();
    55.         }
    56.         //只要结果不等于-1，就说明查到了
    57.         return stringBuilder.indexOf(query)!=-1;
    58.     }

     🥬小结

    以上就是今天的内容，有什么问题都可以在评论区留言🍉🍉🍉

  • 相关阅读:
    基于蜻蜓优化算法的认知无线电网络的服务质量研究附Matlab代码
    spring的学习【3】
    【WSL】单机大模型前的基础环境配置
    linux性能分析(三)查看系统的性能指标
    学点设计模式，盘点Spring等源码中与设计模式的那些事之行为型模型
    CPP emplace_bake 和 push_back 的相同和区别
    Idea热部署插件（JRebel for IntelliJ）激活（适用于内网、外网激活）
    PanTools v1.0.27 多网盘批量管理、遍历分享、转存、重命名、复制...
    项目管理工具DHTMLX Gantt灯箱元素配置教程：文本区域控件设置
    Jetpack组件（二）不推荐使用的DataBinding
  • 原文地址：https://blog.csdn.net/m0_65673419/article/details/126192000