IO流02--畢向東JAVA基礎教程視頻學習筆記

提要08 自定義裝飾類09 LineNumberReader10 MyLineNumberReader11 位元組流File讀寫操作12 拷貝圖片13 位元組流的緩衝區14 自定義位元組流的緩衝區-read和write的特點15 讀取鍵盤錄入08 自定義裝飾類 1 /*自定義裝飾設計類*/ 2 impor...

提要

08 自定義裝飾類
09 LineNumberReader
10 MyLineNumberReader
11 位元組流File讀寫操作
12 拷貝圖片
13 位元組流的緩衝區
14 自定義位元組流的緩衝區-read和write的特點
15 讀取鍵盤錄入

08 自定義裝飾類

 1 /*自定義裝飾設計類*/
 2 import java.io.*;
 3 class MyBufferedReader2 extends Reader
 4 {
 5     private Reader r;
 6     public MyBufferedReader2(Reader r)
 7     {
 8         this.r=r;
 9     }
10     public String MyReadLine()throws IOException
11     {
12         int ch;
13         StringBuilder sb=new StringBuilder();
14         while((ch=r.read())!=-1)
15         {
16             if(ch=='\r')
17                 continue;
18             if(ch=='\n')
19                 return sb.toString();
20             else
21                 sb.append((char)ch);
22         }
23         if(sb.length()!=0)
24             return sb.toString();
25         return null;
26     }
27     public void MyClose()throws IOException
28     {
29         r.close();
30     }
31     //重寫父類的抽象方法
32     public void close()throws IOException
33     {
34         r.close();
35     }
36     public int read(char[] cbuf, int off, int len)throws IOException
37     {
38         return r.read(cbuf,off,len);
39     }
40 }
41 
42 public class  MyBufferedReaderDemo2
43 {
44     public static void main(String[] args)throws IOException
45     {
46         FileReader fw=new FileReader("buf.txt");
47         MyBufferedReader2 mr=new MyBufferedReader2(fw);
48         String line;
49         while((line=mr.MyReadLine())!=null)
50         {
51             System.out.println(line);
52         }
53         mr.MyClose();
54     }
55 }

09 LineNumberReader

 1 /*帶行號的緩衝區，lineNumberReader
 2 是BufferedReader的直接子類，此類定義了setLineNumber(int)和getLineNumber)(),
 3 分別用來設置和獲取當前行號。
 4 */
 5 import java.io.*;
 6 public class LineNumberReaderDemo 
 7 {
 8     public static void main(String[] args) 
 9     {
10         try
11         {
12            FileReader fw=new FileReader("PersonDemo.java");
13            LineNumberReader lr=new LineNumberReader(fw);
14            String line;
15            lr.setLineNumber(100);
16            while((line=lr.readLine())!=null)
17             {
18                System.out.println(lr.getLineNumber()+":"+line);
19            }
20            lr.close();
21             
22         }
23         catch (IOException ie)
24         {
25             ie.printStackTrace();
26         }
27     
28     }
29 }

10 MyLineNumberReader

 1 /*
 2 練習，自定義一個類，實現LineNumberReader的功能
 3 
 4 */
 5 import java.io.*;
 6 class MyLineNumberReader extends MyBufferedReader2
 7 {
 8     private int lineNumber;
 9     public MyLineNumberReader(Reader r)
10     {
11         super(r);
12     }
13     public String readLine()throws IOException
14     {
15         lineNumber++;
16         return super.MyReadLine();
17     }
18     //自定義設置行號的方法
19     public void setLineNumber(int lineNumber)
20     {
21         this.lineNumber=lineNumber;
22     }
23     //自定義獲取行號的方法
24     public int getLineNumber()
25     {
26         return lineNumber;
27     }
28 
29 }
30 public class MyLineNumberReaderDemo 
31 {
32     public static void main(String[] args) 
33     {
34         try
35      {
36         FileReader fr=new FileReader("BufferedReaderDemo.java");
37         MyLineNumberReader mlnr=new MyLineNumberReader(fr);
38         String line=null;
39         mlnr.setLineNumber(99);
40 
41         while((line=mlnr.readLine())!=null)
42         {
43             System.out.println(mlnr.getLineNumber()+"  "+line);
44         }
45         mlnr.close();
46 
47             
48      }
49         catch (IOException ie)
50      {
51             ie.printStackTrace();
52      }
53         
54     }
55     
56         
57 
58     
59 }

