Teknik dan aplikasi membaca dan menulis fail yang dilaksanakan di Jawa

Java ialah bahasa pengaturcaraan peringkat tinggi dengan fungsi membaca dan menulis fail yang sangat berkuasa. Dalam artikel ini, kami akan memperkenalkan teknik dan aplikasi membaca dan menulis fail Java.

1. Asas membaca dan menulis fail Java

1.1 Membaca fail

Kaedah membaca fail yang paling biasa digunakan di Java ialah menggunakan kelas BufferedReader. Berikut ialah contoh mudah:

try{
    BufferedReader br = new BufferedReader(new FileReader("input.txt"));
    String line;
    while ((line = br.readLine()) != null) {
        System.out.println(line);
    }
} catch(IOException e){
    e.printStackTrace();
}

Dalam kod ini, kami mula-mula mencipta objek BufferedReader, yang membaca fail input.txt menggunakan kelas FileReader. Kami kemudian membaca setiap baris dalam fail dan mencetaknya ke konsol.

1.2 Menulis fail

Kaedah menulis fail yang paling biasa digunakan dalam Java ialah menggunakan kelas PrintWriter. Berikut ialah contoh mudah:

try{
    PrintWriter pw = new PrintWriter("output.txt");
    pw.println("Hello, world!");
    pw.close();
} catch(IOException e){
    e.printStackTrace();
}

Dalam kod ini, kami mula-mula mencipta objek PrintWriter, yang akan menulis output ke fail output.txt. Kemudian kami menulis baris "Hello, dunia!" pada fail, dan akhirnya menutup objek PrintWriter.

1.3 Membaca dan menulis fail binari

Selain fail teks, Java juga boleh membaca dan menulis fail binari. Berikut ialah contoh mudah:

try{
    FileInputStream fis = new FileInputStream("input.bin");
    int data = fis.read();
    while (data != -1) {
        System.out.println(data);
        data = fis.read();
    }
    fis.close();
} catch(IOException e){
    e.printStackTrace();
}

Dalam kod ini, kami mula-mula mencipta objek FileInputStream, yang membuka fail input.bin dalam mod binari. Kami kemudian membaca data dari bait fail demi bait dan mencetaknya ke konsol. Akhirnya kami menutup objek FileInputStream.

2. Kemahiran membaca dan menulis fail Java

2.1 Pengekodan aksara fail

Apabila memproses fail teks dalam Java, anda perlu memberi perhatian khusus kepada pengekodan aksara fail . Jika pengekodan fail bukan pengekodan UTF-8 lalai Java, anda perlu menggunakan pengekod yang sesuai untuk membaca atau menulis fail. Berikut ialah contoh membaca fail yang dikodkan UTF-16:

try{
    BufferedReader br = new BufferedReader(new InputStreamReader(
            new FileInputStream("input.txt"), "UTF-16"));
    String line;
    while ((line = br.readLine()) != null) {
        System.out.println(line);
    }
    br.close();
} catch(IOException e){
    e.printStackTrace();
}

Dalam kod ini, kami membaca fail input.txt dengan menukar objek FileInputStream kepada objek InputStreamReader dan menentukan pengekod UTF-16. Adalah penting untuk ambil perhatian bahawa membaca fail teks menggunakan pengekod yang salah boleh menghasilkan aksara pelik atau ralat pengekodan, jadi pastikan anda memberi perhatian kepada pengekodan fail.

2.2 Membaca dan menulis fail besar

Perhatian khusus perlu diberikan kepada penggunaan memori semasa memproses fail besar. Jika anda membaca keseluruhan fail ke dalam memori sekaligus, anda boleh menyebabkan kebocoran memori atau ranap program. Jadi anda boleh menggunakan Java NIO (I/O Baharu) untuk membaca fail besar baris demi baris. Berikut ialah contoh membaca fail besar:

try{
    RandomAccessFile raf = new RandomAccessFile("input.txt", "r");
    FileChannel fc = raf.getChannel();
    ByteBuffer buf = ByteBuffer.allocate(1024);
    while (fc.read(buf) != -1) {
        buf.flip();
        byte[] bytes = new byte[buf.limit()];
        buf.get(bytes);
        System.out.print(new String(bytes, Charset.forName("UTF-8")));
        buf.clear();
    }
    fc.close();
    raf.close();
} catch(IOException e){
    e.printStackTrace();
}

