IO流

首先開篇立論什麼是IO流：設備之間的數據傳輸。java中對於數據的輸入(input)/輸出(output)操作以”流(stream)” 的方式進行，所以就叫IO流
但是在記輸入/輸出流之前，先記一個類：File類
File類能創建，刪除，重命名文件和目錄，但是不能修改（訪問）文件本身的內容，要修改問價的內容還得需要輸入/輸出流
File對象可以作爲參數傳遞給流的構造函數
常用的構造方法
public File(String pathname）
public File(String parent,String child) parent爲父路徑，child爲子路徑創建File對象
註釋：系統路徑分隔符，在UNIX中，此字段爲‘/’，在Windows中，爲‘\\’
舉個例子

```
package ligang.com;
import java.io.File;
public class FileTset {
public static void main(String[] args) {
    File file=new File("Hello World.txt ");//文件放在項目的目錄文件夾下
0   File file1 =new File("D\\AAA","1.txt");//文件放在指定的“D:AAA”目錄中
}
}

在寫IO流之前，我先把什麼叫輸入（input）/輸出（output）
看圖

文件是由字符或字節構成的，在此基礎上再分爲輸入流/輸出流的
所有的文件類都是在這個四個基類的基礎上擴展繼承的
看圖

FileInputStream(文件字節輸入流)
FileOutputStream(文件字節輸出流)
FileReader(文件字符輸入流)
FileWriter(文件字符輸出流）
來個例子

package ligang.com;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;

import org.omg.CORBA.PUBLIC_MEMBER;

public class FileText {


    public static void main(String[] args) {
        //FileOutputStream文件字節輸出流
        File file1=new File("Hello World");//創建文件
        FileOutputStream fos=null;//定義字節文件容器，剛開始爲空
        try {
            fos=new FileOutputStream(file1);
            byte [] b="i love my home i love my china".getBytes();
            fos.write(b);//向文件容器中寫入數據
        } catch (Exception e) {
        e.printStackTrace();
        }
        finally {
            try {
                fos.close();//gc進程管不了文件，所以文件得自己回收
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        //FileInputStream(文件字節輸入流)
        File file=new File("Hello World");
        //將此File類的對象作爲形參傳遞給InputStream的構造器中
        FileInputStream fis=null;
        try {
            fis = new FileInputStream(file);
            int i;
            //通過調用read（）方法將文件中的數據讀入
        while((i=fis.read())!=-1){
            System.out.print((char)i);
            }
        }catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                //關閉現有的流
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        //FileWriter輸入字符流
        Writer w=null;
        try {
            w=new FileWriter("1.txt");
            w.write("what's,your name?");
        } catch (IOException e1) {
            e1.printStackTrace();
        }
        finally{
            try {
                w.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        //FileReade輸出字符流
        Reader r = null;
        try {
            r = new FileReader("1.txt");
            System.out.println();
            int b = 0;
            while ((b = r.read()) != -1) {
                //輸出字符
                System.out.print((char)b);
            }

        }catch(FileNotFoundException e) {
            e.printStackTrace();
        }catch(IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if (r != null)  {
                    r.close();  
                }
            }catch(IOException e) {}    
        }



    }
    }

    顯示結果
    i love my home i love my china
    what's,your name?

緩衝流
主要是爲了提高效率而存在的，減少物理讀取次數
主要有
BufferedInputStream
BufferedOutputStream
BufferedReader
BufferedWriter
BufferedReader提供了實用方法readLine()，可以直接讀取一行，BufferWriter提供了newLine()可以寫換行符。

多記點點：爲什麼說緩衝流會提高效率
採用BufferedInputStream對InputStream進行裝飾，BufferedInputStream會將數據先讀到緩存裏，Java程序再次讀取數據時，直接到緩存中讀取，減少Java程序物理讀取的次數，提高性能
採用BufferedOutputStream對FileOutputStream進行裝飾，每次寫文件的時候，先放到緩存了，然後再一次性的將緩存中的內容保存到文件中，這樣會減少寫物理磁盤的次數，提高性能
其他的同理可證^_^！！！
看代碼

package ligang.com;

import java.io.*;

import org.omg.CORBA_2_3.portable.OutputStream;

public class Bufferd {
public static void main(String[] args) {
/*
 * 用BufferedInputStream與BufferedOutputStream實現文件的快速複製
 */
    InputStream is=null;
    OutputStream os=null;
    try {
        BufferedInputStream fis=new BufferedInputStream(new FileInputStream("1.txt"));
        BufferedOutputStream fos=new BufferedOutputStream(new FileOutputStream("1.txt.bak"));
        int b = 0;
        try {
            while ((b =fis.read()) != -1) {
                fos.write(b);
            }
            fos.flush();
            System.out.println("文件複製完畢！！");
        } catch (IOException e) {
            e.printStackTrace();
        }
        finally {
            try {
                if(fos!=null)
                fos.close();
                if(fis!=null)
                    fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

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

    /**
     * 用BufferedReader與BufferedWriter實現文件的快速複製
     */

    BufferedReader is1 = null;
    BufferedWriter os1= null;
    try {
        is1= new BufferedReader(new FileReader("Hello World"));
        os1= new BufferedWriter(new FileWriter("12.txt"));
        String s = null;
        while ((s = is1.readLine()) != null) {
            os1.newLine();
            os1.write(s);
            //可以採用如下方法換行
            os1.newLine();
        }
        System.out.println("文件複製完畢！");
    }catch(FileNotFoundException e) {
        e.printStackTrace();
    }catch(IOException e) {
        e.printStackTrace();
    }finally {
        try {
            if (is1 != null)    {
                is1.close();    
            }
            if (os1!= null) {
                //在close前會先調用flush
                os1.close();    
            }
        }catch(IOException e) {
            e.printStackTrace();
        }   
    }
}}

簡單的複製操作，一個用緩衝字節流實現，一個用緩衝字符流實現，很簡單的操作，卻讓我摸了好久。。。。
轉換流：InputStreamReader主要是將字節流輸入流轉換成字符輸入流
OutputStreamWriter主要是將字節流輸出流轉換成字符輸出流

舉個小例子

package ligang.com;

import java.io.*;

import javax.activation.FileDataSource;

public class zhuanhuanliu {
    /**
     * 將字節流輸入流轉換成字符輸入流
     */
    public static void main(String[] args) {
        BufferedReader fis=null;
        try {
            fis=new BufferedReader( 
                    new InputStreamReader( 
                            new FileInputStream("12.txt")));//首先取得輸入字節流，再轉成輸入字符流，最後轉換成輸出字符緩衝流
            String s=null;
        try {
            while((s=fis.readLine())!=null){
                System.out.println(s);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
                } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        finally{
            try {
                if(fis!=null)
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }


        /**
         * 將字節流輸出流轉換成字符輸出流
         */
        BufferedWriter fis0 = null;
        try {
            fis0=new BufferedWriter(
                         new OutputStreamWriter(
                                 new FileOutputStream("1.txt")));//首先取得字節輸出流，再轉成字符輸出流，最後轉成字符緩衝輸出流
            try {
                fis0.write("my name is xiao ganggang");
                fis0.newLine();
                fis0.write("nice to me to you!");
            } catch (IOException e) {
                e.printStackTrace();
            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        finally{
    try {
        if(fis0!=null)
        fis0.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
        }
    }
}

System.out其實對應的就是PrintStream，默認輸出到控制檯，我們可以重定向它的輸出，可以定向到文件，也就是執行System.out.println()不輸出到屏幕，而輸出到文件
舉個小例子

package ligang.com;

import java.io.*;

import javax.activation.FileDataSource;

public class rou {
    public static void main(String[] args) {
        OutputStream os = null;
        try {
            os=new FileOutputStream("1.txt");
            System.setOut(new PrintStream(os));`//將輸出改爲指定的文件`
            System.out.println("世界你好，世界午安！！");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }finally {
            try {
                if (os!=null) {
                    os.close();
                }

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

    }

}

