Java基礎 IO流——第一部分

 

新博客地址：Temi

 

                                                               第一講：IO流(概述)

一，IO流的概述：

1. IO流用來處理設備間的數據傳輸。    ===注：設備包括硬盤文件，和內存數據=======
2. Java對數據的操做是經過流的方式。 
3. Java用於操做流的對象都在IO（java.io)包中。===注： nio 是java nonblocking(非阻塞) IO 的簡稱，在jdk1.4 裏提供的新api。(在包java.nio中).====
4. 流按操做數據分爲兩種：字節流和字符流。   ===注：不管是內存中的數據仍是硬盤中的，他們的體現形式都是二進制形式，即：字節。字符流：字符流的產生是爲了方便於處理文本數據，字符流內部融合和字符的編碼表。使處理字符變得更加方便簡單。字符流只用於處理文字數據，而字節流能夠處理媒體數據====
5. 流按流向分爲：輸入流和輸出流。

二，IO流經常使用基類：

1. 字節流抽象基類：InputStream  ,OutputStream。
2. 字符流抽象基類：Reader , Writer。

                          =========注：由這四個基類派生出的子類名稱都是以父類名稱做爲後綴的，例如FileInputStream 是  InputStream 類的子類   FileWriter  是Writer 類的子類。前綴名是流對象的功能=========

                                                                                      第二講：IO流(FileWriter)

一，Writer類的基本瞭解（查閱API)：

1.   Writer 類的定義：public abstract class Writerextends Object   implements  Appendable, Closeable,Flushable
2.   構造方法：    protected Writer()          ===注：構造方法私有化，不能被直接實例化====
3. 經常使用方法：    public abstract void close() throws IOException       ——關閉流，關閉以前刷新流。
                           public abstract void flush() throws IOException      ——刷新流。
                          public void write(char[] cbuf) throws IOException   ——向流中寫數據。===注：此方法針對 int 類型  String 類型都有重載。

二，寫入字符流的步驟：

1. 建立一個FileWriter對象。 FileWriter  fw=new FileWriter("Demo.txt");   ==注：初始化該對象時必須明確指出要操做的文件，且該目錄下若是已有同名文件，則同名文件將被覆蓋。若指定文件不存在則建立文件。若指定文件的父目錄不存在則拋出異常。===
2. 對IO操做過程當中所產生的異常進行處理。 public static void main(String args[])  throws IOException   ==用  try  語句捕捉，或者方法聲明拋出===
3. 調用 FileWriter 對象的 write() 方法進行寫數據。 fw.write("HelloWorld");  ===注：此時寫入動做只是寫入到了內存當中，即寫入到了「流」當中去了，並無真正寫入文件===
4. 調用 FileWriter 對象的 flush() 方法刷新流——將數據寫入到文件中。fw.flush();     
5. 調用 FileWriter 對象的 close() 方法關閉流。 ===注：關閉流時一樣會觸發流的刷新。close() 方法和 flush() 方法的區別在於 flush 以後流任然能夠繼續使用。========

                 ===知識點擴展：Java語言自己是不能往硬盤裏面寫數據的（不一樣系統寫入數據方式不一樣）。Java的數據寫入會調用系統的寫入資源。系統資源使用後必須關閉===

三，代碼練習：

 

 1 //導入須要用到的包。
 2 import java.io.*;
 3 
 4 public class FileWriterDemo{
 5                    public static void main(String args[]) throws IOException{
 6                                
 7 
 8                     //建立一個 FileWriter 對象
 9                     FileWriter fw=new FileWriter("Demo.txt");
10 
11                     //調用Writer 方法寫入數據
12                      fw.writer("HelloWorld");
13 
14                      //刷新流
15                      fw.flush();
16 
17                      //關閉流，一樣會觸發刷新
18                      fw.close();
19                      }
20 }

 

 

                                                第三講：IO流(IO異常處理方式)

一，對於 IO 異常處理的一些說明：

