文件操作与IO(3) 文件内容的读写——数据流

tao滔不绝

已于 2024-03-05 20:37:02 修改

阅读量1.2k

点赞数 54

文章标签： java java-ee

于 2024-03-05 19:55:23 首次发布

本文链接：https://blog.csdn.net/cool_tao6/article/details/136433313

版权

3、在目录中搜索，但是按照文件内容的方式搜索（1和2的小结合）

一、流的概念

流是操作系统的概念，但是Java / C对其进行了封装；流类似水流，连绵不断、生生不息。

水流的特点：有100ml的水，我们可以每次接10ml，分10次接完，也可以分5ml，分20次接完，或者直接一次性100ml全部接完。

数据流的特点：类似水流，假设要读写100字节的数据，可以每次读写10字节的数据，分10次读写完，也可以每次读写5字节，分20次读写完，或者一次性读写完100字节的数据。

文件流：读写文件内容，读写文件内容在各种编程语言中，都是“固定套路”的。

1、打开文件

2、读/写文件

3、关闭文件

Java对流进行了一系列封装，提供了一组类来负责这些工作；针对这么多类，大体可以风味两种类

字节流：以字节为单位，每次最少读写一个字节。

字符流：以字符为单位，每次读写一个字符，比如 utf8 中的汉字，3个字节就是一个字符，每次最少都得读写3个字符。不能一次读写半个字符。

二、字节流代码演示

1、InputStream

从InputStream内部看，我们可以发现InputStream是抽象类，被abstract修饰，如图：

所以，不能实例化InputStream类，但我们可以创建FileInputStream对象，它是InputStream的子类，如图：

InputStream用完要记得关闭文件，可以理解成释放文件的相关资源，如图：

在进程中，PCB里面有文件描述符表，记录了当前进程都打开了哪些文件，这个文件描述符表是由数组 / 顺序表组成的，数组里面的每一个元素都代表着是一个结构体，里面包含了文件的一些属性，每打开一个文件，在文件描述符表就会被多占一个位置，而文件描述符表的资源是有限的，如果不关闭，当它被耗尽了，后续再打开文件就会失败，从而引发其他的逻辑出问题；而为啥不给文件描述符表满了就进行扩容操作？原因是这操作付出的代价很大：对于操作系统内核来说，要求的性能是很高的，内核任务也很重，而扩容本质也就是创造出新的更大规模的数组，把旧数组的数据移动到新数组中，其中工作量很大，如果进行扩容，对操作系统的来说，在内核任务很重的情况下，又要进行其他任务，就可能会导致操作系统卡顿现象，如果发生这种情况，就得不偿失了。

使用finally代码：

public class IODemo1 {
    public static void main(String[] args) throws IOException {
        InputStream inputStream = null;
        try {
            inputStream = new FileInputStream("./test.txt");
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        }finally {
            inputStream.close();
        }
    }
}

可以看到把inputStream放在try代码块外，其中因为finally最后要得到InputStream引用，要将其设为全局变量才能调用close方法；如果在try内代码块new对象，就是局部变量了，finally里找不到有inputStream的引用。

在java中，所以我们可以使用finally，但try还提供了另一个版本：try with resources，用法如下：

