❣博主主页: 33的博客❣
▶️文章专栏分类:JavaEE◀️
🚚我的代码仓库: 33的代码仓库🚚
🫵🫵🫵关注我带你了解更多文件操作

1.前言

2.认识文件

操作系统中，会把硬盘设备和软件资源抽象为文件，但大多数情况下谈到文件就是指硬盘中的文件。
文件是以树型结构组织的：以此电脑为根节点的n叉树

文件路径：
如何在文件系统中描述一个文件的位置，因为从树型结构的角度来看，树中的每个结点都可以被一条从根开始，一直到达的结点的路径所描述，而这种描述方式就被称为文件的绝对路径（absolute path）。

除了使用绝路径来描述以外，还可以用相对路径来表示一个文件的位置

. 表示当前目录
. . 表示当前目录的上一级目录

文件类型：
二进制文件：文件是以二进制形式存储数据，不要求保存的内容是合法的字符
文本文件：文件是以纯文本形式存储数据，保存的内容都是合法的字符
判断一个文件是哪种类型，最简单的方式就是以文本的方式打开一个文件，观察是否出现乱码，如果乱码就是二进制文件否则为文本文件。
例如我打开一个图片：

3.文件操作

我们主要涉及文件的元信息、路径的操作，暂时不涉及关于文件中内容的读写操作。
Java 中通过 java.io.File 类来对一个文件（包括目录）进行抽象的描述。注意，有 File 对象，并不代表真实存在该文件。

3.1File 属性

路径中用来分割的符号，在Windows中’/‘或者’’

3.2构造方法

3.3File类方法

public static void main(String[] args) {
        File file=new File("d:/test");
        System.out.println(file.getName());//获取父目录纯文件名称
        System.out.println(file.getParent());//获取父目录路径
        System.out.println(file.getPath());//获取file的路径
        System.out.println(file.getAbsolutePath());//获取file的绝对路径
    }

public static void main(String[] args) throws IOException {
        File file=new File("d:/test/test.txt");
        System.out.println(file.exists());//判断file是否存在
        System.out.println(file.isDirectory());//判断file是否为目录
        System.out.println(file.isFile());//判断file是否为文件
        System.out.println("创建是否成功： "+file.createNewFile());//创建file对象
        System.out.println("删除是否成功： "+file.delete());//删除file

    }

public static void main(String[] args) {
        File file=new File("d:/test");
        String[] files=file.list();
        for (int i=0;i<files.length;i++){
            System.out.println(files[i]);
        }
    }

  public static void main(String[] args) {
        File file=new File("d:/test/DDD/ddd");
        //file.mkdir();//创建一个目录
        file.mkdirs();//可以创建中间目录
    }

4.文件内容操作

流对象：
字节流（二进制文件）：InputStream、OutStream
字符流（文本文件）：Reader、Writer

4.1Reader

public static void main(String[] args) throws IOException {
        //打开一个文件
        Reader reader=new FileReader("d:/test/test.txt");
        while (true){
            //一次read读取一个字符，返回当前字符的编码
            //int n=reader.read();
            //一次读取多个字符，返回读取的字符数
            char[] cbuf=new char[3];
            int n=reader.read(cbuf);
            //n=-1表示读取完毕
            if(n==-1){
                break;
            }
            System.out.println(n);
            System.out.print(Arrays.toString(cbuf));
            System.out.println();
        }
        //一个文件写完需要加close要记得，关闭资源
        reader.close();
    }

注意
在之前讲进程的时候，我们讲过进程的4大属性，其中一个就是文件描述符表（顺序表）。一个进程每次打开一个文件时，就需要在这个表中分配一个元素，但这个表的长度是有上限的。如果每次打开一个文件之后不去关闭文件，那么这个表就会被占满，后续如果继续打开文件，那么就会失败。我们就称这样的情况为文件泄露。
但如果一段代码在关闭文件之前就出现了异常就中断了。那么就不会执行到关闭文件操作，那么我们有什么方法改进呢？

 public static void main(String[] args) throws IOException {
        //打开一个文件
        Reader reader=new FileReader("d:/test/test.txt");
        try {
            while (true){
                //一次read读取一个字符，返回当前字符的编码
                //int n=reader.read();
                //一次读取多个字符，返回读取的字符数
                char[] cbuf=new char[3];
                int n=reader.read(cbuf);
                if(n==-1){
                    break;
                }
                System.out.println(n);
                System.out.print(Arrays.toString(cbuf));
                System.out.println();
            }
        }finally {
            //一个文件写完需要加close要记得
            reader.close();
        }
    }