1. 只要是發生於設備之間數據處理的動做都會發生 IO  異常。不管都仍是寫。以及建立。
2. 一系列的讀寫操做的異常處理應當放到一個 try 語句快中。
3. 對於必定要執行的動做例如流的關閉，鎖的釋放，應當放到 finally 語句塊中。
4. 在  try 語句外部創建對象的引用，在 try 語句內部進行對象的初始化。  ====避免超出對象做用範圍=========
5. finally 語句中在進行資源關閉以前應當先判斷對象是否爲空，避免發生空指針異常。

 二，代碼練習：

 1 import java.io.*;
 2 
 3 public class FileWriterDemo2{
 4                     public static void main(String args[]){
 5                           
 6                      //在 try 語句外面創建對象引用
 7                       FileWriter fw=null;
 8 
 9 
10                     //try 語句捕獲異常
11                       try{
12 
13 
14                             //try 內部進行對象初始化
15                             fw=new FileWriter("Demo.txt");
16                              
17                             //寫入數據
18                              fw.write("HelloHeiMa");
19                            }catch (IOException e){
20                                 System.out.println(e.toString());
21                            }finally{
22 
23 
24                                        //關閉動做一樣進行  try 處理
25                                        try{
26                                                //判斷 fw 是否爲空
27                                               if(fw!=null)
28                                                        fw.close();
29                                             }catch (IOException e){
30                                                System.out.println(e.toSring());
31                                             }
32                    }
33 }

 

 

                                                      第四講：IO流(文件的續寫)

一，進行數據續寫思路的分析：

1. 分析以前代碼覆寫操做的發生。即：FileWriter fw=new FileWriter("Demo.txt");  此操做目的文件若存在會覆蓋。
   
2. 尋找解決辦法。查閱 API 找到  FileWriter 類的構造方法：FileWriter(String fileName,boolean append);
3. 解決問題：    FileWriter fw=new FileWriter("Demo.txt",true);

二，知識點擴充：

1. 對於續寫時換行的操做：window系統中換行用兩個字符來表示（\r\n)換行，linux系統中用（\n）換行。
2. 文件分隔符： window 系統下文件分割可使用「\\"表示，其中第一個」\「 表示轉義。也能夠用」/「做爲文件分割符。

三，代碼練習：

 1 import java.io.*;
 2 
 3 
 4 public class FileWriterDemo3 {
 5              public static void main(String args[]){
 6                   
 7                      //聲明FileWriter對象
 8                      FileWriter fw=null;
 9                      try{
10                          
11                          //以追加方式實例化FileWriter對象，
12                          fw=new FileWriter("E:/demo.txt",true);
13                          
14                          //向文件中追加數據
15                          fw.write("abcd\r\nHeiMa");
16                      }catch(IOException e){
17                          System.out.println("內容寫入失敗");
18                      }finally{
19                          
20                          
21                          //關閉系統資源
22                           try{
23                               if(fw!=null)
24                                   fw.close();
25                           }catch(IOException e){
26                               System.out.println("關閉流操做失敗");
27                           }
28                      }
29              }
30 }

 

                                                     第五講：IO流(文本文件讀取方式一)

一，FileReader類的瞭解：

1. FileReader 類的定義： public class FileReader extends InputStreanReader   ===用來讀取字符文件的便捷類。此類的構造方法假定默認字符編碼和默認字節緩衝區大小都是適當的。====
2. FileReader 類的構造方法：public FileReader(File file) throws FileNotFoundException ===當指定的文件不存在時拋出FileNotFoundException====
                    public FileReader(File file) throws FileNotFoundException 
3. FileReader 類的經常使用方法： public void close()    關閉流。
                                        public void mark   (int readAheadLimit)  throws IOException    標記流中的當前位置。
                                        public long skip   (long n)  throws IOException           跳過字符。
                                        public void reset()  throws IOException       重置該流。
                                        public int read()   throws IOException   讀取字符，此方法被屢次重載，能夠向字符數組中讀取。

