詳解JAVA I/O

剛開始學Java時候，一直搞不懂Java裏面的io關係，在網上找了很多大多都是給個結構圖草草描述也看的不是很懂。而且沒有結合到java7 的最新技術，所以自己結合API來整理一下，有錯的話請指正，也希望大家提出寶貴意見。

首先看個圖：（如果你也是初學者，我相信你看了真個人都不好了，想想java設計者真是煞費苦心啊！）

Java I/O系統的類實在是太多了，這裏我們只學習一些基本的和常用的，相信能夠掌握這些就可以解決我們以後的普通應用了

 什麼是數據流（字節流）                                                                                                                                                                      

數據流是指所有的數據通信通道；

有兩類流，InputStream and OutputStream。

Java中每一種流的基本功能依賴於它們InputStream 用於read,OutputStream 用於write, 讀和寫都是相對與內存說的，讀就是從其他地方把數據拿進內存，寫就是把數據從內存推出去
這兩個都是抽象類，不能直接使用

InputStream 的方法有：                                                                                                                             

1.read() ：從流中讀入數據 有3中方式：
2.int read()： 一次讀一個字節
3.int read(byte[]) ：讀多個字節到數組中
4.int read(byte[],int off,int len) ：指定從數組的哪裏開始，讀多長
5.skip() ：跳過流中若干字節
6.available() ：返回流中可用字節數，但基於網絡時無效，返回0
7.markSupported()： 判斷是否支持標記與復位操作
8.mark() ：在流中標記一個位置，要與markSupported()連用
9.reset() ：返回標記過的位置
10.close() ：關閉流

OutputStream 的方法:                                                                                                                               

1.write(int) ：寫一個字節到流中
2.write(byte[])： 將數組中的內容寫到流中
3.write(byte[],int off,int len)： 將數組中從off指定的位置開始len長度的數據寫到流中
4.close() ：關閉流
5.flush() ：將緩衝區中的數據強制輸出

File 類                                                                                                                                                      

File 可以表示文件也可以表示目錄，File 類控制所有硬盤操作
構造器：
1.File(File parent,String child)： 用父類和文件名構造
2.File(String pathname) ：用絕對路徑構造
3.File(String parent,String child)： 用父目錄和文件名構造
4.File(URI uri) ：用遠程文件構造
常用方法：

-----------------------------------------------------------------------------------------------------------------------------------------------------------

1.boolean createNewFile();

2.boolean exists();

例子：
//建立 test.txt 文件對象，判斷是否存在，不存在就創建

import java.io.*;

public class CreateNewFile{
    public static void main(String args[]){
      File f=new File("test.txt");
      try{
         if(!f.exists())
            f.createNewFile();
         else
           System.out.println("exists");
        }catch(Exception e){
         e.printStackTrace();
        }
    }
}

---------------------------------------------------------------------------------------------------------------------------------------------------------

3.boolean mkdir()/mkdirs()

4.boolean renameTo(File destination)
例子：//看一下這 mkdir()/mkdirs() 的區別和 renameTo 的用法

import java.io.*;
public class CreateDir{
    public static void main(String args[]){
       File f=new File("test.txt");
       File f1=new File("Dir");
       File f2=new File("Top/Bottom");
       File f3=new File("newTest.txt");
       try{
         f.renameTo(f3);
          f1.mkdir();
          f2.mkdirs();
       }catch(Exception e){
         e.printStackTrace();
       }
    }
}

--------------------------------------------------------------------------------------------------------------------------------------------------------------

String getPath()/getAbsolutePath()

String getParent()/getName()

例子：//硬盤上並沒有parent 目錄和 test.txt 文件，但我們仍然可以操作，因爲我們創建了他們的對象，是對對象進行操

import java.io.*;
public class Test{
    public static void main(String args[]){
        File f=new File("parent/test.txt");
        File f1=new File("newTest.txt");
        try{
           System.out.println(f.getParent());
           System.out.println(f.getName());
           System.out.println(f1.getPath());
           System.out.println(f1.getAbsolutePath());
          }catch(Exception e){
             e.printStackTrace();
          }
      }
}

----------------------------------------------------------------------------------------------------------------------------------------------------------

String list[] //顯示目錄下所有文件
long lastModified() //返回 1970.1.1 到最後修改時間的秒數
boolean isDirectory()
例子：//列出目錄下的所有文件和目錄，最後修改時間，是目錄的後面標出<DIR>,是文件的後面標出文件長度

