Bagaimana untuk melaksanakan operasi membaca dan menulis fail dalam Java

Operasi input dan output fail dalam Java ialah tugas asas. Di Java, anda boleh menggunakan Fail dan FileInputStream, FileOutputStream, BufferedReader, PrintWriter dan kelas lain untuk melaksanakan operasi membaca dan menulis fail.

Membaca Fail

Di Java, anda boleh menggunakan kelas FileInputStream dan BufferedReader untuk membaca fail.

FileInputStream:

FileInputStream boleh digunakan untuk membaca aliran input fail terbuka dalam sistem fail. Ia mewarisi daripada kelas InputStream dan menyediakan banyak kaedah yang berkaitan dengan fail I/O. Kita boleh menggunakannya untuk membuka fail di bawah laluan yang ditentukan dan membaca data daripada fail tersebut.

FileInputStream inputStream = null;
try {
    File file = new File("file.txt");
    inputStream = new FileInputStream(file);
    int content;
    while ((content = inputStream.read()) != -1) {
        // 处理读取到的字节
    }
} catch (IOException e) {
    e.printStackTrace();
} finally {
    if (inputStream != null) {
        try {
            inputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Dalam kod di atas, kami mula-mula mencipta objek Fail dan kemudian menggunakan FileInputStream untuk membaca kandungan fail. Memandangkan FileInputStream hanya boleh membaca satu bait pada satu masa, kita perlu menggunakan gelung sementara untuk membaca setiap bait secara berterusan. Apabila kaedah read() mengembalikan -1, ini bermakna keseluruhan fail telah dibaca.

BufferedReader:

Strim input aksara buffer boleh dibalut oleh kelas pembalut BufferedReader untuk membalut aliran input aksara. Kelebihannya ialah ia boleh membaca berbilang aksara sekaligus, dengan itu meningkatkan kecekapan membaca fail.

BufferedReader reader = null;
try {
    File file = new File("file.txt");
    FileReader fileReader = new FileReader(file);
    reader = new BufferedReader(fileReader);
    String content;
    while ((content = reader.readLine()) != null) {
        // 处理读取到的一行字符串
    }
} catch (IOException e) {
    e.printStackTrace();
} finally {
    if (reader != null) {
        try {
            reader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Dalam kod di atas, kami mula-mula mencipta objek Fail, kemudian gunakan FileReader untuk menukar fail kepada aliran aksara dan gunakan BufferedReader untuk membalutnya. Apabila membaca kandungan setiap baris, gunakan kaedah readLine() Apabila kaedah ini mengembalikan null, ini bermakna keseluruhan fail telah dibaca.

Penulisan Fail

Di Java, anda boleh menggunakan kelas FileOutputStream dan PrintWriter untuk menulis fail.

FileOutputStream:

FileOutputStream ialah aliran keluaran yang digunakan untuk mengeluarkan data ke sistem fail. Ia adalah subkelas kelas OutputStream dan mempunyai banyak kaedah yang berkaitan dengan input dan output fail. Kita boleh menggunakannya untuk membuka fail di bawah laluan yang ditentukan dan menulis data ke fail.

FileOutputStream outputStream = null;
try {
    File file = new File("file.txt");
    outputStream = new FileOutputStream(file);
    String content = "Hello, world!";
    byte[] bytes = content.getBytes();
    outputStream.write(bytes);
} catch (IOException e) {
    e.printStackTrace();
} finally {
    if (outputStream != null) {
        try {
            outputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Dalam kod di atas, kami mula-mula mencipta objek Fail dan kemudian menggunakan FileOutputStream untuk menulis kandungan fail. Memandangkan FileOutputStream hanya boleh menulis satu bait atau tatasusunan bait pada satu masa, kita perlu menukar rentetan yang ingin kita tulis kepada tatasusunan bait.

PrintWriter:

PrintWriter ialah kelas pembalut yang membungkus strim output aksara ke dalam strim output cetakan.. Ia menyediakan kaedah mudah untuk mengeluarkan pelbagai jenis data, termasuk rentetan, nombor, dsb. Selain itu, PrintWriter juga boleh memformat data bertulis.

PrintWriter writer = null;
try {
    File file = new File("file.txt");
    FileWriter fileWriter = new FileWriter(file);
    writer = new PrintWriter(fileWriter);
    String content = "Hello, world!";
    writer.println(content);
} catch (IOException e) {
    e.printStackTrace();
}

Dalam kod di atas, kami mula-mula mencipta objek Fail, kemudian gunakan FileWriter untuk menukar fail kepada aliran aksara dan gunakan PrintWriter untuk membalutnya. Di sini, kami menggunakan fungsi println() untuk menulis rentetan, yang secara automatik menambah aksara baris baharu pada penghujung rentetan.

Salinan fail

Dalam Java, anda boleh menggunakan FileInputStream dan FileOutputStream untuk melaksanakan fungsi salinan fail.

FileInputStream inputStream = null;
FileOutputStream outputStream = null;
try {
    File sourceFile = new File("source.txt");
    File targetFile = new File("target.txt");
    inputStream = new FileInputStream(sourceFile);
    outputStream = new FileOutputStream(targetFile);
    byte[] buffer = new byte[1024];
    int length;
    while ((length = inputStream.read(buffer)) > 0) {
        outputStream.write(buffer, 0, length);
    }
} catch (IOException e) {
    e.printStackTrace();
} finally {
    if (inputStream != null) {
        try {
            inputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    if (outputStream != null) {
        try {
            outputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Kami mula-mula mencipta dua objek Fail dalam kod ini, satu untuk mewakili fail sumber dan satu lagi untuk mewakili fail sasaran. Seterusnya, gunakan FileInputStream dan FileOutputStream untuk membaca fail asal dan menulisnya ke fail sasaran. Penampan (tatasusunan bait) perlu digunakan untuk menyimpan data baca, kerana hanya panjang tertentu data bait boleh dibaca pada satu masa. Akhirnya, apabila keseluruhan fail telah dibaca, aliran input dan output ditutup.

Pemadaman fail

Di Java, anda boleh menggunakan kaedah delete() kelas Fail untuk memadamkan fail.

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

Kami menggunakan objek Fail untuk memadamkan fail Kami mula-mula mencipta objek dan kemudian memanggil kaedah delete(). Pemadaman fail yang berjaya akan kembali benar, manakala kegagalan pemadaman fail akan kembali palsu.

Penamaan semula fail

Di Java, anda boleh menggunakan kaedah renameTo() kelas Fail untuk melaksanakan fungsi penamaan semula fail.

File sourceFile = new File("source.txt");
File targetFile = new File("target.txt");
if (sourceFile.renameTo(targetFile)) {
    System.out.println("文件重命名成功！");
} else {
    System.out.println("文件重命名失败！");
}

Kami mula-mula membuat instantiated dua objek Fail Antara dua objek ini, satu mewakili nama fail asal dan satu lagi mewakili nama fail sasaran. Gunakan kaedah renameTo() untuk menamakan semula nama fail asal kepada nama fail sasaran. Jika benar dikembalikan, ini bermakna nama semula fail berjaya; jika palsu dikembalikan, ini bermakna nama semula fail tidak berjaya.

Atas ialah kandungan terperinci Bagaimana untuk melaksanakan operasi membaca dan menulis fail dalam Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!