二，文本文件讀取過程：

1. 以指定名稱的文件，建立一個文件讀取流對象。  FileReader  fr=new FileReader("Demo.txt");====若文件不存在拋出FileNotFoundException 異常======
2. 調用讀取流對象的 read() 方法     int  ch=fr.read();  ===read() 方法一次讀取一個字符，返回字符的整形編碼，且會自動往下讀。若想一次讀取多個字符可經過字符數組進行讀取===
3. 當讀取函數返回-1時表示達到文件末尾，此時應該關閉流。fr.close();

三，代碼練習：

 1 import java.io.*;
 2 
 3 
 4 public class FileWriterDemo4 {
 5                public static void main(String args[]){
 6                    
 7                    
 8                    //聲明文件讀寫對象
 9                    FileReader fr=null;
10                    
11                    
12                    //實例化對象，進行文件讀寫
13                    try{
14                        
15                        //若文件不存在拋出FileNotFoundException異常
16                        fr=new FileReader("E:\\demo.txt");
17                        
18                        //定義int 變量ch 接受讀取結果
19                        int ch;
20                        
21                        //若讀取結果爲-1則表示到達文件末尾，讀取結束
22                        while((ch=fr.read())!=-1)
23                            System.out.println("ch"+(char)ch);
24                        System.out.println("讀取完畢");
25                        
26                        
27                        //文件不存在的異常處理
28                    }catch(FileNotFoundException e){
29                        System.out.println("指定的文件不存在");
30                    }catch(IOException e){
31                        System.out.println("讀取文件發生錯誤");
32                    }finally{
33                        
34                        //關閉系統資源
35                        try{
36                            if(fr!=null)
37                                fr.close();
38                        }catch(IOException e){
39                            System.out.println("關閉文件發生錯誤");
40                        }
41                    }
42                }
43 }

 

                                             第六講：IO流(文本文件讀取方式二)

一，用到的方法：

