【JAV学习】存储&读写数据的方案

A林玖

于 2024-12-09 23:35:08 发布

阅读量876

点赞数 12

文章标签：学习

本文链接：https://blog.youkuaiyun.com/PANSS__/article/details/144359465

版权

File

File 其对象代表具体的文件，只能操作文件本身

File类的所有操作只是对文件或目录进行路径操作，并没有直接操作文件内容

常用方法：

创建File对象

// 使用绝对路径创建File对象
File absFile = new File("C:\\folder\\file.txt");
// 使用相对路径创建File对象
File relFile = new File("src/main/resources/file.txt");

注意：

只要不带盘符的都称之为绝对路径
相对路径：不带盘符，默认到相应idea工程下寻找文件

检查文件/目录是否存在

File file = new File("path/to/your/file.txt");
if (file.exists()) {
    System.out.println("文件存在");
} else {
    System.out.println("文件不存在");
}

创建文件

try {
    File file = new File("path/to/your/newfile.txt");
    if (file.createNewFile()) {
        System.out.println("文件创建成功");
    } else {
        System.out.println("文件已存在");
    }
} catch (IOException e) {
    e.printStackTrace();
}

创建目录

mkdir() 用于创建单个目录。如果目录已经存在，则返回 false

File dir = new File("path/to/your/newdir");
if (dir.mkdir()) {
    System.out.println("目录创建成功");
} else {
    System.out.println("目录已存在或创建失败");
}

mkdirs() 方法会创建目录及所有必要的父目录

File dir = new File("path/to/your/newdir/subdir");
if (dir.mkdirs()) {
    System.out.println("目录及父目录创建成功");
} else {
    System.out.println("目录创建失败");
}

删除文件

delete() 方法用于删除文件或空目录。删除失败会返回 false

File file = new File("path/to/your/file.txt");
if (file.delete()) {
    System.out.println("文件删除成功");
} else {
    System.out.println("文件删除失败");
}

获取文件信息

获取文件的大小

long size = file.length();
System.out.println("文件大小: " + size + "字节");

获取文件的绝对路径

String absolutePath = file.getAbsolutePath();
System.out.println("文件的绝对路径: " + absolutePath);

获取文件的名称

String fileName = file.getName();
System.out.println("文件名: " + fileName);

判断是文件还是目录

if (file.isFile()) {
    System.out.println("这是一个文件");
} else if (file.isDirectory()) {
    System.out.println("这是一个目录");
}

遍历文件夹

public File[] listFiles() 获取当前目录下所有的"一级文件对象"到一个文件对象数组中去返回

import java.io.File;

public class FileTraversalExample {
    public static void main(String[] args) {
        File dir = new File("path/to/your/directory");

        // 检查目录是否存在
        if (dir.exists() && dir.isDirectory()) {
            // 获取目录下的所有文件和子目录
            File[] files = dir.listFiles();

            // 遍历文件和子目录
            if (files != null) {
                for (File file : files) {
                    if (file.isDirectory()) {
                        System.out.println("目录: " + file.getName());
                    } else {
                        System.out.println("文件: " + file.getName());
                    }
                }
            } else {
                System.out.println("该目录为空或无法访问！");
            }
        } else {
            System.out.println("指定的路径不是有效的目录！");
        }
    }
}

注意事项：

当主调是文件，或者路径不存在时，返回null
当主调是空文件夹时，返国一个长度为0的数组
当主调是一个有内容的文件夹时，将里面所有一级文件和文件夹的路径放在file数组中返回
当主调是一个文件夹，且里面有隐藏文件时，将里面所有文件和文件夹的路径放在file数组中返回，包含隐藏文件
当主调是一个文件夹，但是没有权限访问该文件夹时，返回null

public String[] list() 获取当前目录下所有的"一级文件名称"到一个字符串数组中去返回

import java.io.File;

public class FileListExample {
    public static void main(String[] args) {
        File dir = new File("path/to/your/directory");

        // 检查目录是否存在
        if (dir.exists() && dir.isDirectory()) {
            // 获取目录下的所有文件和子目录的名称
            String[] fileNames = dir.list();

            // 遍历文件和子目录名称
            if (fileNames != null) {
                for (String fileName : fileNames) {
                    System.out.println(fileName);
                }
            } else {
                System.out.println("该目录为空或无法访问！");
            }
        } else {
            System.out.println("指定的路径不是有效的目录！");
        }
    }
}

注意：该方式返回的仅是文件和目录的名称，如果需要更详细的信息（如是否为目录、文件大小等），应该使用 listFiles()

方法递归

实现文件搜索

import java.io.File;

public class FileSearch {