11 位元組流File讀寫操作

 1 /*
 2 字元流：
 3 FileReader
 4 FileWriter
 5 
 6 BufferedReader
 7 BufferedWriter
 8 
 9 位元組流：
10 InputStream  讀
11 OutPutStream 寫
12 
13 需求：想要操作圖片數據，這就需要用到位元組流。
14 
15 */
16 import java.io.*;
17 public class FileStream
18 {
19     public static void main(String[] args)throws IOException
20     {
21         writeFile();
22         readFile_1();
23         readFile_2();
24         readFile_3();
25 
26 
27     
28     }
29     //把讀到的存放到一個位元組數組中，然後一起輸出
30     public static void readFile_3()throws IOException
31     {
32         FileInputStream fis=new FileInputStream("fos.txt");
33        //int num=fis.available();
34        //使用avaliable方法，定義一個剛剛好的緩衝區，不用再迴圈了
35        //如果文件太大，不建議使用，會出現記憶體溢出
36        byte[] buf=new byte[fis.available()];
37        fis.read(buf);
38        System.out.println(new String(buf));
39 
40        fis.close();
41     }
42     //把讀到的存放到一個位元組數組中，然後一起輸出
43     public static void readFile_2()throws IOException
44     {
45         FileInputStream fis=new FileInputStream("fos.txt");
46        byte[] buf=new byte[1024];
47        int len=0;
48        while((len=fis.read(buf))!=-1)
49         {
50            System.out.println(new String(buf,0,len));
51        }
52        fis.close();
53     }
54     //一個一個地讀
55     public static void readFile_1()throws IOException
56     {
57         FileInputStream fis=new FileInputStream("fos.txt");
58         int ch=0;
59         while((ch=fis.read())!=-1)
60         {
61             System.out.println((char)ch);
62         }
63         fis.close();
64     }
65     public static void writeFile()throws IOException
66     {
67         FileOutputStream fos=new FileOutputStream("fos.txt");
68         fos.write("abcde".getBytes());
69         //對最小單位位元組操作，不需要刷新
70         fos.close();
71     }
72 }

12 拷貝圖片

void write(byte[] b, int off, int len) 將指定 byte 數組中從偏移量 off 開始的 len 個位元組寫入此文件輸出流。

int read(byte[] b) 從此輸入流中，將最多b.length個位元組的數據讀入byte數組中。返回讀入緩衝區的位元組總數，如果達到文件末尾沒有更多數據，則返回-1.

 1 /*
 2 複製一個圖片
 3 思路：
 4 1.用位元組讀取流對象和圖片相關聯
 5 2.用位元組寫入流對象創建一個圖片文件，用於存儲獲取到的圖片數據
 6 3.通過迴圈讀寫，完成數據的存儲
 7 4.關閉資源
 8 */
 9 import java.io.*;
10 public class CopyPic
11 {
12     public static void main(String[] args)
13     {
14         FileOutputStream fos=null;
15         FileInputStream fis=null;
16         try
17         {
18             fis=new FileInputStream("d:\\十字路口.bmp");
19             fos=new FileOutputStream("d:\\路口.bmp");
20 
21             byte[] buf=new byte[1024];
22             int len=0;
23             while((len=fis.read(buf))!=-1)
24             {
25                 fos.write(buf,0,len);
26             }
27 
28 
29         }
30         catch (IOException e)
31         {
32             throw new RuntimeException("複製文件失敗！");
33         }
34         finally
35         {
36             try
37             {
38                 if(fis!=null)
39                     fis.close();
40                 
41             }
42             catch (IOException e)
43            {
44             throw new RuntimeException("讀取關閉失敗！");
45            }
46            try
47             {
48                 if(fos!=null)
49                     fos.close();
50                 
51             }
52             catch (IOException e)
53            {
54             throw new RuntimeException("寫入關閉失敗！");
55            }
56         }
57     }
58 }

13 位元組流的緩衝區

 1 /*
 2 演示mp3的複製，通過緩衝區
 3 BufferedOutputStream
 4 BufferedInputStream
 5 */
 6 import java.io.*;
 7 public class CopyMp3
 8 {
 9     public static void main(String[] args)throws IOException
10     {
11         long start=System.currentTimeMillis();
12         copy();
13         long end=System.currentTimeMillis();
14 
15         System.out.println((end-start)+"毫秒");
16 
17     }
18     //通過位元組流的緩衝區完成複製
19     public static void copy()throws IOException
20     {
21         BufferedInputStream bufis=new BufferedInputStream(new FileInputStream("D:\\安又琪-那你呢.mp3"));
22         BufferedOutputStream bufos=new BufferedOutputStream(new FileOutputStream("d:\\那你呢.mp3"));
23 
24         int by=0;
25         while((by=bufis.read())!=-1)
26         {
27             bufos.write(by);        
28         }
29         bufis.close();
30         bufos.close();
31 
32     }
33 }

