20、java的IO流

時間  2019-11-22
標籤 java 欄目 Java 简体版
原文   原文鏈接

IO流：進行輸入輸出操做。java

輸入流：把數據從其餘設備上讀取到內存中的流數組

輸出流：把數據從內存中寫出到其餘設備上的流app

數據的類型分爲：字節流和字符流編碼

 

一切皆爲字節：一切文件數據在存儲時都是以二進制數字的形式保存，都是一個一個的字節，那麼傳輸時同樣如此。因此，字節流能夠傳輸任意文件數據。在操做流的時候，咱們要時刻明確，不管使用什麼樣的流對象，底層傳輸的始終爲二進制數據對象

 

字節輸出流：OutputStream繼承

java.io.OutputStream:此抽象類是表示輸出字節流的全部類的超類索引

定義了一些子類共性的成員方法：接口

public void close（）；關閉此輸出流並釋放與此流相關聯的任何系統資源內存

public void flush（）；刷新此輸出流並強制任何緩衝的輸出字節被寫出資源

public void write（byte[] b）;將b.length字節從指定的字節數組寫入此輸出流

public void write （byte[] b,int off,int len）;從指定的字符數組寫入len字節，從偏移量off開始輸出到此輸出流

public abstract void write（int b）;將指定的字節輸出流

 

java.io.FileOutputStream extends OutputStream :把內存中的數據寫入到硬盤的文件中

構造方法：FileOutputStream(String name)建立一個向具備指定名稱的文件中寫入數據的輸出文件流

               FileOutputStream(File file)建立一個向指定File對象表示的文件中寫入數據的文件輸出流

               FileOutputStream(String name ,boolean appent), 指定路徑是否覆蓋重寫

                參數：String name：目的地是一個文件的路徑

                         File file：目的地是一個文件

                構造方法的做用：一、建立一個FileOutputStream 對象

                                        二、會根據構造方法中傳遞的文件/文件路徑，建立一個空的文件

                                        三、會把FileOutputStream對象指向建立好的文件

寫入數據的原理：Java程序->JVM->OS->OS調用寫數據的方法->把數據寫入到文件中

字節輸出流的使用步驟：一、建立一個FileOutputStream對象，構造方法中傳遞寫入數據的目的地

                                 二、調用FileOutputStream對象中的方法write，把數據寫入到文件中

                                 三、釋放資源

public class Demo {

    public static void main(String[] args)throws Exception {
        File file = new File("c/a.txt");
        FileOutputStream os= new FileOutputStream(file,true);
        byte[] in = new byte[]{97,98,99,100};
        os.write(97);
        os.write(in,0,in.length);
        os.flush();
        os.close();

    }

字節輸入流：InputStream

Java.io.InputStream:此抽象類是表示字節輸入流的全部類的超類

定義了全部子類共性的方法：一、int read()從輸入流中讀取數據的下一個字節

                                       二、int read(byte[] b)從輸入流中讀取必定數量的字節，並將其存儲到緩衝區數組b中

                                       三、void close（）關閉此輸入流並釋放與該流關聯的全部系統資源

java.io.FileInputStream extends InputStream: 文件字節輸入流

做用：把硬盤文件中的數據，讀取到內存中使用

構造方法：FileInputStream（String name）

               FileInputStream（File file）

構造方法做用：一、會建立一個FileInputStream對象

                     二、會把FileInputStream對象指向構造方法要讀取到文件

                     

讀取數據的原理：Java程序->JVM->OS->OS讀取數據的方法-> 讀取文件

字節輸入流的使用步驟：一、建立FileInputStream對象，構造方法中綁定要讀取的數據源

                                 二、使用FileInputStream對象中的方法read，讀取文件

                                 三、釋放資源

public class Demo {

    public static void main(String[] args)throws Exception {
        File file = new File("c/a.txt");
        FileInputStream is = new FileInputStream(file);
        byte[] buffer=  new byte[1024];
        int len = is.read(buffer);
        System.out.println(len);
        System.out.println(Arrays.toString(Arrays.copyOf(buffer,len)));
        is.close();

    }


}

字符流：

java.io.Reader:字符輸入流，是字符輸入流的最頂端的父類

共性的成員方法：int read()讀取單個字符並返回

