File I/O Stream

Sebuah I / O Stream merupakan sumber input atau output tujuan. Sebuah stream dapat mewakili berbagai macam sumber dan tujuan, termasuk file disk, perangkat, program lain, dan array memori.

Stream mendukung berbagai jenis data, termasuk byte sederhana, tipe data primitif, karakter lokal, dan objek. Beberapa aliran sungai cukup dengan memberikan data, yang lain memanipulasi dan mengubah data dengan cara yang bermanfaat.

Tidak peduli bagaimana mereka bekerja secara internal, semua aliran menyajikan model sederhana yang sama untuk program yang menggunakannya: stream adalah urutan data. Suatu program menggunakan input stream untuk membaca data dari sumber, satu item pada suatu waktu:

Suatu program menggunakan output stream untuk menulis data ke tujuan, satu item pada waktu:

Dalam pelajaran ini, kita akan melihat sungai yang dapat menangani semua jenis data, dari nilai primitif ke objek maju.

Sumber data dan tujuan data digambarkan di atas bisa apa saja yang memegang, menghasilkan, atau data mengkonsumsi. Jelas ini termasuk file disk, tetapi sumber atau tujuan juga bisa program lain, perangkat periferal, soket jaringan, atau array.

Pada bagian berikutnya, kita akan menggunakan jenis yang paling dasar sungai, byte stream, untuk menunjukkan operasi umum Stream I / O. Untuk input sampel, kita akan menggunakan contoh xanadu.txt file, yang berisi ayat berikut ini:

Dalam Xanadu tidak Khan Kubla
Sebuah keputusan kesenangan-kubah megah:
Dimana Alph, sungai suci, berlari
Melalui gua terukur kepada manusia
Turun ke laut sunless.

Byte Stream
byte menggunakan Program stream untuk melakukan input dan output byte 8-bit. Semua kelas stream byte adalah keturunan dari InputStream dan OutputStream.

Ada banyak kelas stream byte. Untuk mendemonstrasikan bagaimana byte stream bekerja, kita akan fokus pada file I / O byte stream, FileInputStream dan FileOutputStream. jenis lain dari byte stream yang digunakan dalam banyak cara yang sama, mereka berbeda terutama dalam cara mereka dibangun.

Menggunakan Byte Streaming

Kita akan mengeksplorasi FileInputStream dan FileOutputStream dengan memeriksa program contoh bernama CopyBytes, yang menggunakan byte stream untuk menyalin xanadu.txt, satu byte pada suatu waktu.

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

public class CopyBytes {
    public static void main(String[] args) throws IOException {
        FileInputStream in = null;
        FileOutputStream out = null;
        try {
            in = new FileInputStream("xanadu.txt");
            out = new FileOutputStream("outagain.txt");
            int c;

            while ((c = in.read()) != -1) {
                out.write(c);
            }

        } finally {
            if (in != null) {
                in.close();
            }
            if (out != null) {
                out.close();
            }
        }
    }
}

CopyBytes menghabiskan sebagian besar waktu dalam satu lingkaran sederhana yang membaca input stream dan menulis output stream, satu byte pada suatu waktu, seperti yang ditunjukkan pada gambar berikut

byte input stream dan output.
Perhatikan bahwa membaca () mengembalikan nilai int. Jika input merupakan aliran byte, mengapa tidak membaca () mengembalikan nilai byte? Menggunakan int sebagai tipe kembali memungkinkan read () untuk menggunakan -1 untuk menunjukkan bahwa ia telah mencapai ujung sungai.
Selalu Tutup Streaming
Menutup aliran saat itu tidak lagi dibutuhkan adalah sangat penting - sangat penting bahwa CopyBytes menggunakan akhirnya blok untuk menjamin bahwa kedua sungai akan ditutup bahkan jika terjadi kesalahan. Praktek ini membantu menghindari kebocoran sumber daya yang serius.

Satu kesalahan yang mungkin adalah bahwa CopyBytes tidak dapat membuka satu atau kedua file. Ketika itu terjadi, variabel aliran sesuai dengan file tidak pernah berubah dari nilai null awal. Itu sebabnya CopyBytes memastikan bahwa setiap variabel stream berisi referensi obyek sebelum memanggil dekat.
Ketika Tidak Menggunakan Byte Streams
CopyBytes tampaknya seperti program normal, tetapi sebenarnya merupakan semacam rendah tingkat I / O yang harus Anda hindari. Sejak xanadu.txt berisi data karakter, pendekatan terbaik adalah dengan menggunakan karakter stream, seperti dijelaskan dalam bagian berikutnya. Ada juga aliran untuk lebih jenis data rumit. Byte stream seharusnya hanya digunakan untuk paling primitif I / O.