无论try中的代码是否能正常执行，都能保证finally执行完毕。这样写虽然能够解决问题，可是不够优雅，我们在进一步改进：

public static void main(String[] args) throws IOException {
        //打开一个文件
        try (Reader reader=new FileReader("d:/test/test.txt")) {
            while (true) {
                //一次read读取一个字符，返回当前字符的编码
                //int n=reader.read();
                //一次读取多个字符，返回读取的字符数
                char[] cbuf = new char[3];
                int n = reader.read(cbuf);
                if (n == -1) {
                    break;
                }
                System.out.println(n);
                System.out.print(Arrays.toString(cbuf));
                System.out.println();
            }
        } 
    }

try with resour这个语法的目的就是（）定义的变量会在try代码块结束的时候，自动调用close方法。但（）定义的对象必须要实现closeable接口。
只要我们会使用reader其他=都是类似的使用规则

4.2writer

这里的写操作有多种：
write（int c）：一次写一个字符
write（String str）：一次写一个字符串
write（char[ ] cubf）：一次写多个字符
write（String str，int off ，int len）：从字符串的第off个而为之开始写

public static void main(String[] args) throws IOException {
        try (Writer writer=new FileWriter("d:/test/test.txt",true)){            
            //直接写会覆盖之前的内容，但加上append就不会覆盖
            writer.write("我在学习IO");
        }
    }

4.3inputStream

public static void main(String[] args) throws FileNotFoundException {
        try (InputStream inputStream=new FileInputStream("d:/test/AAA/test.txt")){
            while (true){
                byte[] bytes=new byte[1024];
                int n=inputStream.read(bytes);
                for (int i=0;i<n;i++){
                    System.out.println(bytes[i]);
                }
                if(n==-1)break;
            }

//字节流转换为字符流
            Scanner scanner=new Scanner(inputStream);
            String s=scanner.next();
            System.out.println(s);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

4.4OutputStream

public static void main(String[] args) {
        try (OutputStream outputStream = new FileOutputStream("d:/test/AAA/test.txt",true)) {
            String s="你好世界";
            outputStream.write(s.getBytes());
            outputStream.write(97);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

4.5字符流与字节流转换

输出转换：

 public static void main(String[] args) {
        try (InputStream inputStream=new FileInputStream("d:/test/AAA/test.txt")) {
            Scanner scanner=new Scanner(inputStream);
            String s=scanner.nextLine();
            System.out.println(s);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

输入转换：

 public static void main(String[] args) {
        try(OutputStream outputStream=new FileOutputStream("d:/test/AAA/test.txt")) {
            PrintWriter writer=new PrintWriter(outputStream);//先写入缓冲区
            writer.write("hello word");
            writer.flush();//记得要冲刷一下
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

5.应用

扫描指定目录，并找到名称中包含指定字符的所有普通文件（不包含目录），并且后续询问用户是否要
删除该文件

import java.io.File;
import java.util.Scanner;

//扫描指定目录，并找到名称中包含指定字符的所有普通文件（不包含目录），并且后续询问用户是否要删除该文件
public class Demo5 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入路径");
        String path=scanner.nextLine();
        File file=new File(path);
        if (!file.isDirectory()){
            System.out.println("输入有误");
            return;
        }
        System.out.println("请输入文件名");
        String words=scanner.nextLine();
        find(file,words);
    }

    private static void find(File file,String words) {

        File[] files= file.listFiles();
        if (files==null){
            return;
        }
        for (File f:files){
            System.out.println("当前正在扫描"+f.getAbsolutePath());
            if(f.isFile()){
                check(f,words);
            }else {
                find(f,words);
            }
        }
    }
    private static void check(File file, String words) {
        if (file.getName().contains(words)){
            System.out.println("确认是否要删除文件(y/n)"+file.getAbsolutePath());
            Scanner scanner=new Scanner(System.in);
            String x=scanner.nextLine();
            if (x.equals("y")){
                file.delete();
                System.out.println("删除成功");
            }else {
                return;
            }
        }else {
            return;
        }
    }
}

6.总结

本篇文章主要介绍了，文件操作，File 属性。构造方法，File类方法，文件内容操作，Reader，writer，inputStream，OutputStream，字符流与字节流转换等，同学们赶快练习起来吧！！

下期预告：网络编程