                        int read(char [] cbuf)一次讀取多個字符，將字符讀入數組

                        void close()關閉該流並釋放與之關聯的全部資源

 

java.io.FileReader extends InputStreamReader extends Reader

FileReader:文件字符輸入流

做用：把硬盤文件中的數據以字符的方法讀取到內存中

構造方法：FileReader（String fileName）

               FileReader（File file）

參數：String fileName：文件路徑

         File file ：一個文件

FileReader構造方法的做用：一、建立一個FileReader對象

                                       二、會把FileReader對象指向要讀取的文件

字符輸入流的使用步驟：一、建立FileReader對象，構造方法中綁定要讀取的數據源

                                 二、使用FileReader對象中的方法read讀取文件

                                 三、釋放資源

示例代碼

public class Demo {

    public static void main(String[] args)throws Exception {
        FileReader reader = new FileReader(new File("c/a.txt"));
        int len = 0;
        char [] chars =new char[1024];
        System.out.println(reader.read());
        System.out.println(reader.read(chars));
        System.out.println(Arrays.toString(Arrays.copyOf(chars,9)));
        reader.close();

    }

java.io.write:字符輸出流，是全部字符輸出流的最頂層的父類，是一個抽象類

共性成員方法：void wirte(int c)寫入單個字符

                     void write（char[] cbuf）寫入字符數組

                    abstract void write (char [] cbuf,int off,int len) 寫入字符數組的某一部分，off數組的開始索引，len寫的字符個數

                    void write(String str)寫入字符串

                    void write(String str,int off,int len)寫入字符串的某一部分，off字符串的開始索引，len寫的字符個數

                    void flush（）刷新該流的緩衝

                    void close（）關閉此流，可是要先刷新它

 

java.io.FileWriter extends OutputStream extends Writer

Filewriter:文件字符輸出流

做用：把內存中字符數據寫入到文件中

構造方法：FileWriter（File file）根據給定的File對象構造一個FileWriter對象

               FileWriter(String fileName)根據給定的文件名構造一個FileWriter 對象

               參數：寫入數據的目的地

                構造方法做用：一、會建立一個FileWriter對象

                                     二、會根據構造方法中傳遞的文件/文件路徑，建立文件

                                     三、會把FileWriter對象指向建立好的文件

字符輸出流的使用步驟：一、建立FileWriter對象，構造方法中綁定要寫入數據的目的地

                                 二、使用FileWriter中的方法write，把數據寫入到內存緩衝區（字符轉換成字節的過程）

                                 三、使用FileWriter中的方法flush，把內存緩衝區中的數據，刷新到文件中

                                 四、釋放資源

示例代碼：

public class Demo {

    public static void main(String[] args)throws Exception {
        FileWriter fw = new FileWriter(new File("c/a.txt"),true);
        fw.write("你好");
        fw.flush();
        fw.close();
    }


}

properties:表示一個持久的屬性集，properties可保存在流中或從流中加載。屬性列表中每一個鍵及其對應指都是一個字符串，惟一和IO流相結合的集合

示例代碼：

public class Demo {

    public static void main(String[] args)throws Exception {
        FileWriter fw = new FileWriter(new File("c/a.txt"),false);
        Properties pp =new Properties();
        pp.setProperty("讀者A","做品A");
        pp.setProperty("讀者B","做品B");
        Set<Object> set = pp.keySet();
        for (Object obj:set) {
            System.out.println(pp.getProperty((String)obj));
        }

        pp.store(fw,"save");
        fw.close();
        Properties pp2 = new Properties();
        pp2.load(new FileReader(new File("c/a.txt")));
        Set<Object> set2 = pp2.keySet();
        for (Object obj:set2) {
            System.out.println(pp2.getProperty((String)obj));
        }


    }


}

 注意：一、字符流能夠寫中文，字節流不能，讀也同樣

          二、後面位註釋，大多用「」

          三、鍵值對存儲在文件，能夠用等號或空格鏈接