Jadi mengapa bicara tentang byte stream? Karena semua jenis aliran lain yang dibangun pada byte stream.

Krakter Stream

Platform Java toko karakter nilai-nilai menggunakan konvensi Unicode. Karakter stream I / O secara otomatis menerjemahkan format internal untuk dan dari set karakter lokal. Dalam locales Barat, set karakter lokal biasanya merupakan superset 8-bit ASCII.

Untuk sebagian besar aplikasi, I / O dengan karakter stream tidak lebih rumit daripada I / O dengan byte stream. Input dan output dilakukan dengan kelas-kelas aliran secara otomatis menerjemahkan dari dan ke set karakter lokal. Sebuah program yang menggunakan stream karakter di tempat byte stream secara otomatis menyesuaikan dengan set karakter lokal dan siap untuk internasionalisasi - semua tanpa upaya ekstra oleh programmer.
Jika internasionalisasi tidak prioritas, Anda dapat menggunakan class stream karakter tanpa membayar banyak perhatian terhadap isu-isu set karakter. Kemudian, jika internasionalisasi menjadi prioritas, program anda dapat disesuaikan tanpa recoding luas. Lihat jejak Internasionalisasi untuk informasi lebih lanjut.
Menggunakan Karakter Streaming
kelas karakter stream Semua adalah keturunan dari Reader dan Writer. Seperti dengan byte stream, ada kelas aliran karakter yang mengkhususkan diri dalam file I / O: FileReader dan FileWriter. Contoh CopyCharacters menggambarkan kelas-kelas ini..........

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

public class CopyCharacters {
    public static void main(String[] args) throws IOException {
        FileReader inputStream = null;
        FileWriter outputStream = null;

        try {
            inputStream = new FileReader("xanadu.txt");
            outputStream = new FileWriter("characteroutput.txt");

            int c;
            while ((c = inputStream.read()) != -1) {
                outputStream.write(c);
            }
        } finally {
            if (inputStream != null) {
                inputStream.close();
            }
            if (outputStream != null) {
                outputStream.close();
            }
        }
    }
}

CopyCharacters sangat mirip dengan CopyBytes. Perbedaan yang paling penting adalah bahwa CopyCharacters menggunakan FileReader dan FileWriter untuk input dan output di tempat FileInputStream dan FileOutputStream. Perhatikan bahwa kedua CopyBytes dan CopyCharacters menggunakan variabel int untuk membaca dan menulis dari. Namun, di CopyCharacters, variabel int memiliki nilai karakter dalam terakhir 16 bit, dalam CopyBytes, variabel int memiliki nilai byte dalam 8 bit terakhir.

Karakter Streaming bahwa Gunakan Byte Streams
Karakter aliran sering "pembungkus" untuk byte stream. Aliran karakter menggunakan aliran byte untuk melakukan fisik I / O, sedangkan aliran karakter menangani terjemahan antara karakter dan byte. FileReader, misalnya, menggunakan FileInputStream, sedangkan FileWriter menggunakan FileOutputStream.

Ada dua tujuan umum byte-untuk-karakter "jembatan" stream: InputStreamReader dan OutputStreamWriter. Gunakan mereka untuk menciptakan karakter stream jika tidak ada aliran dikemas kelas karakter yang memenuhi kebutuhan Anda. Pelajaran soket dalam jejak jaringan menunjukkan bagaimana untuk menciptakan karakter stream dari byte stream yang disediakan oleh kelas socket.

Krakter Stream

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

public class CopyCharacters {
    public static void main(String[] args) throws IOException {
        FileReader inputStream = null;
        FileWriter outputStream = null;

        try {
            inputStream = new FileReader("xanadu.txt");
            outputStream = new FileWriter("characteroutput.txt");

            int c;
            while ((c = inputStream.read()) != -1) {
                outputStream.write(c);
            }
        } finally {
            if (inputStream != null) {
                inputStream.close();
            }
            if (outputStream != null) {
                outputStream.close();
            }
        }
    }
}

