Untuk fail moden I/O di Java, gunakan NIO.2 (java.nio.file) kerana ia menyediakan API yang lebih intuitif, kaya, dan lebih selamat berbanding dengan I/O tradisional; 2. Gunakan I/O tradisional hanya untuk kod warisan atau operasi aliran mudah, kerana ia menyekat dan kurang berskala; 3. Gunakan NIO dengan saluran dan pemilih untuk pengaturcaraan rangkaian yang berprestasi tinggi, tidak menyekat; 4. Gunakan Nio.2's WatchService untuk memantau perubahan direktori dan asynchronousfileChannel untuk operasi fail yang tidak menyekat; 5. lebih suka laluan.get () dan cuba-dengan-sumber untuk pengurusan sumber, dan elakkan memuatkan fail besar sepenuhnya ke dalam ingatan dengan readalllines (). NIO.2 adalah standard yang disyorkan untuk pengendalian fail di Java 7 dan kemudian kerana reka bentuk, ekspresi, dan keupayaan prestasi yang unggul.

Sistem I/O (input/output) Java telah berkembang dengan ketara selama bertahun -tahun, terutamanya dengan pengenalan NIO (I/O baru) di Java 1.4 dan pembaikan utama di NIO.2 dengan Java 7.

Mari kita memecahkan aspek utama Java I/O dan Nio.2, bandingkan kekuatan mereka, dan lihat bagaimana mereka sesuai dengan pembangunan Java moden.

1. Java Tradisional I/O: Model berasaskan sungai

Sistem I/O asal Java, yang diperkenalkan dalam versi awal Java, didasarkan pada aliran - perwakilan abstrak aliran data. Ia terdapat dalam pakej java.io dan berkisar di sekitar aliran byte dan watak.

Komponen utama:

• InputStream / OutputStream : Untuk mengendalikan bait mentah (contohnya, fail, soket rangkaian).
• Pembaca/Penulis : Untuk I/O berasaskan watak, pengekodan/penyahkodan menyokong (contohnya, FileReader , BufferedReader ).
• Penghias : Aliran boleh dibungkus (contohnya, BufferedInputStream , DataInputStream ) untuk menambah fungsi.

Contoh: Membaca fail

 cuba (bufferedreader reader = bufferedReader baru (fileReader baru ("data.txt"))) {
    Garis rentetan;
    sementara ((line = reader.readline ())! = null) {
        System.out.println (line);
    }
}

Ciri -ciri:

• Segerak dan menyekat : Setiap operasi I/O menyekat benang sehingga selesai.
• Berorientasikan aliran : Data diproses secara berurutan; Tiada akses rawak.
• Mudah untuk tugas asas : Hebat untuk fail kecil atau kes penggunaan mudah.

Walau bagaimanapun, perjuangan I/O tradisional dengan skalabiliti dalam persekitaran yang tinggi (contohnya, pelayan mengendalikan beribu-ribu sambungan), di mana menyekat I/O membawa kepada keletihan benang.

2. Java Nio: model penampan dan saluran (Java 1.4)

NIO ( java.nio ) memperkenalkan pendekatan yang tidak menyekat, buffer-centric kepada I/O, yang direka untuk aplikasi berprestasi tinggi dan berskala.

Konsep Teras:

• Saluran : Saluran dua arah untuk data (tidak seperti aliran unidirectional). Contoh: FileChannel , SocketChannel .
• Buffer : Bekas data bersaiz tetap (misalnya, ByteBuffer , CharBuffer ) yang memegang data yang dibaca/ditulis.
• Pemilih : Dayakan Multiplexing-Satu benang tunggal boleh memantau pelbagai saluran untuk acara (contohnya, bersedia untuk membaca/menulis), penting untuk rangkaian I/O yang tidak menyekat.

Contoh: Membaca fail dengan NIO

 cuba (fileChannel channel = fileChannel.Open (paths.get ("data.txt"), standardOpenOption.read)) {
    ByteBuffer buffer = byteBuffer.allocate (1024);
    Semasa (Channel.READ (Buffer)> 0) {
        buffer.flip ();
        sementara (buffer.hasremaining ()) {
            System.out.print ((char) buffer.get ());
        }
        buffer.clear ();
    }
}

Kelebihan:

