Java中文件读写操作与常用技巧分享

// 指定一个完整路径，获取文件对象
File file = new File("D:\\Files\\test.txt");
System.out.println(file1.getName());
// 指定一个父文件路径和子文件名称，获取文件对象
File file = new File("D:\\Files", "test.txt");
System.out.println(file2.getName());

public static void main(String[] args) throws Exception {
    // 指定一个文件完整路径，获取文件对象
    File file = new File("D:\\Files\\test.txt");
    // 获取文件父节点目录对象
    File parentFile = file.getParentFile();
    // 判断指定路径的文件目录是否存在
    if(parentFile.exists()){
        System.out.println("文件目录存在");
    } else {
        // 创建文件夹，可以自动创建多级文件夹
        parentFile.mkdirs();
        System.out.println("文件目录不存在，创建一个文件目录");
    }
    // 判断指定父节点路径的是否是一个目录
    if(parentFile.isDirectory()){
        System.out.println("父节点路径是一个目录");
    }
    // 判断指定路径的文件是否存在
    if(file.exists()){
        System.out.println("文件存在");
    } else {
        // 创建文件
        file.createNewFile();
        System.out.println("文件不存在，创建一个文件");
    }
    // 获取目录下的所有文件/文件夹（仅该层路径下）
    File[] files = parentFile.listFiles();
    System.out.print("路径下有文件：");
    for (File f : files) {
        System.out.print(f + "；");
    }
    System.out.println();
    // 获取文件名、文件夹名
    System.out.println("files[0]的文件名：" + files[0].getName());
    // 获取文件、文件夹路径
    System.out.println("files[0]的文件路径：" + files[0].getPath());
    // 获取文件、文件夹绝对路径
    System.out.println("files[0]的绝对路径：" + files[0].getAbsolutePath());
    // 获取文件父目录路径
    System.out.println("files[0]的父文件夹名：" + files[0].getParent());
    // 判断文件、文件夹是否存在
    System.out.println(files[0].exists() ? "files[0]的存在" : "files[0]的不存在");
    // 判断文件是否可写
    System.out.println(files[0].canWrite() ? "files[0]的可写" : "files[0]的不可写");
    // 判断文件是否可读
    System.out.println(files[0].canRead() ? "files[0]的可读" : "files[0]的不可读");
    // 判断文件是否可执行
    System.out.println(files[0].canExecute() ? "file[0]可执行" : "file[0]不可执行");
    // 判断文件、文件夹是不是目录
    System.out.println(files[0].isDirectory() ? "files[0]的是目录" : "files[0]的不是目录");
    // 判断拿文件、文件夹是不是标准文件
    System.out.println(files[0].isFile() ? "files[0]的是文件" : "files[0]的不是文件");
    // 判断路径名是不是绝对路径
    System.out.println(files[0].isAbsolute() ? "files[0]的路径名是绝对路径" : "files[0]的路径名不是绝对路径");
    // 获取文件、文件夹上一次修改时间
    System.out.println("files[0]的最后修改时间：" + files[0].lastModified());
    // 获取文件的字节数，如果是一个文件夹则这个值为0
    System.out.println("files[0]的大小：" + files[0].length() + " Bytes");
    // 获取文件路径URI后的路径名
    System.out.println("files[0]的路径转换为URI：" + files[0].toURI());
    // 下面的代码逻辑，假设目录下有3个以上文件
    // 对文件重命名
    File newfile = new File(file.getParentFile(), "22.txt");  //新的文件名称
    files[0].renameTo(newfile);
    // 删除指定的文件、文件夹
    files[1].delete();
    // 当虚拟机终止时删除指定的文件、文件夹
    files[2].deleteOnExit();
}

// windows 系统下的文件绝对路径定义方式
String path = "d:"+File.separator +"Files"+File.separator+"text.txt";
File file = new File(path);

// 创建一个 readWriteDemo.txt 文件
File file = new File("readWriteDemo.txt");
if(!file.exists()){
    file.createNewFile();
}
// 向文件中写入数据(这种方式会覆盖原始数据)
OutputStream outputStream = new FileOutputStream(file);
String str = "我们一起学习Java";
outputStream.write(str.getBytes(StandardCharsets.UTF_8));
outputStream.close();

// 追加数据写入(这种方式不会覆盖原始数据)
OutputStream appendOutputStream = new FileOutputStream(file, true);
String str = "-----这是追加的内容------";
appendOutputStream.write(str.getBytes(StandardCharsets.UTF_8));
appendOutputStream.close();