public class IODemo1 {
    public static void main(String[] args) throws FileNotFoundException {
        try(InputStream inputStream = new FileInputStream("./test.txt")){
            
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

也是和finally作用一样，无论咋样，都会执行InputStream.close。其中创建FileInputStream可能会有FileNotFoundException异常，因为IOException是FileNotFoundException的父类，所以可以直接像上面那样写，不用像下面这样写

read方法

read有三个不同参数的版本，如图：

第一个没有参数的版本：

每次只读一个字节，并且有返回值，上面显示的是int类型，其实是byte类型，返回的值是读到的该字节的值，范围是0~255，还有一个特殊的情况，如果返回值是-1，则说明读取到文本的末尾了，没有其他内容了。

以下是代码案例：

public class IODemo2 {
    public static void main(String[] args) {
        try(InputStream inputStream = new FileInputStream("./test.txt")) {
            while (true) {
                int n = inputStream.read();
                if(n == -1) {
                    break;
                }
                System.out.printf("%x ", n);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

test.txt的内容是abcdef，如图

代码运行结果如下：

而abcdef的ascll表16进制分别是以上结果。

第二个带有byte数组的版本：

如图，该数组是 “输出型参数”，byte[] 是引用类型，在方法内对数组进行修改，方法结束后，在方法外部仍然生效，本质是看针对 “引用类型修改”，还是针对 “解引用修改对象本体”。

以下是代码演示：

public class IODemo1 {
    public static void main(String[] args) {
        try(InputStream inputStream = new FileInputStream("./test.txt")){
            byte[] buffer = new byte[1024];
            while (true) {
                int n = inputStream.read(buffer);
                if(n == -1) {
                    break;
                }
                for (int i = 0; i < n; i++) {
                    System.out.printf("%x ", buffer[i]);
                }
            }
        }catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

上面代码是按照若干个字节读，而不是一个一个字节读，效率比第一个版本强，因为读文件本质是读硬盘，这个操作是比较耗时的，如果我们读若干个字节，放在内存了，然后要显示出来其内容的时候，是直接在内存访问已经读的若干个字节，要比读硬盘快。

而返回值是读了多少个字节，它读的时候，会尽可能把数组填满，但实际情况可能填不满，那就能填多少是多少。

执行结果如下：

如果我们想显示中文字符，如果像上面那样读，会读出中文字符的 utf8 的16进制值，要怎么搞，以下是代码演示：

public class IODemo2 {
    public static void main(String[] args) {
        try(InputStream inputStream = new FileInputStream("./test.txt")){
            while (true) {
                byte[] buffer = new byte[1024];
                int n = inputStream.read(buffer);
                if (n == -1) {
                    break;
                }
                String s = new String(buffer, 0, n);
                System.out.print(s);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

执行结果如下：

第三个版本

是写数组的一部分，其中off是偏移量，而不是开关，如图：

搭配Scanner的使用

我们想读文件的内容，也可以使用Scanner搭配InputStream使用。

Scanner（System.in），括号里面我们肯定都不陌生，这里的System.in本质就是InputStream，我们可以把System.in换成InputStream，下面是代码演示：

public class IODemo8 {
    public static void main(String[] args) {
        try(InputStream inputStream = new FileInputStream("./test.txt")) {
            Scanner scanner = new Scanner(inputStream);
            while (scanner.hasNext()) {
                String s = scanner.next();
                System.out.println(s);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

执行结果：

2、OutputStream

write方法

如图，下面是三个不同参数版本

第一个版本是一次写一个字节，第二个版本是一次写整个数组，第三个版本是写数组的一部分，它们的返回值都是void，返回空。

第一个版本：

代码如下：

public class IODemo4 {
    public static void main(String[] args) {
        try(OutputStream outputStream = new FileOutputStream("./test.txt")) {
            outputStream.write(97);
            outputStream.write(98);
            outputStream.write(99);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

执行结果：

因为一次写一个字节，97 98 99是abc的ASCII值，会把原来文件的内容删除，重新写入新的内容。

注意：就算没有调用write方法，执行代码后，也会删除指定文件的内容，除非创建FileOutputStream是，参数加true，才能追加写，如图：

执行下面代码：

public class IODemo4 {
    public static void main(String[] args) {
        try(OutputStream outputStream = new FileOutputStream("./test.txt", true)) {
            outputStream.write(97);
            outputStream.write(98);
            outputStream.write(99);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

结果如下：

之前原本有的abc还在，又追加写了abc。

第二个写入整个数组版本：

代码演示：

public class IODemo5 {
    public static void main(String[] args) {
        try(OutputStream outputStream = new FileOutputStream("./test.txt")) {
            byte[] buffer = {97, 98, 99, 100, 101, 102};
            outputStream.write(buffer);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

执行结果：

byte数组里面放的元素ASCII值是abcdef，放入数组就是写入数组里的内容，也可以追加写，加个true就行了。

第三个版本：

写数组的一部分，off是偏移量，不是开关。

三、字符流代码演示

Reader和Writer的使用方法，和字节流的InputStream和OutputStream基本差不多。

1、Reader

read方法

如图，下面是read方法几个不同参数的版本

和字节流读的不同，它是以char为单位进行读的，下面用带数组参数的版本演示，代码如下：

public class IODemo6 {
    public static void main(String[] args) {
        try(Reader reader = new FileReader("./test.txt")) {
            while (true) {
                char[] buffer = new char[1024];
                int n = reader.read(buffer);
                if(n == -1) {
                    break;
                }
                String s = new String(buffer, 0, n);
                System.out.println(s);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

执行结果：

这里有个细节问题，一个char类型有2个字节，而在utf8中，一个中文字符符占3个字节，存在char数组的值怎么打印出中文字符？

原因：在read的时候，每次读到的内容都会存进数组中，存进数组时，读到的内容是按unicode的值存进数组的，当这个数组放进String的构造方法时，会把unicode的值转回utf的值，这个过程是在java内部封装好了的，我们人为感知不到。

如果我们把数组内容一个一个读出来，代码如下：

public class IODemo6 {
    public static void main(String[] args) {
        try(Reader reader = new FileReader("./test.txt")) {
            while (true) {
                char[] buffer = new char[1024];
                int n = reader.read(buffer);
                if(n == -1) {
                    break;
                }
//                String s = new String(buffer, 0, n);
//                System.out.println(s);
                for(int i = 0; i < n; i++) {
                    System.out.print(buffer[i]);
                    System.out.print(" ");
                }
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

执行结果：

“你好你好”这一行就打印不出来了。

2、Writer

write方法

如果要追加写，就加个true

如图是write方法的几个版本：

主要使用带有String参数的版本，构造一个字符串，直接把字符串作为参数放进write方法中就可以写入那个字符串进文件中。以下是代码演示：

public class IODemo7 {
    public static void main(String[] args) {
        try(Writer writer = new FileWriter("./test.txt")) {
            String s = "你好";
            writer.write(s);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

执行结果：把你好写进文件中了。

四、三个小练习

以下是文件路径相关信息

这里需要使用到递归，是遍历一遍树，也就是所有的文件都要遍历一遍，看是否符合要求，这里不存在前中后遍历的情况，因为该树是N叉树。

1、查找硬盘上文件的位置

要求：给定一个文件名，去指定的目录中进行搜索，找到文件名匹配的结果，并打印出完整的路径。

代码演示：

//D:/desktop/file/javaEE/JavaEECode/test
public class IODemo9 {
    public static void main(String[] args) {
        //1、输入必要信息
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入要查找的文件");
        String fileName = scanner.next();
        System.out.println("请输入要搜索的目录");
        String rootPath = scanner.next();
        File file = new File(rootPath);
        //判断输入的目录是否合法
        if(!file.isDirectory()) {
            //不是目录
            System.out.println("输入的目录不合法");
            return;
        }
        //2、在目录下找我们给定文件名，看是否存在，使用递归的方式进行搜索
        scanDir(file, fileName);//知道递归的起点，还需要知道要查询的文件名
    }
    private static void scanDir(File rootFile, String  fileName) {
        //1、把所有子目录都列出来
        File[] files = rootFile.listFiles();
        //递归结束条件
        if(files == null) {
            //空目录，直接返回
            return;
        }
        //2、遍历files，判断每一个file文件是目录还是文件
        for(File f : files) {
            //记录日志
            System.out.println("当前遍历到："  + f.getAbsolutePath());
            //1、文件，判断文件名是不是要查找的文件名
            if(f.isFile()) {
                String name = f.getName();
                if(fileName.equals(name)) {
                    System.out.println("找到文件了，文件路径：" + f.getAbsolutePath());
                }
            } else if(f.isDirectory()) {
                //2、目录，继续往下递归
                scanDir(f, fileName);
            } else {
                // 这个 else 暂时不需要
            }
        }
    }
}

执行结果：

2、实现文件复制

要求：把一个文件复制一下，成为另一个文件。

意思就是把第一个文件以读方式打开，依次读取这里的每个字节，再读到的内容，写入到另一个文件中。

现有的文件：

复制cat.jpg文件，到cat2.jpg，因为没有cat2.jpg，所以执行代码后会多出cat2.jpg文件。

代码演示：

public class IODemo11 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入要复制的源文件");
        String srcFileName = scanner.next();
        System.out.println("请输入目标文件");
        String desFileName = scanner.next();

        File srcFile = new File(srcFileName);
        //判断源文件的合法性
        if(!srcFile.isFile()) {
            System.out.println("文件不合法");
            return;
        }
        File desFile = new File(desFileName);
        //判断目标文件的合法性，不要求文件存在，但要求文件路径存在
        if(!desFile.getParentFile().isDirectory()) {
            System.out.println("目标路径不合法");
            return;
        }
        //读取要复制文件的每个字节,把读到的每个字节都放到新的文件中
        try(InputStream srcInputStream = new FileInputStream(srcFile);
            OutputStream outputStream = new FileOutputStream(desFile)) {
            while (true) {
                byte[] buffer = new byte[1024];
                int n = srcInputStream.read(buffer);
                if(n == -1) {
                    break;
                }
                outputStream.write(buffer,0 ,n);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

输入内容：

执行结果：

多出了cat2.jpg文件。

3、在目录中搜索，但是按照文件内容的方式搜索（1和2的小结合）

用户输入一个目录，一个要搜索的词，遍历文件的过程中，如果文件包含了要搜索的词，此时就把文件的路径打印出来。

代码演示：

public class IODemo13 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入要搜索的词");
        String word = scanner.nextLine();
        System.out.println("请输入要搜索的路径");
        String rootPath = scanner.nextLine();

        File rootFile = new File(rootPath);
        //判断搜素路径是否合法
        if(!rootFile.isDirectory()) {
            System.out.println("输入的搜素路径不合法");
            return;
        }
        //遍历每一个文件，如果是普通文件，就判断文件内容里面有没有我们要搜索的词
        scanDir(rootFile, word);
    }
    private static void scanDir(File rootFile, String word) {
        //把当前目录都列出来
        File[] files = rootFile.listFiles();
        if(files == null) {
            return;
        }
        for(File f : files) {
            System.out.println("当前遍历到: " + f.getAbsolutePath());
            //是普通文件，判断文件内容里面有没有我们要搜索的词
            if(f.isFile()) {
                //把文件内容一个字节一个字节的读出来，构成字符串，在判断字符串里面有没有要搜索的词
                searchInFile(f, word);
            } else if(f.isDirectory()) {
                //是目录，继续递归
                scanDir(f, word);
            } else {
                //这个不需要处理
            }
        }
    }
    private static void searchInFile(File f, String word) {
        try(InputStream inputStream = new FileInputStream(f)) {
            StringBuilder stringBuilder = new StringBuilder();
            while (true) {
                byte[] buffer = new byte[1024];
                int n = inputStream.read(buffer);
                if(n == -1) {
                    break;
                }
                String s = new String(buffer, 0, n);
                stringBuilder.append(s);
            }
            //System.out.println("日志，当前读到文本的内容：" + stringBuilder);
            if(stringBuilder.indexOf(word) == -1) {
                //没有找到，直接return走
                return;
            }
            //文本内容存在要搜索的单词,打印出路径
            System.out.println("该文本存在要搜索的单词:" + word +" 存在于：" + f.getAbsolutePath());
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

文件内容如下：

代码输入如下：

执行结果：

都看到这了，点个赞再走吧，谢谢谢谢谢

tao滔不绝

关注

54
点赞
踩
41

收藏

觉得还不错? 一键收藏
打赏
19
评论
文件操作与IO(3) 文件内容的读写——数据流

在进程中，PCB里面有文件描述符表，记录了当前进程都打开了哪些文件，这个文件描述符表是由数组 / 顺序表组成的，数组里面的每一个元素都代表着是一个结构体，里面包含了文件的一些属性，每打开一个文件，在文件描述符表就会被多占一个位置，而文件描述符表的资源是有限的，如果不关闭，当它被耗尽了，后续再打开文件就会失败，从而引发其他的逻辑出问题；数据流的特点：类似水流，假设要读写100字节的数据，可以每次读写10字节的数据，分10次读写完，也可以每次读写5字节，分20次读写完，或者一次性读写完100字节的数据。
复制链接

扫一扫