          四、文件中的內容能夠用#註釋，註釋過的內容不會被讀取

 

緩衝流：基本流的一種加強

緩衝流的基本原理：在建立對象時，會建立一個內置的默認大小的緩衝區數組，經過緩衝區讀寫，減小系統IO次數，從而提升讀寫的效率

字節緩衝流：BufferedInputStream，BufferedOutputStream

字符緩衝流：BufferedReader，BufferedWriter

 

java.io.BufferedOutputStream extends OutputStream

構造方法：BufferedOutputStream(OutputStream out)

               BufferedOutPutStream(OutputStream out,int size)

 使用步驟：一、建立FileOutputStream對象，構造方法中綁定要輸出的目的地

                二、建立BufferedOutputStream對象，構造方法中傳遞FileOutputStream對象，提升FileOutputStream效率

                三、使用BufferedOutputStream對象中的方法write，把數據寫入到內部緩衝區中

                四、使用BufferedOutputStream對象中的方法flush，刷新到文件中

                五、釋放資源

public class Demo {

    public static void main(String[] args)throws Exception {
        FileOutputStream fos= new FileOutputStream(new File("c/a.txt"));
        BufferedOutputStream bfos= new BufferedOutputStream(fos);
        bfos.write("你好嗎".getBytes());
        bfos.close();
        fos.close();


    }


}

java.io.BufferedInputStream extends InputStream

構造方法：BufferedInputStream（InputStream in）

               BufferedInputStream（InputStream in，int size）

使用步驟：一、建立FileInputStream對象，構造方法中綁定要讀取到數據源

               二、建立BufferedInputStream對象，構造方法中傳遞FileInputStream對象，提升FileInputStream讀寫的讀取效率

               三、使用BufferedInputStream對象中的方法read，讀取文件

               四、釋放資源

複製文件示例代碼：

public class Demo {

    public static void main(String[] args)throws Exception {
        FileOutputStream fos= new FileOutputStream(new File("c/a.txt"));
        BufferedOutputStream bfos= new BufferedOutputStream(fos);
        bfos.write("你很差".getBytes());
        bfos.close();
        fos.close();

        FileInputStream fis = new FileInputStream(new File("c/a.txt"));
        BufferedInputStream bfis = new BufferedInputStream(fis);
        FileOutputStream fos2 = new FileOutputStream(new File("c/b.txt"));
        BufferedOutputStream bfos2= new BufferedOutputStream(fos2);
        int len =0;
        byte [] buffer = new byte[1024];
        while ((len=bfis.read(buffer))!=-1){
            bfos2.write(buffer,0,len);
            System.out.println(len);
            System.out.println(Arrays.toString(Arrays.copyOf(buffer,len)));
        }
        bfos2.flush();
        bfos2.close();
        fos2.close();
        bfis.close();
        fis.close();


    }


}

java.io.BufferedWriter extends Writer

構造方法:BufferedWriter(Writer out)

             BufferedWriter(Writer out,int size)

特有的成員方法：void newLine（）；

使用步驟：一、建立字符緩衝輸出流對象，構造方法中傳遞字符輸出流

               二、調用字符緩衝輸出流中的方法write，把數據寫入到內存緩衝區中

               三、調用字符緩衝輸出流中的方法flush，把內存緩衝區中的數據，刷新到文件中

               四、釋放資源

 

java.io.BufferedReader extends Reader

構造方法：BufferedReader(Reader in)

               BufferedReader(Reader in ,int size)

特有方法：String readLine（）；讀取一個文本行

使用步驟：一、建立一個字符緩衝輸入流對象，構造方法中傳遞字符輸入流

               二、使用字符緩衝輸入流對象中的方法read/readLine讀取文本

               三、釋放資源

public class Demo {

    public static void main(String[] args)throws Exception {
        File file  = new File("c/a.txt");
        BufferedReader br = new BufferedReader(new FileReader(file));
        File file1 = new File("c/b.txt");
        BufferedWriter bw = new BufferedWriter(new FileWriter(file1));
        int len = 0;
        char[] buffer = new char[1024];
        while ((len = br.read(buffer))!=-1){
            bw.write(buffer,0,len);
        }
        bw.flush();
        bw.close();
        br.close();
    }


}

轉換流：能夠指定編碼表

java.io.OutputStreamWriter extends Writer

構造方法：OutputStream(OutputStream)建立使用默認字符編碼