• Tidak menyekat I/O : terutamanya berguna dalam pengaturcaraan rangkaian (contohnya, pelayan menggunakan Selector ).
• Fail yang dipetakan memori : FileChannel.map() membolehkan pemetaan fail terus ke memori untuk akses cepat.
• Prestasi yang lebih baik untuk pemindahan data yang besar .

Tetapi API Nio lebih kompleks dan kurang intuitif daripada I/O tradisional, dan pengendalian fail (terutamanya laluan dan metadata) masih kikuk.

3. NIO.2: Fail Moden I/O (Java 7)

NIO.2, yang diperkenalkan di Java 7 melalui java.nio.file , merombak model interaksi sistem fail. Ia tinggal di java.nio.file , java.nio.file.attribute , dan java.nio.file.spi pakej.

Ciri -ciri utama:

• Antara muka Path : Penggantian moden untuk java.io.File , yang mewakili laluan sistem fail.
• Kelas Fail : Kaedah Utiliti Kaya untuk Operasi Biasa (Salin, Pindah, Padam, Baca, Tulis).
• FileSystem API : Menyokong pelbagai sistem fail (misalnya, fail zip melalui FileSystemProvider ).
• WatchService : Memantau direktori untuk perubahan fail (Buat, Ubahsuai, Padam).
• Asynchronous I/O : AsynchronousFileChannel membolehkan operasi fail yang tidak menyekat.

Contoh: Membaca fail dengan NIO.2

 Laluan laluan = paths.get ("data.txt");
Senarai <string> lines = files.readalllines (Path, standardCharsets.utf_8);

Atau lebih mudah:

 String content = files.readString (path);

Contoh: Menonton direktori

 WatchService Watcher = FileSystems.getDefault (). NewWatchService ();
Jalan dir = paths.get ("tonton-folder");
dir.register (Watcher, standardWatcheVentkinds.entry_create);

// dalam gelung
Kunci WatchKey = Watcher.Take ();
untuk (WatchEvent <?> Acara: Key.PolleVents ()) {
    System.out.println ("Fail dicipta:" event.context ());
}

Kelebihan Legacy I/O:

• API yang lebih intuitif dan ekspresif .
• Pengendalian pengecualian yang lebih baik (pengecualian khusus seperti NoSuchFileException ).
• Sokongan untuk pautan simbolik, atribut fail, dan keizinan .
• Penyedia sistem fail pluggable (contohnya, bekerja dengan arkib zip sebagai sistem fail).

4. Bila hendak menggunakan apa?

Peraturan Thumb : Untuk Fail I/O dalam Java Moden (8), lebih suka NIO.2. Ia lebih selamat, lebih ringkas, dan kaya ciri.

5. Petua Praktikal dan Gotchas

• Sentiasa gunakan Cuba-dengan-Resources : kedua-dua aliran dan saluran adalah AutoCloseable .
• Lebih suka Paths.get() ke atas new File() : ia mengembalikan Path , asas NIO.2.
• WatchService memerlukan penggunaan acara : Sentiasa panggil pollEvents() dan reset() pada kunci.
• Elakkan readAllLines() untuk fail besar : ia memuatkan segala -galanya ke dalam ingatan. Gunakan Files.lines() untuk streaming:

   cuba (stream <string> lines = files.lines (path)) {
      garis.foreach (System.out :: println);
  }

• Gunakan StandardOpenOption untuk kawalan halus (contohnya, CREATE , APPEND ).

---

Pemikiran terakhir

Walaupun Java I/O tradisional masih berfungsi dan dilihat secara meluas dalam kod warisan, NIO.2 adalah masa depan dan masa depan pengendalian fail di Java . Ia menggabungkan manfaat prestasi NIO dengan API yang bersih dan tinggi. Untuk projek baru, lalai ke NIO.2 melainkan anda mempunyai alasan khusus untuk menggunakan pembinaan peringkat rendah.

Memahami evolusi dari java.io → nio → nio.2 Membantu anda membuat pilihan maklumat mengenai prestasi, skalabilitas, dan kejelasan kod.

Pada asasnya, jika anda melakukan fail I/O di Java hari ini, anda harus menggunakan java.nio.file . Cara lama tidak salah - mereka hanya ketinggalan zaman.

Atas ialah kandungan terperinci Pandangan Komprehensif di Java I/O dan NIO.2. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!