【JavaEE -- 文件操作IO有关面试题】

文件操作IO有关面试题

• 1.查找硬盘上的文件位置
• • [1.1 思路](#1.1 思路)
  • [1.2 执行代码](#1.2 执行代码)
• [2. 实现文件复制](#2. 实现文件复制)
• • [2.1 思路](#2.1 思路)
  • [2.2 代码执行](#2.2 代码执行)
• [3. 打印搜索的词的文件路径](#3. 打印搜索的词的文件路径)
• • [3.1 思路](#3.1 思路)
  • [3.2 代码执行](#3.2 代码执行)

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

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

1.1 思路

文件系统的目录结构是 树形 结构，针对树的遍历，要递归进行实现，而这里目录中有几个子目录，就递归几次。此处是N叉树，并且每个节点上也有很多文件。

1. 输入必要的信息，引用Scanner进行接收文件名和目录。
2. 进行路径合法性判断
3. 有了要搜索的路径之后，就可以按照递归的方式来搜索。
4. 在递归中，1）要使用 listFiles() 把当前目录的文件和子文件都列出来
   2）遍历所有文件，判定每个file是目录还是文件
   3）普通文件，判定是否是要搜索的文件，不是就接着递归

1.2 执行代码

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

public class IODemo13 {
    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 rootFile = new File(rootPath);
        if (!rootFile.isDirectory()) {
            System.out.println("输入的路径有误");
            return;
        }

        // 2. 有了要搜索的路径之后，就可以按照，递归的方式来搜索
        scanDir(rootFile,fileName);
    }

    private static void scanDir(File rootFile, String fileName) {
        // 把当前目录的文件和子文件都列出来
        File[] files = rootFile.listFiles();
        if (files == null) {
            // 空的目录，直接返回
            return;
        }
        // 2.遍历上述files，判定每一个file是目录还是
        for (File f : files) {
            System.out.println("当前遍历到：" + f.getAbsolutePath());
            if (f.isFile()) {
                // 普通文件，评定文件名是否是搜索的文件
                if (fileName.equals(f.getName())) {
                    System.out.println("找到符合要求的文件！" + f.getAbsolutePath());
                }
            } else if (f.isDirectory()) {
                // 是目录，接着递归
                scanDir(f,fileName);
            } else {
                ;
            }
        }
    }
}

2. 实现文件复制

把一个文件复制一下，成为另外一个文件。

2.1 思路

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

1. 输入必要信息（源文件路径和目标文件路径）
2. 合法性判断（源文件路径的文件是否存在，目标文件目录是否正确）
3. 复制操作（读文件然后进行写文件到另外一个文件）

2.2 代码执行

public class IODemo14 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你要复制的源文件：");
        String srcPath = scanner.next();
        System.out.println("请输入你要复制过去的目标文件：");
        String destPath = scanner.next();

        // 合法性判断
        // 1. srcPath 对应的文件是否存在
        File srcFile = new File(srcPath);
        if (!srcFile.isFile()) {
            System.out.println("输入的源文件有误");
            return;
        }

        // 2.destPath 不要求对应的文件存在，但是目录得存在
        File destFile = new File(destPath);
        if (!destFile.getParentFile().isDirectory()) {
            System.out.println("目标文件目录有误");
            return;
        }

        // 复制操作
        // try()里面可以写多个对象定义，用 ; 隔开就好
        try (InputStream inputStream = new FileInputStream(srcFile);
        OutputStream outputStream  = new FileOutputStream(destFile)) {
            while (true) {
                byte[] buffer = new byte[1024];
                int n = inputStream.read(buffer);
                if (n == -1) {
                    break;
                }

                //
                outputStream.write(buffer,0,n);
            }

        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

3. 打印搜索的词的文件路径

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

3.1 思路

1. 输入搜索的路径和词并判断路径是否合法
2. 路径合法进行递归寻找匹配的词
3. 遍历文件，如果文件存在，进行搜索，如果是目录，接着递归。
4. 搜索思路：1）把文件的内容全部读取出来，用StringBuilder中的append方法进行拼接
   2）当文件读取完毕，循环结束之后，此时StringBuilder就是包含整个内容的字符串了
   3）使用StringBuilder中的indexOf（word）如果为-1，那就是遍历完了没找到，找到了获取路径

3.2 代码执行

import java.io.*;
import java.util.Scanner;


/**在目录中搜索，按照文件内容的方式搜索
    用户输入一个目录，一个要搜索的词
    遍历文件的过程，如果文件包含了要搜索的词(这个匹配过程，就需要把文件内容读取出来，再在文件内容中进行查找)，
    此时就把文件的路径打印出来
*/
 public class IODemo15 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入要搜索的路径：");
        String rootPath = scanner.next();
        System.out.println("请输入要搜索的词");
        String word = scanner.next();

        File rootFile = new File(rootPath);
        if (!rootFile.isDirectory()) {
            System.out.println("输入的搜索路径不正确");
            return;
        }

        scanDir2(rootFile,word);
    }

    private static void scanDir2(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()) {
                scanDir2(f,word);
            }else {
                ;
            }
        }
    }

    private static void searchInFile(File f, String word) {
        // 通过这个方法在文件内部进行搜索
        // 1. 把文件里的内容全部读取出来
        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);
            }

            // 测试，查看stringBuilder内容
            System.out.println("[debug] 文件内容：" + stringBuilder);

            // 当文件读取完毕，循环结束之后，此时stringBulider就是包含整个内容的字符串了
            if (stringBuilder.indexOf(word) == -1) {
                // 没找到
                return;
            }
            // 找到了，打印文件的路径
            System.out.println("word存在的文件路径：" + f.getAbsolutePath());
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}