    /**
     * 递归查找文件。
     * @param dir 要搜索的目录。
     * @param fileName 要查找的文件名。
     */
    public static void search(File dir, String fileName) {
        // 检查传入的参数是否为null或不存在
        if (dir == null || !dir.exists()) {
            System.out.println("指定的路径不存在");
            return;
        }

        // 如果是文件而不是目录，则检查文件名是否匹配
        if (!dir.isDirectory()) {
            if (dir.getName().equals(fileName)) {
                System.out.println("找到文件: " + dir.getAbsolutePath());
            }
            return;
        }

        // 获取目录下的所有文件和子目录
        File[] files = dir.listFiles();
        if (files != null) {
            for (File file : files) {
                // 如果是目录，则递归调用search方法
                if (file.isDirectory()) {
                    search(file, fileName);
                } else if (file.getName().equals(fileName)) {
                    // 如果是文件且名称匹配，则打印出文件的绝对路径
                    System.out.println("找到文件: " + file.getAbsolutePath());
                }
            }
        }
    }

    public static void main(String[] args) {
        // 设置搜索的根目录和文件名
        File rootDir = new File("C:\\your\\directory\\path");
        String targetFileName = "target.txt";
        
        // 开始搜索
        search(rootDir, targetFileName);
    }
}

IO流读写数据

IO 流的分类

IO 流体系

常用IO流使用示例

字节流

字节流是最基础的流，用于处理二进制数据

FileInputStream 读取文件

import java.io.FileInputStream;
import java.io.IOException;

public class FileInputStreamExample {
    public static void main(String[] args) {
        try (FileInputStream fis = new FileInputStream("example.txt")) {
            int content;
            while ((content = fis.read()) != -1) {
                System.out.print((char) content);// 将读取的字节转换为字符
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

FileInputStream 用来从文件读取数据
fis.read() 读取文件中的一个字节，直到文件结束（返回 -1）
System.out.print((char) content) 将读取到的字节转换为字符并打印出来

FileOutputStream 写入文件

import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputStreamExample {
    public static void main(String[] args) {
        try (FileOutputStream fos = new FileOutputStream("output.txt")) {
            String content = "Hello, Java IO!";
            fos.write(content.getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

FileOutputStream 用来向文件写入数据
content.getBytes() 将字符串转换成字节数组，然后通过 fos.write() 写入文件

字符流

字符流是为了方便处理文本数据，它会自动处理字符编码的转换

FileReader 读取文件

import java.io.FileReader;
import java.io.IOException;

public class FileReaderExample {
    public static void main(String[] args) {
        try (FileReader fr = new FileReader("example.txt")) {
            int content;
            while ((content = fr.read()) != -1) {
                System.out.print((char) content);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

FileReader 用于读取文本文件
fr.read() 每次读取一个字符（其实是一个字节，然后根据编码转换为字符），直到文件结束

FileWriter 写入文件

import java.io.FileWriter;
import java.io.IOException;

public class FileWriterExample {
    public static void main(String[] args) {
        try (FileWriter fw = new FileWriter("output.txt")) {
            fw.write("Hello, Java IO!");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

FileWriter 用于向文本文件写入字符
fw.write() 直接写入字符串数据

缓冲流

缓冲流提高了读写性能，适用于处理大量数据。它们在内存中读取或写入数据块，而不是一个字符或字节。

BufferedReader 读取文件

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class BufferedReaderExample {
    public static void main(String[] args) {
        try (BufferedReader br = new BufferedReader(new FileReader("example.txt"))) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

BufferedReader 让读取变得更加高效，readLine() 每次读取文件中的一行内容

BufferedWriter 写入文件

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class BufferedWriterExample {
    public static void main(String[] args) {
        try (BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"))) {
            bw.write("Hello, BufferedWriter!");  写入字符串
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

数据流

数据流用于读取和写入原始数据类型（如 int、double 等），而不是字符

DataInputStream

import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class DataInputStreamExample {
    public static void main(String[] args) {
        try (DataInputStream dis = new DataInputStream(new FileInputStream("data.bin"))) {
            int intValue = dis.readInt();
            double doubleValue = dis.readDouble();
            System.out.println("Read values: " + intValue + ", " + doubleValue);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

DataInputStream 用于读取文件中的原始数据类型（如 int、double）
dis.readInt() 读取一个 int 值，dis.readDouble() 读取一个 double 值

DataOutputStream

import java.io.DataOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class DataOutputStreamExample {
    public static void main(String[] args) {
        try (DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.bin"))) {
            dos.writeInt(123);
            dos.writeDouble(3.14159);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

DataOutputStream 用于将原始数据类型写入文件

文件复制实现

import java.io.*;

public class FileCopyExample {
    public static void main(String[] args) {
        File sourceFile = new File("source.txt");
        File destinationFile = new File("destination.txt");

        try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream(sourceFile));
             BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destinationFile))) {

            byte[] buffer = new byte[1024];
            int bytesRead;
            while ((bytesRead = bis.read(buffer)) != -1) {
                bos.write(buffer, 0, bytesRead);
            }

            System.out.println("文件复制完成！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}