Java File類與文件IO流總結

1.File類

　　File類被定義爲「文件和目錄路徑名的抽象表示形式」，這是由於File類既能夠表示「文件」也能夠表示「目錄」，他們都經過對應的路徑來描述。經過構造函數建立一個File類對象，則該對象就是指定文件的引用，能夠經過該對象對文件操做。經過File對象，能夠獲取文件的屬性值（文件大小，可否讀寫，最後修改時間等）。File對象不能對文件進行讀取和寫入的操做，若是想要對文件進行讀寫，那麼要使用IO流。

　　如下函數是File類使用示例。它的功能是，將一個文件的路徑傳入函數，函數判斷此路徑是否有文件，若是此路徑沒有指向任何文件或目錄，那麼判斷這個路徑裏是否有"."，若是有，那麼建立這個路徑的文件，若是沒有，建立這個目錄。若是有文件，則判斷此路徑是文件仍是目錄，若是是文件，則顯示它的一系列屬性，若是是目錄，那麼後續用遞歸的方式顯示它及其子目錄下的文件。文件路徑有兩種表示方法，一種是絕對路徑，一種是相對路徑。絕對路徑是帶盤符的，相對路徑是相對於當前目錄的路徑。

 1 public void testFile(String path){
 2         File file = new File(path);
 3         if(file.exists()){
 4             //若是文件存在，再獲取屬性值
 5         //TODO:獲取文件大小
 6             if(file.isFile()){
 7         System.out.println("文件大小"+file.length());
 8         
 9         //TODO:文件是否可讀，可寫
10         System.out.println("是否能寫："+file.canWrite());
11         System.out.println("是否可讀："+file.canRead());
12         //TODO:獲取最後修改時間
13         //Date date = new Date();
14         SimpleDateFormat sfm = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
15         String str = sfm.format(file.lastModified());
16         System.out.println("文件最後修改時間："+str);
17         
18             }
19             else if(file.isDirectory()){
20                 System.out.println("sdfsf");
21                 this.listFiles(file);
22                 //這個函數遞歸列出全部子目錄及文件，在後續會有說起
23             }
24     }else{
25         System.out.println("文件不存在"+path);
26         if(path.contains(".")){
27             try {
28                 //建立文件
29                 file.createNewFile();
30             } catch (IOException e) {
31                 // TODO Auto-generated catch block
32                 e.printStackTrace();
33             }
34         }else{
35 
36             //建立目錄：file.mkdir();    建立單目錄
37             //file.mkdirs();循環建立目錄，沒有的話能夠建立上層目錄
38             file.mkdirs();
39         }
40     }
41         }

　　如下是遞歸調用listFiles(file)重載遞歸的函數實現。思想是先用listFiles獲取當前目錄下的全部列表，顯示全部列表的名字，若是當前列表仍是個目錄，那麼調用自身，進行子目錄的遍歷輸出。

 1 public void listFiles(File file){
 2         File [] files = file.listFiles();//獲取當前目錄下全部列表
 3         for(File one :files){
 4             System.out.println("名字：" + one.getName());
 5             //TODO:若是是目錄，繼續遍歷列出
 6             if(one.isDirectory()){
 7                 listFiles(one);
 8             }
 9         }
10     }

2.字節流

　　字節流抽象類是InputStream和OutputStream，它們的實現的子類是FileInputStream和FileOutputStream。此處咱們使用FileInputStream和FileOutPutStream解決文件讀寫問題。讀入的思想是當須要把文件的內容讀入程序時，要申明一個Byte字節數組，將FileInputStream對象讀入數組。當沒讀完的時候，返回讀取的長度。當讀完的時候，返回-1。當使用完流的時候，要記得關閉流。FileOutputStream寫的時候也是須要將寫的東西轉換爲Byte數組寫入文件，寫完關閉流。

 1 public static void Input(String path) throws IOException {
 2         //構建一個InputStream對象    一、打開流
 3         FileInputStream fin = new FileInputStream(path);
 4         byte[] buf = new byte[1024];
 5         int iread = 0;//讀取的實際長度
 6         //TODO:二、讀取文件內容
 7         while((iread = fin.read(buf)) != -1){
 8             System.out.println(new String(buf));
 9             System.out.println("*****************我已讀"+iread+"**************");
10         }
11         //TODO:三、關閉流
12         fin.close();
13     }
14     public static void Output(String path) throws IOException {
15         //1.打開
16         FileOutputStream oup = new FileOutputStream(path);
17         String string = "道可道很是道";
18         //2.寫
19         oup.write(string.getBytes());
20         //3.關閉
21         oup.close();
22     }