14 自定義位元組流的緩衝區-read和write的特點

 1 /*
 2 通過自定義的緩衝區，拷貝Mp3
 3 
 4 註意，把myRead方法的返回值設為int型，而不是byte型
 5 因為當連續讀取8個1時，可能錯誤結束main函數中的讀取迴圈，
 6 提升了一個int型(byte型1個位元組，int型32位，4個位元組)，還是-1的原因是因為在8個1前面補1造成的。
 7  那麼如果能在前面補0，既可以保留原位元組數據不變，又可以避免-1的出現。
 8 
 9  補0的方法：
10  和255相與
11 
12 最後文件大小並沒有變成原來的4倍的原因是，write方法只寫入後8位，對int型又做了強制轉換
13 
14 運行發現，自定義的緩衝區的拷貝時間比原來的提高了大約200毫秒
15 
16 */
17 import java.io.*;
18 class MyBufferedInputStream
19 {
20     private InputStream in;
21     private byte[] buf=new byte[1024];
22     private int pos=0,count=0;
23     public MyBufferedInputStream(InputStream in)
24     {
25         this.in=in;
26     }
27     //一次讀一個位元組，從緩衝區（位元組數組）獲取。
28     public int myRead()throws IOException
29     {
30         //通過in對象讀取硬碟上數據，並存儲在buf中。
31         if(count==0)
32         {
33             count=in.read(buf);
34             pos=0;
35             byte b=buf[pos];
36 
37             count--;
38             pos++;
39             return b&255;
40         }
41         else if(count>0)
42         {
43             byte b=buf[pos];
44             count--;
45             pos++;
46             return b&255;
47         }
48         return -1;
49 
50     }
51     public void myClose()throws IOException
52     {
53         in.close();
54     }
55 }
56 public class CopyMp3_2
57 {
58     public static void main(String[] args)throws IOException
59     {
60         long start=System.currentTimeMillis();
61         copy_1();
62         long end=System.currentTimeMillis();
63 
64         System.out.println((end-start)+"毫秒");
65 
66     }
67     //通過位元組流的緩衝區完成複製
68     public static void copy_1()throws IOException
69     {
70         MyBufferedInputStream bufis=new MyBufferedInputStream(new FileInputStream("D:\\安又琪-那你呢.mp3"));
71         BufferedOutputStream bufos=new BufferedOutputStream(new FileOutputStream("d:\\那你呢.mp3"));
72 
73         int by=0;
74         while((by=bufis.myRead())!=-1)
75         {
76             
77             bufos.write(by);        
78         }
79         bufis.myClose();
80         bufos.close();
81 
82     }
83 }

15 讀取鍵盤錄入

需求：
通過鍵盤錄入數據
當錄入一行數據後，就將該行數據轉變為大寫形式再進行列印
如果錄入的數據是over,則停止錄入。

 1 /*
 2 字元流：
 3 FileReader
 4 FileWriter
 5 
 6 BufferedReader
 7 BufferedWriter
 8 
 9 位元組流：
10 FileInputStream
11 FileOutputStream
12 
13 BufferedInputStream
14 BufferedOutputStream
15 
16 
17 讀取鍵盤錄入：
18 System.out :對應的是標準輸出設備，控制台
19 System.in :對應的標準輸入設備：鍵盤
20 
21 
22 */
23 import java.io.*;
24 public class  ReadIn
25 {
26     public static void main(String[] args) throws IOException
27     {
28         InputStream in=System.in;
29         //建立一個讀入數據的緩衝區
30         StringBuilder sb=new StringBuilder();
31 
32         while(true)
33         {
34             //read方法是阻塞式方法，沒有錄入，就會一直等待
35         int ch=in.read();
36         if(ch=='\r')
37             continue;
38         else if(ch=='\n')
39             {
40             String s=sb.toString();
41             if("over".equals(s))
42                 break;
43             System.out.println(s.toUpperCase());
44             //清空緩衝區
45             sb.delete(0,sb.length());
46 
47         }
48         else 
49             sb.append((char)ch);
50 
51         }
52     
53     }
54 }