Pengenalan dan analisis contoh kelas Fail dan aliran IO dalam Java

Aliran IO:

Gambaran keseluruhan aliran IO:

IO : Input/Output

Strim : Ia adalah konsep abstrak dan istilah umum untuk penghantaran data. Maksudnya, penghantaran data antara peranti dipanggil aliran Intipati aliran data digunakan untuk menangani masalah penghantaran data antara peranti: memuat turun fail; dll. Ringkasnya, ia melibatkan Segala-galanya tentang penghantaran melibatkan aliran.

Rajah sistem aliran IO:

Oleh kerana IO ialah operasi yang melibatkan fail, maka Ia mestilah tidak boleh dipisahkan daripada teknologi pengendalian fail:

Kelas fail:

Kelas fail ialah satu-satunya objek dalam pakej java.io yang mewakili fail cakera itu sendiri. Kelas Fail mentakrifkan beberapa kaedah untuk mengendalikan fail, terutamanya digunakan untuk mendapatkan atau memproses maklumat yang berkaitan dengan fail cakera, seperti nama fail, laluan fail, kebenaran akses, tarikh pengubahsuaian, dsb., dan juga boleh menyemak imbas hierarki subdirektori.

Kelas Fail mewakili maklumat yang berkaitan dengan pemprosesan fail dan sistem fail. Kelas Fail tidak mempunyai fungsi membaca maklumat dari dan menulis maklumat ke fail Ia hanya menerangkan sifat fail itu sendiri. Jadi ia dipasangkan dengan IO untuk operasi membaca dan menulis.

Pertama lihat rajah ringkasan kaedah yang biasa digunakan bagi kelas Fail:

Gunakan createNewFile() untuk cipta fail:

public class test01 {
    public static void main(String[] args) throws IOException {
		//先建立一个File对象，并传入路径
        File file1 = new File("G://abc.txt");
        //创建空文件，如果没有存在则新建一个，并且返回True,如果存在了就返回false
        System.out.println(file1.createNewFile());   
}

Jika fail tidak wujud dalam direktori selepas pelaksanaan, ia akan mencipta satu dan mengembalikan benar Jika ia sudah wujud, ia akan mengembalikan palsu, menunjukkan bahawa penciptaan gagal.

Gunakan mkdir() untuk mencipta direktori:

File file2 = new File("G://a");
	System.out.println(file2.mkdir());   
//创建一个目录，如果没有存在则新建一个，并且返回True,如果存在了就返回false

Gunakan mkdirs() untuk cipta berbilang direktori: Direktori tahap:

File file3 = new File("G://a//b//c");
        System.out.println(file3.mkdirs());   
//创建多级目录，如果没有存在则新建一个，并且返回True,如果存在了就返回false

Kemudian kita perlu menggunakan fungsi dalam aliran IO untuk memasukkan dan mengeluarkan fail:

Mula-mula perkenalkan empat strim yang biasa digunakan:

• strim input bait: InputStream

• bait Strim Output: OutputStream

• Strim input aksara: Reader

• Strim output aksara: Writer

Mengapakah terdapat dua aliran, bait dan aksara?

Dalam kod ASCII , satu huruf Inggeris (tanpa mengira huruf besar dan kecil) ialah satu bait dan satu aksara Cina ialah dua bait.

Dalam pengekodan UTF-8 , satu perkataan Inggeris ialah satu bait dan satu perkataan Cina ialah tiga bait.

Dalam pengekodan Unicode , satu perkataan Inggeris ialah satu bait dan satu perkataan Cina ialah dua bait.

Jadi kita tahu bahawa komputer membaca data satu demi satu Apabila fail mengandungi nombor atau bahasa Inggeris, kerana mereka semua menduduki satu bait, ia boleh dibaca secara normal.

Jadi bagaimana jika ia adalah aksara Cina? Ia menduduki sekurang-kurangnya dua bait Jika aksara Cina dipecah dan dibaca, pasti akan ada masalah dengan paparan.

Ringkasan: Jika data dibuka melalui perisian Notepad yang disertakan dengan Windows, dan kami masih boleh membaca kandungan di dalamnya, gunakan strim aksara, jika tidak gunakan strim bait. Jika anda tidak tahu jenis strim yang hendak digunakan, gunakan strim bait!

Berikut ialah jadual ringkasan nama kaedah yang sepadan dengan empat aliran:

Strim output Byte:

Kami menggunakan strim output bait untuk menulis ayat dalam fail abc.txt:

public class test01 {
    public static void main(String[] args) {

        try{
              //创建输出流对象：
            OutputStream fos = null;
            fos = new FileOutputStream("G://abc.txt");
            String str = "今天的博客是IO流";
            //先将需要写入的字符打散成数组：
            byte[] words = str.getBytes();
            //使用写入的功能
            fos.write(words);

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Selepas berjalan:

aliran input byte (baca dari fail ke konsol):

kita tahu bahawa jika fail mengandungi aksara Cina dan menggunakan aliran input byte, paparan pasti akan dihiasi fail kini Di dalam adalah empat perkataan "Saya suka China". >

public class test02 {
    public static void main(String[] args) {
        //创建字节输入流对象：
        InputStream fis = null;
        try{
            fis = new FileInputStream("G://abc.txt");
            int data;
            //fis.read()取到每一个字节通过Ascll码表转换成0-255之间的整数，没有值返回-1
            while((data=fis.read())!=-1){
                //(char) data 将读到的字节转成对应的字符
                //中文的字符是2+个字节组成
                System.out.print((char) data);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try{
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

字符输出流：

我们使用字符输出流给abc.txt文件里面写几句话：

public class test03 {
    public static void main(String[] args) {
        try{
            //使用字符输出流的FileWriter写入数据
            Writer fw = new FileWriter("G://abc.txt");
            fw.write("我们在学Java");
            fw.write("一起加油");
            fw.close(); //关闭资源
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

也没用问题，我们发现，使用字符流写中文汉字更方便。

字符输入流：

可以设置缓存流提高获取值的效率：

public class test04 {
    public static void main(String[] args) throws IOException {
        //创建字符输入流对象：
        Reader fr = null;
        try{
            fr = new FileReader("G:/abc.txt");
            //借助字符流对象创建了字符缓存区 把字符一个一个的取到后先放到缓存区
            //然后一起再读写到程序内存来，效率更高
            BufferedReader br = new BufferedReader(fr);
            //先去缓存区一行一行的读取
            String line = br.readLine();
            while(line != null){
                System.out.println(line);
                line = br.readLine();
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

当文件内的信息为多行的时候：