import java.io.*;
import java.util.*;
public class Dir{
     public static void main(String args[]){
          File f=new File("Dir");
          String[] listAll=null;
          File temp=null;
          try{
              listAll=f.list();
              for(int i=0;i<listAll.length;i++){
                   temp=new File(listAll<i>);
                   System.out.print(listAll<i>+"\t");
                   if(temp.isDirectory())
                         System.out.print("\t<DIR>\t");
                   else
                     System.out.print(temp.length()+"\t");
                     System.out.println(new Date(temp.lastModified()))
           }
         }catch(Exception e){
             e.printStackTrace();
        }
    }
}

文件流的建立                                                                                                                                                                               
File f=new File("temp.txt");
FileInputStream in=new FileInputStream(f);
FileOutputStream out=new FileOutputStream(f);
例子：文件拷貝

import java.io.*;
public class Copy{
public static void main(String args[]){
     FileInputStream fis=null;
     FileOutputStream fos=null;
     try{
        fis=new FileInputStream("c2.gif");
        fos=new FileOutputStream("c2_copy.gif");
        int c;
        while((c=fis.read()) != -1)
            fos.write(c);
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            if(fis != null) try{ fis.close(); }catch(Exception e){ e.printStackTrace(); }
            if(fos!= null) try{ fos.close(); }catch(Exception e){ e.printStackTrace(); }
        }
    }
}

<span style="background-color: rgb(0, 102, 0);"><span style="color:#FFFFFF;"><strong>
</strong></span></span>

緩衝區流                                                                                                                                                                                             
BufferedInputStream
BufferedOutputStream
他們是在普通文件流上加了緩衝的功能，所以構造他們時要先構造普通流
例子：文件拷貝的緩衝改進

import java.io.*;
public class Copy{
   public static void main(String args[]){
         BufferedInputStream bis=null;
         BufferedOutputStream bos=null;
         byte buf[]=new byte[100];
         try{
             bis=new BufferedInputStream(new FileInputStream("persia.mp3"));
             bos=new BufferedOutputStream(new FileOutputStream("persia_copy.mp3"));
             int len=0;
             while( true ){
                   len=bis.read(buf);
                   if(len<=0) break;
                   bos.write(buf,0,len);
             }
             bos.flush();//緩衝區只有滿時纔會將數據輸出到輸出流，用flush()將未滿的緩衝區中數據強制輸出
          }catch(Exception e){
             e.printStackTrace();
          }finally{
             if(bis != null) try{ bis.close(); }catch(Exception e){ e.printStackTrace(); }
             if(bos!= null) try{ bos.close(); }catch(Exception e){ e.printStackTrace(); }
         }
    }
}

原始數據流                                                                                                                                        

DataInputStream
DataOutputStream
他們是在普通流上加了讀寫原始型數據的功能，所以構造他們時要先構造普通流
方法：
readBoolean()/writeBoolean()
readByte()/writeByte()
readChar()/writeByte()
......
例子：//這個流比較簡單，要注意的就是讀時的順序要和寫時的一樣

import java.io.*;
public class DataOut{
     public static void main(String args[]){
     DataOutputStream dos=null;
     try{
         dos=new DataOutputStream(new FileOutputStream("dataout.txt"));
         dos.writeInt(1);
         dos.writeBoolean(true);
         dos.writeLong(100L);
         dos.writeChar('a');
      }catch(Exception e){
         e.printStackTrace();
      }finally{
         if(dos!=null)
         try{
            dos.close();
         }catch(Exception e){
      }
    }
  }
}

import java.io.*;
public class DataIn{
     public static void main(String args[]){
     DataInputStream dis=null;
     try{
        dis=new DataInputStream(new FileInputStream("dataout.txt"));
        System.out.println(dis.readInt());
        System.out.println(dis.readBoolean());
        System.out.println(dis.readLong());
        System.out.println(dis.readChar());
      }catch(Exception e){
        e.printStackTrace();
      }finally{
         if(dis!=null)
        try{
           dis.close();
        }catch(Exception e){
      }
    }
  }
}

對象流                                                                                                                                                                                             

串行化：對象通過寫出描述自己狀態的數值來記述自己的過程叫串行話
對象流：能夠輸入輸出對象的流
將串行化的對象通過對象流寫入文件或傳送到其他地方
對象流是在普通流上加了傳輸對象的功能，所以構造對象流時要先構造普通文件流
注意：只有實現了Serializable接口的類才能被串行化
例子：

import java.io.*;
class Student implements Serializable{
    private String name;
    private int age;

    public Student(String name,int age){
         this.name=name;
         this.age=age;
     }

     public void greeting(){
          System.out.println("hello ,my name is "+name);
     }

     public String toString(){
          return "Student["+name+","+age+"]";
   }
}