Line-Oriented I / O
Karakter I / O biasanya terjadi dalam unit lebih besar dari karakter tunggal. Satu unit umum adalah baris: string karakter dengan terminator garis di akhir. Sebuah terminator garis bisa menjadi urutan carriage-return/line-feed ("\ r \ n"), sebuah kereta tunggal-return ("\ r"), atau feed line-tunggal ("\ n"). Mendukung semua line terminator mungkin memungkinkan program untuk membaca file teks yang dibuat pada salah satu sistem operasi yang banyak digunakan.

Mari kita memodifikasi contoh CopyCharacters untuk menggunakan line-berorientasi I / O. Untuk melakukan ini, kita harus menggunakan dua kelas belum kita lihat sebelumnya, BufferedReader dan PrintWriter. Kita akan mengeksplorasi kelas-kelas ini lebih mendalam dalam Buffered I / O dan Format. Saat ini, kami hanya tertarik pada dukungan mereka untuk baris-berorientasi I / O.

Contoh CopyLines memanggil BufferedReader.readLine dan PrintWriter.println untuk melakukan input dan output satu baris pada suatu waktu.

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

public class CopyLines {
    public static void main(String[] args) throws IOException {
        BufferedReader inputStream = null;
        PrintWriter outputStream = null;

        try {
            inputStream = 
                new BufferedReader(new FileReader("xanadu.txt"));
            outputStream = 
                new PrintWriter(new FileWriter("characteroutput.txt"));

            String l;
            while ((l = inputStream.readLine()) != null) {
                outputStream.println(l);
            }
        } finally {
            if (inputStream != null) {
                inputStream.close();
            }
            if (outputStream != null) {
                outputStream.close();
            }
        }
    }
}

Menjalankan kembali readLine baris teks dengan baris. CopyLines output setiap baris menggunakan println, yang menambahkan line terminator untuk sistem operasi saat ini. Ini mungkin bukan terminator baris yang sama yang digunakan dalam file input.

Ada banyak cara untuk struktur input teks dan output di luar karakter dan garis. Untuk informasi lebih lanjut, lihat Scanning dan Format.

Stream buffered

Sebagian besar contoh yang telah kita lihat sejauh ini menggunakan unbuffered I O. / Ini berarti setiap membaca atau menulis request ditangani langsung oleh OS yang mendasarinya. Hal ini dapat membuat program yang jauh kurang efisien, karena masing-masing permintaan seperti itu sering memicu akses disk, aktivitas jaringan, atau beberapa operasi lain yang relatif mahal.

Untuk mengurangi jenis overhead, platform Java mengimplementasikan buffered I / O stream. Buffered input stream membaca data dari area memori yang dikenal sebagai penyangga; masukan API asli disebut hanya ketika buffer kosong. Demikian pula, output buffer stream menulis data ke buffer, dan output API asli disebut hanya ketika buffer penuh.

Suatu program dapat mengkonversi aliran unbuffered ke dalam sungai buffer menggunakan idiom pembungkus kami telah digunakan beberapa kali sekarang, di mana objek sungai unbuffered dilewatkan ke konstruktor untuk kelas stream buffer. Berikut adalah bagaimana Anda dapat memodifikasi pemanggilan konstruktor dalam contoh CopyCharacters untuk menggunakan buffered I / O:

 inputStream = 
            new BufferedReader(new FileReader("xanadu.txt"));
        outputStream = 
            new BufferedWriter(new FileWriter("characteroutput.txt"));

Ada empat kelas sungai buffer digunakan untuk membungkus unbuffered stream: BufferedInputStream dan BufferedOutputStream membuat buffer byte stream, sedangkan BufferedReader dan BufferedWriter membuat buffered stream karakter.
Flushing Buffered Streaming
Sering masuk akal untuk menulis buffer di titik kritis, tanpa menunggu untuk itu untuk mengisi. Ini dikenal sebagai pembilasan buffer.

Beberapa kelas output buffer dukungan autoflush, ditetapkan oleh argumen konstruktor opsional. Ketika autoflush diaktifkan, peristiwa penting tertentu menyebabkan buffer yang akan memerah. Sebagai contoh, suatu obyek PrintWriter autoflush mengosongkan buffer pada setiap permintaan dari println atau format. Lihat Memformat untuk lebih lanjut tentang metode ini.

Untuk flush stream secara manual, memanggil metode flush nya. Metode flush berlaku pada setiap output stream, tapi tidak berpengaruh kecuali sungai adalah buffered.

Mulai Lagi

File I/O Stream

0 komentar:

Posting Komentar

Blog Archive

Pengikut

Mengenai Saya