// 获取 readWriteDemo.txt 文件
File file = new File("readWriteDemo.txt");
if(file.exists()){
    // 获取文件流
    InputStream input = new FileInputStream(file);
    // 临时区
    byte[] buffer = new byte[1024];
    // 分次读取数据，每次最多读取1024个字节，将数据读取到临时区之中，同时返回读取的字节个数，如果遇到文件末尾，会返回-1
    int len;
    while ((len = input.read(buffer)) > -1) {
        // 字节转为字符串
        String msg = new String(buffer, 0, len, StandardCharsets.UTF_8);
        System.out.println(msg);
    }
    // 数据读取完毕之后，关闭输入流
    input.close();
}

// 创建一个 newReadWriteDemo.txt 文件
File file = new File("newReadWriteDemo.txt");
if(!file.exists()){
    file.createNewFile();
}
// 实例化Writer类对象
Writer out = new FileWriter(file) ;
// 输出字符串
out.write("Hello");
// 输出换行
out.write("\n");
// 追加信息，append 方法底层本质调用的是 write 方法
out.append("我们一起来学习Java");
// 关闭输出流
out.close();

// 创建一个 newReadWriteDemo.txt 文件
File file = new File("newReadWriteDemo.txt");
if(file.exists()){
    // 实例化输入流
    Reader reader = new FileReader(file);
    // 临时区
    char[] buffer = new char[1024];
    // 分次读取数据，每次最多读取1024个字符，将数据读取到临时区之中，同时返回读取的字节个数，如果遇到文件末尾，会返回-1
    int len;
    while ((len = reader.read(buffer)) > -1) {
        // 字符转为字符串
        String msg = new String(buffer, 0, len);
        System.out.println(msg);
    }
    // 关闭输入流
    reader.close();
}

// 1. 创建一个字节数组作为数据读取的临时区
byte[] buffer = new byte[1024];
// 2. 创建一个 FileInputStream 对象用于读取文件
InputStream input = new FileInputStream(new File("input.txt"));
// 3. 创建一个 FileOutputStream 对象用于写入文件
OutputStream output = new FileOutputStream(new File("output.txt"));
// 4. 循环读取文件内容到临时区，并将临时区中的数据写入到输出文件中
int length;
while ((length = input.read(buffer)) != -1) {
    output.write(buffer, 0, length);
}
// 5. 关闭输入流
input.close();
// 6. 关闭输出流
output.close();

// 1. 创建一个字节数组作为数据读取的临时区
byte[] buffer = new byte[1024];
// 2. 创建一个 BufferedInputStream 缓存输入流对象用于读取文件
InputStream bis = new BufferedInputStream(new FileInputStream(new File("input.txt")));
// 3. 创建一个 BufferedOutputStream 缓存输出流对象用于写入文件
OutputStream bos = new BufferedOutputStream(new FileOutputStream(new File("output.txt")));
// 4. 循环读取文件内容到临时区，并将缓冲区中的数据写入到输出文件中
int length;
while ((length = bis.read(buffer)) != -1) {
    bos.write(buffer, 0, length);
}
// 5. 关闭输入流
bis.close();
// 6. 关闭输出流
bos.close();

// 获取 readWriteDemo.txt 文件
File file = new File("readWriteDemo.txt");
if(file.exists()){
    // 获取字节输入流
    InputStream inputStream = new FileInputStream(file);
    // 转字符流输入流，指定 UTF_8 编码规则，读取数据
    Reader reader = new InputStreamReader(inputStream, StandardCharsets.UTF_8);
    // 缓冲区
    char[] buffer = new char[1024];
    // 分次读取数据，每次最多读取1024个字符，将数据读取到缓冲区之中，同时返回读取的字节个数
    int len;
    while ((len = reader.read(buffer)) > -1) {
        // 字符转为字符串
        String msg = new String(buffer, 0, len);
        System.out.println(msg);
    }
    // 关闭输入流
    reader.close();
    inputStream.close();
}

// 创建一个 newReadWriteDemo.txt 文件
File file = new File("readWriteDemo.txt");
if(!file.exists()){
    file.createNewFile();
}
// 获取字节输出流
OutputStream outputStream = new FileOutputStream(file);
// 转字符流输出流，指定 UTF_8 编码规则,写入数据
Writer out = new OutputStreamWriter(outputStream, StandardCharsets.UTF_8);
// 输出字符串
out.write("Hello");
// 输出换行
out.write("\n");
// 追加信息，append 方法底层本质调用的是 write 方法
out.append("我们一起来学习Java");
// 关闭输出流
out.close();
outputStream.close();