public class ObjectOutTest{
      public static void main(String args[]){
      ObjectOutputStream oos=null;
      try{
         oos=new ObjectOutputStream(new FileOutputStream("student.txt"));
         Student s1=new Student("Jerry",24);
         Student s2=new Student("Andy",33);

         oos.writeObject(s1);
         oos.writeObject(s2);
        }catch(Exception e){
             e.printStackTrace();
        }finally{
             if(oos!=null)
             try{
                oos.close();
              }catch(Exception e){
                   e.printStackTrace();
             }
          }
     }
}

import java.io.*;
public class ObjectInTest{
       public static void main(String args[]){
       ObjectInputStream ois=null;
       Student s=null;
       try{
         ois=new ObjectInputStream(
         new FileInputStream("student.txt"));
         System.out.println("--------------------");
         s=(Student)ois.readObject();
         System.out.println(s);
         s.greeting();
         System.out.println("--------------------");
         s=(Student)ois.readObject();
         System.out.println(s);
         s.greeting();
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            if(ois!=null)
            try{
              ois.close();
            }catch(Exception e){
             e.printStackTrace();
          }
       }
    }
}

字符流 InputStreamReader/OutputStreamWriter                                                                                                                                  
上面的幾種流的單位是 byte，所以叫做字節流，寫入文件的都是二進制字節，我們無法直接看，下面要學習的是字節流
Java採用 Unicode 字符集，每個字符和漢字都採用2個字節進行編碼，ASCII 碼是 Unicode 編碼的自集
InputStreamReader 是 字節流 到 字符橋的橋樑 （ byte->char 讀取字節然後用特定字符集編碼成字符)
OutputStreamWriter是 字符流 到 字節流的橋樑 （ char->byte )
他們是在字節流的基礎上加了橋樑作用，所以構造他們時要先構造普通文件流
我們常用的是:
BufferedReader 方法：readLine()
PrintWriter 方法：println()

例子：

import java.io.*;
public class PrintWriterTest{
     public static void main(String args[]){
     PrintWriter pw=null;
     try{
        pw=new PrintWriter(new OutputStreamWriter(new FileOutputStream("bufferedwriter.txt")));
        pw.println("hello world");
      }catch(Exception e){
        e.printStackTrace();
      }finally{
        if(pw!=null)
             try{
                pw.close();
               }catch(Exception e){
                  e.printStackTrace();
           }
       }
   }
}

import java.io.*;
public class BufferedReaderTest{
         public static void main(String args[]){
         BufferedReader br=null;
        try{
           br=new BufferedReader(new InputStreamReader(new FileInputStream("bufferedwriter.txt")));
           System.out.println(br.readLine());
          }catch(Exception e){
              e.printStackTrace();
         }finally{
           if(br!=null)
             try{
                br.close();
             }catch(Exception e){
                e.printStackTrace();
            }
        }
    }
}

隨機存取文件 RandomAccessFile                                                                                                                                                       
可同時完成讀寫操作
支持隨機文件操作的方法:
readXXX()/writeXXX()
seek() 將指針調到所需位置
getFilePointer() 返回指針當前位置
length() 返回文件長度
例子：把若干個32位的整數寫到一個名爲 “temp.txt”的文件中,然後利用seek方法,以相反的順序再讀取這些數據

import java.io.*;
public class RandomFile{
   public static void main(String args[]){
        RandomAccessFile raf=null;
        int data[]={12,31,56,23,27,1,43,65,4,99};
        try{
           raf=new RandomAccessFile("temp.txt","rw");
           for(int i=0;i<data.length;i++)
                raf.writeInt(data<i>);
                for(int i=data.length-1;i>=0;i--){
                     raf.seek(i*4);
                     System.out.println(raf.readInt());
                }
           }catch(Exception e){
               e.getMessage();
           }finally{
               if(raf!=null)
               try{
                  raf.close();
              }catch(Exception e){
                 e.getMessage();
            }
       }
   }
}

小結                                                                                                                                                                                                  

這部分的難點就是類比較複雜，尤其是每個類的構造方式，我認爲記住下面這個圖比記類的繼承關係更好些

字節流：

InputStream
|-- FileInputStream (基本文件流）
|-- BufferedInputStream
|-- DataInputStream
|-- ObjectInputStream
OutputStream 同上圖
BufferedInputStream DataInputStream ObjectInputStream 只是在 FileInputStream 上增添了相應的功能，構造時先構造FileInputStream

 字符流：
Reader
|-- InputStreamReader (byte->char 橋樑）
|-- BufferedReader (常用）

Writer
|-- OutputStreamWriter (char->byte 橋樑）
|-- BufferedWriter
|-- PrintWriter （常用）

 隨機存取文件 RandomAccessFile