               OutputStream(OutputStream,string charsetName)建立指定字符集的

使用步驟：一、建立OutputStreamWriter對象，構造方法中傳遞字節輸出流和指定的編碼表名稱

               二、使用OutputStreamWriter對象中的方法write，把字符轉換文字節存儲緩衝區中

               三、使用OutputStreamWriter對象中的方法flush，把內存緩衝區中的字節刷新到文件中

               四、釋放資源

 

java.io.InputStreamReader extends Reader

構造方法：InputStreamReader(InputStream in )建立一個使用默認字符集的字節輸入流

               InputStreamReader(InputStream in,String charsetName)建立使用指定字符集的字節輸入流

使用步驟：一、建立InputStreamReader對象，構造方法中傳遞字節輸入流和指定的編碼表名稱

               二、使用InputStreamReader對象中的方法read讀取文件

               三、釋放資源

示例代碼：

public class Demo {

    public static void main(String[] args)throws Exception {
        File file  = new File("c/a.txt");
        InputStreamReader isr = new InputStreamReader(new FileInputStream(file),"UTF-8");
        File file1 = new File("c/b.txt");
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(file1),"UTF-8");
        int len = 0;
        char[] buffer = new char[1024];
        while ((len = isr.read(buffer))!=-1){
            osw.write(buffer,0,len);
        }
        osw.flush();
        osw.close();
        isr.close();
    }


}

序列化流：

序列化：把對象以流的方式，寫入到文件中保存，叫作對象的序列化

反序列化：把文件中保存的對象，以流的方式讀取出來，叫作對象的反序列化

 

java.io.ObjectOutputStream extends OutputStream

構造方法：ObjectOutputStream(OutputStream out)

特有的成員方法：void writerObject（Object obj）

使用步驟：一、建立ObjectOutputStream對象，構造方法中傳遞字節輸出流

               二、使用ObjectOutputStream對象中的方法writeObject，把對象寫入到文件中

               三、釋放資源

 

java.io.ObjectInputStream extends InputStream

構造方法：ObjectInputStream(InputStream in)

特有成員方法：Object readObject()

使用步驟：一、建立ObjectInputStream對象，構造方法中傳遞字節輸入流

               二、使用ObjectInputStream對象中的方法readObject讀取保存對象的文件

               三、釋放資源

 

注意：序列化和反序列的對象類必須實現Serializable接口，且存在

 

擴展：一、被static修飾成員變量不能被序列化，同理transient（瞬態關鍵字），被修飾的成員變量不能被序列化，可是有不具有靜態成員變量的屬性

         二、能夠經過private static final long serialVersionUID = 1L; 的格式手動添加序列號

 

示例代碼：

public class Demo {

    public static void main(String[] args)throws  Exception {
        ObjectOutputStream oos =new ObjectOutputStream(new FileOutputStream(new File("c/b.txt")));
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("c/b.txt")));

        Person p1 = new Person("讀者A",18);
        Person p2 =new Person("讀者B",19);

        ArrayList<Person> list = new ArrayList<>();
        list.add(p1);
        list.add(p2);

        oos.writeObject(list);

        Object o = ois.readObject();
        ArrayList<Person> list1 =(ArrayList<Person>)o;

        for (Person p:list1) {
            System.out.println(p);
        }

    }


}

打印流：

java.io.PrintStream

特色：一、只負責數據的輸出，不負責數據的讀取

         二、與其餘的輸出流不一樣，PrintStream永遠不會拋出IOException

         三、特有方法：void print（任意類型的值）

                             void print （任意類型的值並換行）

構造方法：PrintStream（File file）輸出目的地是一個文件

               PrintStream（OutputStream out）輸出目的地是一個字節輸出流

               PrintStream（String fileName）輸出目的地是一個文件路徑

注意：若是使用繼承自父類的write方法寫數據，那麼查看數據的時候會查詢編碼表 97->a

         若是使用本身特有的方法print方法寫數據，學的數據原樣輸出

public class Demo {

    public static void main(String[] args)throws  Exception {
        PrintStream ps = new PrintStream(new File("c/a.txt"));
        ps.print("原樣打印");
    }

}
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程