也可以將屏幕的輸入到文件中
舉個小例子

package ligang.com;

import java.io.*;

import javax.activation.FileDataSource;

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

        OutputStream os1 = null;
        BufferedReader os = null;
        try {
            os1=new FileOutputStream("1.txt");
            System.setOut(new PrintStream(os1));//將輸出改爲指定的文件
        } catch (FileNotFoundException e1) {
            e1.printStackTrace();
        }
        os=new BufferedReader(
                new InputStreamReader(System.in));//將從鍵盤得到數據放到指定文件中
        String s=null;
        try {
            while((s=os.readLine())!=null){
                System.out.println(s);//這裏相當與本是輸出到終端的，但現在輸出到os1的文件中去

                if("w".equals(s))
                    break;  
            }
        } catch (IOException e) {
            e.printStackTrace();
        }       
        finally {
            try {
                if(os!=null)
                os.close();
                if(os1!=null)
                    os1.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}

還有對象流。。貌似有點多了，
對象流可以將Java對象轉換成二進制寫入磁盤，這個過程通常叫做序列化，並且還可以從磁盤讀出完整的Java對象，而這個過程叫做反序列化。
對象流主要包括：ObjectInputStream和ObjectOutputStream

而實現序列化和反序列化，就需要實現java.io.Serializable 接口，但他沒有任何方法，只是一種標記接口
我不想寫了。。。
到這兒

javac--

發佈了40 篇原創文章 · 獲贊 3 · 訪問量 1萬+

私信關注

類和對象淺談（1）

安全衛士第二天筆記

類和對象淺談（3）

異常處理（Exception）

集合篇(Collection)

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結