1. public int read(char[] cbuf)  throws  IOException    將字符讀入數組。==注意此時的返回值，此時返回的 int 值並非字符的編碼，而是讀入字符數組中的字符數量。若是已到達流的末尾，則返回 -1==
2. public int read(char[] cbuf,int off,int len)  throws IOException       將字符讀入數組的某一部分。off--開始下標（包括），len (讀取長度）。若是已到達流的末尾，則返回 -1

二，注意事項：

1. 當在使用字符數組中讀取的字符串時，應當注意讀取個數問題，避免重複取。new String (cbuf,0,num);  其中num表明讀取的字符個數。
2. 一般狀況下，char數組的大小定義爲 1024 的整數倍。char[] cbuf=new char[1024]; 

三，代碼練習：

 1 import java.io.*;
 2 
 3 
 4 public class FileWriterDemo4 {
 5                public static void main(String args[]){
 6                    
 7                    
 8                    //聲明文件讀寫對象
 9                    FileReader fr=null;
10                    
11                    
12                    //實例化對象，進行文件讀寫
13                    try{
14                        
15                        //若文件不存在拋出FileNotFoundException異常
16                        fr=new FileReader("E:\\demo.txt");
17                        
18                        //定義整形變量表示讀取到的字符數量
19                        int ch;
20                        
21                        
22                        //定義字符數組向裏讀取字符
23                        char[] cbuf=new char[1024];
24                        
25                        //若讀取結果爲-1則表示到達文件末尾，讀取結束
26                        while((ch=fr.read(cbuf))!=-1)
27                            
28                            //截取有效的字符數
29                            System.out.println(new String(cbuf,0,ch));
30                        System.out.println("讀取完畢");
31                        
32                        
33                        //文件不存在的異常處理
34                    }catch(FileNotFoundException e){
35                        System.out.println("指定的文件不存在");
36                    }catch(IOException e){
37                        System.out.println("讀取文件發生錯誤");
38                    }finally{
39                        
40                        //關閉系統資源
41                        try{
42                            if(fr!=null)
43                                fr.close();
44                        }catch(IOException e){
45                            System.out.println("關閉文件發生錯誤");
46                        }
47                    }
48                }
49 }

                                                第七講：IO流(文本文件讀取練習)

一，練習要求：

1. 讀取一個 .java 文件並打印到控制檯上。
2. 將C盤一個文本文件複製到D盤。           ====複製的原理：讀一次寫一次=========

二，實現代碼：

     1，打印文件：

package com.examp.ch18;


import java.io.*;


public class FileWriterDemo4 {
               public static void main(String args[]){
                   
                   
                   //聲明文件讀寫對象
                   FileReader fr=null;
                   
                   String filename="E:\\test.java";
                   
                   //判斷文件名是否爲.java 結尾。
                   if(!filename.endsWith(".java")){
                       System.out.println("目標文件後墜名不是.java");
                       return;
                   }
                       
                   //實例化對象，進行文件讀寫
                   try{
                       
                       //若文件不存在拋出FileNotFoundException異常
                       fr=new FileReader(filename);
                       
                       //定義整形變量表示讀取到的字符數量
                       int ch;
                       
                       
                       //定義字符數組向裏讀取字符
                       char[] cbuf=new char[1024];
                       
                       //若讀取結果爲-1則表示到達文件末尾，讀取結束
                       while((ch=fr.read(cbuf))!=-1)
                           
                           //截取有效的字符數
                           System.out.println(new String(cbuf,0,ch));
                       System.out.println("讀取完畢");
                       
                       
                       //文件不存在的異常處理
                   }catch(FileNotFoundException e){
                       System.out.println("指定的文件不存在");
                   }catch(IOException e){
                       System.out.println("讀取文件發生錯誤");
                   }finally{
                       
                       //關閉系統資源
                       try{
                           if(fr!=null)
                               fr.close();
                       }catch(IOException e){
                           System.out.println("關閉文件發生錯誤");
                       }
                   }
               }
}

 

          2，複製文件：

 1 import java.io.*;
 2 
 3 
 4 public class FileWriterDemo4 {
 5                public static void main(String args[]){
 6                    if(copy("E:\\test.java","F:\\demo.txt"))
 7 
 8 
 9                            //複製成功給出提示
10                        System.out.println("複製成功");
11                }
12                
13                
14                public  static boolean copy(String srcfile,String dest){
15 
16                        //聲明讀文件對象以及寫文件對象的引用。
17                        FileReader fr=null;
18                        FileWriter fw=null;
19                        
20                        
21                        //定義int變量表示讀取的字符數
22                        int ch;
23 
24                        //定義字符數組，用來讀取
25                        char[] cbuf=new char[1024];
26                        try{
27 
28                            //分別實例化源文件的讀對象，以及目的文件的寫對象
29                            fr=new FileReader(srcfile);
30                            fw=new FileWriter(dest);
31                            
32 
33                           //邊讀邊寫，實現文件複製
34                            while((ch=fr.read(cbuf))!=-1){
35                                fw.write(cbuf, 0, ch);
36                            }
37                            
38                            
39                            //複製成功返回true
40                            return true;
41                        }catch(FileNotFoundException e){
42                          
43                             //產生異常，給出提示，返回false
44                            System.out.println(e.toString());
45                            return false;
46                        }catch(IOException e){
47 
48 
49                            //產生異常，給出提示，返回false
50                            System.out.println("複製文件產生錯誤");
51                            return false;
52                        }finally{
53 
54                            //釋放系統資源
55                            try{
56                                if(fr!=null)
57                                    fr.close();
58                                if(fw!=null)
59                                    fw.close();
60                            }catch(IOException e){
61 
62 
63                                    //產生異常，給出提示。                                                       System.out.println("關閉文件產生錯誤！");
64                            }
65                        }
66                }
67 }