Dalam kod ini, kita mula-mula mencipta objek RandomAccessFile dan menggunakan objek RandomAccessFile untuk mencipta objek FileChannel. Kemudian kami mencipta objek ByteBuffer dengan saiz 1024 bait. Kemudian kami menggunakan objek FileChannel untuk membaca data ke dalam objek ByteBuffer, menggunakan objek ByteBuffer untuk menukar data menjadi tatasusunan bait dan menggunakan pengekod UTF-8 untuk menukar tatasusunan bait menjadi rentetan. Akhirnya kami mengosongkan objek ByteBuffer supaya kami boleh membaca data pada masa akan datang.

2.3 Menulis fail besar

Apabila berurusan dengan fail besar, anda juga perlu memberi perhatian khusus untuk membahagikan fail kepada saiz yang sesuai dan menulis baris demi baris. Berikut ialah contoh menulis fail besar:

try{
    PrintWriter pw = new PrintWriter(new File("output.txt"));
    for (int i = 0; i < 1000000; i++) {
        pw.println("Line #" + i);
        if (i % 10000 == 0) {
            pw.flush();
        }
    }
    pw.close();
} catch(IOException e){
    e.printStackTrace();
}

Dalam kod ini, kami mula-mula mencipta objek PrintWriter, yang akan menulis output ke fail output.txt. Kemudian kami menulis 1,000,000 baris data dalam gelung dan siram penimbal setiap 10,000 baris untuk menulis data ke cakera. Akhirnya kami menutup objek PrintWriter.

3. Aplikasi membaca dan menulis fail Java

3.1 Penyalinan fail

Salah satu aplikasi yang paling biasa digunakan bagi fungsi membaca dan menulis fail Java ialah menyalin fail. Berikut ialah contoh salinan fail mudah:

try{
    FileInputStream fis = new FileInputStream("input.txt");
    FileOutputStream fos = new FileOutputStream("output.txt");
    byte[] buffer = new byte[1024];
    int count;
    while ((count = fis.read(buffer)) != -1) {
        fos.write(buffer, 0, count);
    }
    fis.close();
    fos.close();
} catch(IOException e){
    e.printStackTrace();
}

Dalam kod ini, kami mula-mula mencipta objek FileInputStream untuk membaca fail input.txt. Kemudian kami mencipta objek FileOutputStream untuk menulis data ke fail output.txt. Seterusnya kita mencipta penimbal tatasusunan bait untuk menyalin blok fail demi blok. Akhir sekali kita gelung melalui setiap bahagian data dalam fail dan menulisnya ke fail output.

3.2 Pengiraan Nilai Hash Fail

Fungsi membaca dan menulis fail Java juga boleh digunakan untuk mengira nilai cincang (Hash) fail. Berikut ialah contoh pengiraan nilai cincang fail:

try{
    MessageDigest md = MessageDigest.getInstance("SHA-256");
    FileInputStream fis = new FileInputStream("input.txt");
    byte[] buffer = new byte[1024];
    int count;
    while ((count = fis.read(buffer)) != -1) {
        md.update(buffer, 0, count);
    }
    fis.close();
    byte[] digest = md.digest();
    System.out.println(DatatypeConverter.printHexBinary(digest));
} catch(IOException | NoSuchAlgorithmException e){
    e.printStackTrace();
}

Dalam kod ini, kami mula-mula mencipta objek MessageDigest dan menggunakan algoritma penyulitan SHA-256. Kemudian kami mencipta objek FileInputStream untuk membaca fail input.txt. Kemudian kami mencipta penimbal tatasusunan bait dan gelung melalui setiap keping data dalam fail dan mengemas kininya ke dalam objek MessageDigest. Akhirnya kami menutup objek FileInputStream dan menggunakan objek MessageDigest untuk mengira nilai cincang fail dan mengeluarkan hasil pengiraan ke konsol dalam bentuk rentetan perenambelasan.

Kesimpulan

Fungsi membaca dan menulis fail Java sangat berkuasa Pembangun boleh menggunakan pelbagai teknik secara fleksibel untuk mengendalikan keperluan membaca dan menulis yang berbeza, seperti memproses pengekodan fail, membaca dan menulis fail besar, fail. penyalinan dan pengiraan nilai Hash dsb. Oleh itu, menguasai kemahiran membaca dan menulis fail Java dan aplikasi boleh membantu meningkatkan kecekapan pembangunan dan kualiti kod.

Atas ialah kandungan terperinci Teknik dan aplikasi membaca dan menulis fail yang dilaksanakan di Jawa. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!