　　當讀完文件以後馬上要寫的時候，咱們要注意一個問題，就是最後一次存入的時候，可能已經數組裏的內容比最後一次讀入的多，那麼就會最後一次多輸出一些上一次讀入數組時存的數據。爲了解決這個問題，咱們採用三個參數的write方式，避免出現亂碼。

public static void ReadAndWrite() throws IOException{
        //一、打開
        FileInputStream fin = new FileInputStream("d:\\uft.txt");
        FileOutputStream fout = new FileOutputStream("d:\\www.txt");
        //一個讀一個寫，一塊一塊操做
        int iread = 0;
        byte [] buf = new byte[200];
        while((iread = fin.read(buf))!=-1){
            fout.write(buf,0,iread);
            System.out.println(new String(buf));
            }//關閉
        fin.close();
        fout.close();
    }

3.字符流

　　字符流：操做的數據單元是16位字符，Reader、Writer  文本文件。思想跟字節流相似，不一樣的是咱們使用的字符流FileReader類繼承於Reader接口，字符流FileWriter類繼承於Writer接口。具體的操做步驟也是打開流，操做流，關閉流的步驟。

 1 public static void Fileread(String path) throws IOException{
 2     //一、打開流
 3     FileReader fin = new FileReader(path);
 4     //二、
 5     char[] buf = new char[100];//讀取的數據
 6     int iread = 0;
 7     while((iread = fin.read(buf)) !=-1){
 8         String str = new String(buf);
 9         System.out.println("[讀了"+iread+"]"+str.substring(0, iread));
10     }
11     //三、
12     fin.close();
13     }
14     public static void testOut(String path,String str) throws IOException{
15         FileWriter fr = new FileWriter(path,true);
16         fr.write(str);
17         fr.close();
18         System.out.println("*******************輸出完畢！！！*********************");
19     }

　　當須要讀完了立馬就輸入文件的時候也是須要注意以前字節流的那個問題，寫的時候要用那個三個參數的write函數，否則會將數組裏的全部東西存入文件，會存入多餘數據。

public static void testIO(String inPath,String outPath) throws Exception{
        //d:\紅鯉魚.txt    ->d:\紅鯉魚.out2.txt
        //1
        FileReader fin = new FileReader(inPath);
        FileWriter fout = new FileWriter(outPath);
        //2
        char[] buf = new char[100];//讀取的數據
        int iread = 0;
        while((iread = fin.read(buf))!=-1 ){
            String str = new String(buf);
            fout.write(buf,0,iread);
            System.out.println("["+iread+"]"+str.substring(0, iread));
        }
        //3
        fin.close();
    }

4.帶緩衝的字符流

　　BufferedReader和BufferedWriter創建的時候須要傳入一個Writer或者Reader，構造函數也能夠指定緩衝區大小。也就是，BufferedReader是高層流，FileReader是底層流。最後要關閉的時候，要先關閉高層流再關閉底層流。

public static void testOut2() throws IOException{
        StringWriter out = new StringWriter();
        BufferedWriter fout = new BufferedWriter(out,3);
        String string = "ABCDEFG哈哈哈";
        for(char c:string.toCharArray()){
            fout.write(c);
            System.out.println(out.getBuffer().toString());
        }
    }
    
    public static void testIoBuffer(String path1,String path2) throws Exception{
        FileReader in = new FileReader(path1);
        BufferedReader fin = new BufferedReader(in);
        FileWriter out = new FileWriter(path2,true);
        BufferedWriter fout = new BufferedWriter(out);
        String s;
        while((s =fin.readLine())!=null){
            fout.write(s);
            fout.newLine();
            System.out.println(s);
        }
        //關閉
        fout.close();
        fin.close();
        out.close();
        in.close();
    }