IO流與NIO流

時間  2019-11-18
標籤 nio 欄目 Netty 简体版
原文   原文鏈接

JAVA IO流最詳解

 
 
（轉自CSDN）

IO流上：概述、字符流、緩衝區(java基礎)

 

1、IO流概述

概述：html

         IO流簡單來講就是Input和Output流，IO流主要是用來處理設備之間的數據傳輸，Java對於數據的操做都是經過流實現，而java用於操做流的對象都在IO包中。java

分類：設計模式

        按操做數據分爲：字節流和字符流。 如：Reader和InpurStreamapi

        按流向分：輸入流和輸出流。如：InputStream和OutputStream數組

IO流經常使用的基類：緩存

         * InputStream    ，    OutputStream網絡

字符流的抽象基類：app

         * Reader       ，         Writer函數

由上面四個類派生的子類名稱都是以其父類名做爲子類的後綴：post

            如：FileReader和FileInputStream

2、字符流

1. 字符流簡介：

* 字符流中的對象融合了編碼表，也就是系統默認的編碼表。咱們的系統通常都是GBK編碼。

* 字符流只用來處理文本數據，字節流用來處理媒體數據。

* 數據最多見的表現方式是文件，字符流用於操做文件的子類通常是FileReader和FileWriter。

2.字符流讀寫：

注意事項：

* 寫入文件後必需要用flush()刷新。

* 用完流後記得要關閉流

* 使用流對象要拋出IO異常

 

* 定義文件路徑時，能夠用「/」或者「\\」。

* 在建立一個文件時，若是目錄下有同名文件將被覆蓋。

* 在讀取文件時，必須保證該文件已存在，不然出異常

示例1：在硬盤上建立一個文件,並寫入一些文字數據

 

[java]  view plain  copy
 
  1. class FireWriterDemo {  
  2.     public static void main(String[] args) throws IOException {             //須要對IO異常進行處理   
  3.   
  4.         //建立一個FileWriter對象，該對象一被初始化就必需要明確被操做的文件。  
  5.         //並且該文件會被建立到指定目錄下。若是該目錄有同名文件，那麼該文件將被覆蓋。  
  6.   
  7.         FileWriter fw = new FileWriter("F:\\1.txt");//目的是明確數據要存放的目的地。  
  8.   
  9.         //調用write的方法將字符串寫到流中  
  10.         fw.write("hello world!");  
  11.       
  12.         //刷新流對象緩衝中的數據，將數據刷到目的地中  
  13.         fw.flush();  
  14.   
  15.         //關閉流資源，可是關閉以前會刷新一次內部緩衝中的數據。當咱們結束輸入時候，必須close();  
  16.         fw.write("first_test");  
  17.         fw.close();  
  18.         //flush和close的區別：flush刷新後能夠繼續輸入，close刷新後不能繼續輸入。  
  19.   
  20.     }  
  21. }  

 

示例2：FileReader的reade()方法.

要求：用單個字符和字符數組進行分別讀取

 

[java]  view plain  copy
 
  1. class FileReaderDemo {  
  2.     public static void main(String[] args) {  
  3.         characters();  
  4.     }  
  5.   
  6.   
  7. /*****************字符數組進行讀取*********************/  
  8.     private static void characters() {  
  9.   
  10.         try {  
  11.   
  12.             FileReader fr = new FileReader("Demo.txt");  
  13.             char []  buf = new char[6];   
  14.             //將Denmo中的文件讀取到buf數組中。  
  15.             int num = 0;      
  16.             while((num = fr.read(buf))!=-1) {  
  17.   
  18.                 //String(char[] value , int offest,int count) 分配一個新的String,包含從offest開始的count個字符  
  19.                 sop(new String(buf,0,num));  
  20.             }  
  21.             sop('\n');  
  22.             fr.close();  
  23.         }  
  24.         catch (IOException e) {  
  25.             sop(e.toString());  
  26.         }  
  27.     }  
  28.   
  29.   
  30.   
  31.   
  32.   
  33.   
  34. /*****************單個字母讀取*************************/  
  35.     private static void singleReader() {  
  36.           
  37.         try {  
  38.   
  39.             //建立一個文件讀取流對象，和指定名稱的文件關聯。  
  40.             //要保證文件已經存在，不然會發生異常：FileNotFoundException  
  41.             FileReader fr = new FileReader("Demo.txt");  
  42.   
  43.           
  44.             //如何調用讀取流對象的read方法？  
  45.             //read()方法，一次讀取一個字符，而且自動往下讀。若是到達末尾則返回-1  
  46.             int ch = 0;  
  47.             while ((ch=fr.read())!=-1) {  
  48.                 sop((char)ch);  
  49.             }  
  50.             sop('\n');  
  51.             fr.close();  
  52.   
  53.   
  54.             /*int ch = fr.read(); 
  55.             sop("ch=" + (char)ch); 
  56.  
  57.             int ch2 = fr.read(); 
  58.             sop("ch2=" + (char)ch2); 
  59.  
  60.             //使用結束注意關閉流 
  61.             fr.close(); */    
  62.               
  63.   
  64.   
  65.         }  
  66.         catch (IOException e) {  
  67.             sop(e.toString());  
  68.         }  
  69.       
  70.     }  
  71.   
  72.   
  73. /**********************Println************************/  
  74.     private static void sop(Object obj) {  
  75.         System.out.print(obj);  
  76.     }  
  77.   
  78. }  

 

示例3：對已有文件的數據進行續寫

 

 

[java]  view plain  copy
 
  1. import java.io.*;  
  2.   
  3. class  FileWriterDemo3 {  
  4.     public static void main(String[] args) {  
  5.           
  6.         try {  
  7.             //傳遞一個參數,表明不覆蓋已有的數據。並在已有數據的末尾進行數據續寫  
  8.             FileWriter fw = new FileWriter("F:\\java_Demo\\day9_24\\demo.txt",true);  
  9.             fw.write(" is charactor table?");  
  10.             fw.close();  
  11.         }  
  12.         catch (IOException e) {  
  13.             sop(e.toString());  
  14.         }  
  15.           
  16.     }  
  17.   
  18. /**********************Println************************/  
  19.     private static void sop(Object obj)  
  20.     {  
  21.         System.out.println(obj);  
  22.     }  
  23. }  

 



練習：

將F盤的一個文件複製到E盤。 

思考：

其實就是將F盤下的文件數據存儲到D盤的一個文件中。

步驟：

1.在D盤建立一個文件，存儲F盤中文件的數據。
2.定義讀取流和F：盤文件關聯。
3.經過不斷讀寫完成數據存儲。
4.關閉資源。

源碼：

 

[java]  view plain  copy
 
  1. import java.io.*;  
  2. import java.util.Scanner;  
  3.   
  4. class CopyText {  
  5.     public static void main(String[] args) throws IOException {  
  6.         sop("請輸入要拷貝的文件的路徑:");  
  7.         Scanner in = new Scanner(System.in);  
  8.         String source = in.next();  
  9.         sop("請輸入須要拷貝到那個位置的路徑以及生成的文件名:");  
  10.         String destination = in.next();  
  11.         in.close();  
  12.         CopyTextDemo(source,destination);  
  13.   
  14.     }  
  15.   
  16. /*****************文件Copy*********************/  
  17.     private static void CopyTextDemo(String source,String destination) {  
  18.   
  19.         try {  
  20.             FileWriter fw = new FileWriter(destination);  
  21.             FileReader fr = new FileReader(source);  
  22.             char []  buf = new char[1024];   
  23.             //將Denmo中的文件讀取到buf數組中。  
  24.             int num = 0;      
  25.             while((num = fr.read(buf))!=-1) {  
  26.                                //String(char[] value , int offest,int count) 分配一個新的String,包含從offest開始的count個字符  
  27.                 fw.write(new String(buf,0,num));  
  28.             }  
  29.             fr.close();  
  30.             fw.close();  
  31.         }  
  32.         catch (IOException e) {  
  33.             sop(e.toString());  
  34.         }  
  35.     }  
  36.   
  37.   
  38.   
  39. /**********************Println************************/  
  40.     private static void sop(Object obj) {  
  41.         System.out.println(obj);  
  42.     }  
  43. }  

 

3、緩衝區

1. 字符流的緩衝區：BufferedReader和BufferedWreiter

* 緩衝區的出現時爲了提升流的操做效率而出現的.

* 須要被提升效率的流做爲參數傳遞給緩衝區的構造函數

* 在緩衝區中封裝了一個數組，存入數據後一次取出

BufferedReader示例：

讀取流緩衝區提供了一個一次讀一行的方法readline，方便對文本數據的獲取。
readline()只返回回車符前面的字符，不返回回車符。若是是複製的話，必須加入newLine()，寫入回車符

newLine()是java提供的多平臺換行符寫入方法。

 

[java]  view plain  copy
 
  1. import java.io.*;  
  2.   
  3.   
  4. class BufferedReaderDemo {  
  5.     public static void main(String[] args)  throws IOException {  
  6.   
  7.         //建立一個字符讀取流流對象，和文件關聯  
  8.         FileReader rw = new FileReader("buf.txt");  
  9.   
  10.         //只要將須要被提升效率的流做爲參數傳遞給緩衝區的構造函數便可  
  11.         BufferedReader brw = new BufferedReader(rw);  
  12.   
  13.           
  14.         for(;;) {  
  15.             String s = brw.readLine();  
  16.             if(s==null) break;  
  17.             System.out.println(s);  
  18.         }  
  19.           
  20.         brw.close();//關閉輸入流對象  
  21.   
  22.     }  
  23. }  

 

BufferedWriter示例：

 

[java]  view plain  copy
 
  1. import java.io.*;  
  2.   
  3.   
  4. class BufferedWriterDemo {  
  5.     public static void main(String[] args)  throws IOException {  
  6.   
  7.         //建立一個字符寫入流對象  
  8.         FileWriter fw = new FileWriter("buf.txt");  
  9.   
  10.         //爲了提升字符寫入效率，加入了緩衝技術。  
  11.         //只要將須要被提升效率的流做爲參數傳遞給緩衝區的構造函數便可  
  12.         BufferedWriter bfw = new BufferedWriter(fw);  
  13.   
  14.         //bfw.write("abc\r\nde");  
  15.         //bfw.newLine();               這行代碼等價於bfw.write("\r\n"),至關於一個跨平臺的換行符  
  16.         //用到緩衝區就必需要刷新  
  17.         for(int x = 1; x < 5; x++) {  
  18.             bfw.write("abc");  
  19.             bfw.newLine();                  //java提供了一個跨平臺的換行符newLine();  
  20.             bfw.flush();  
  21.         }  
  22.   
  23.   
  24.   
  25.         bfw.flush();                                                //刷新緩衝區  
  26.         bfw.close();                                                //關閉緩衝區，可是必需要先刷新  
  27.   
  28.         //注意，關閉緩衝區就是在關閉緩衝中的流對象  
  29.         fw.close();                                                 //關閉輸入流對象  
  30.   
  31.     }  
  32. }  

 

2.裝飾設計模式

裝飾設計模式：：：：

要求：自定義一些Reader類，讀取不一樣的數據(裝飾和繼承的區別)
MyReader //專門用於讀取數據的類
    |--MyTextReader
        |--MyBufferTextReader
    |--MyMediaReader
        |--MyBufferMediaReader
    |--MyDataReader
        |--MyBufferDataReader

若是將他們抽取出來，設計一個MyBufferReader，能夠根據傳入的類型進行加強
class MyBufferReader {

    MyBufferReader (MyTextReader text) {}
    MyBufferReader (MyMediaReader media) {}
    MyBufferReader (MyDataReader data) {}
}

可是上面的類拓展性不好。找到其參數的共同類型，經過多態的形式，能夠提升拓展性

class MyBufferReader  extends MyReader{
    private MyReader r;                        //從繼承變爲了組成模式  裝飾設計模式
    MyBufferReader(MyReader r) {}
}

優化後的體系：
    |--MyTextReader
    |--MyMediaReader
    |--MyDataReader
    |--MyBufferReader        //加強上面三個。裝飾模式比繼承靈活，
                              避免繼承體系的臃腫。下降類與類之間的耦合性

裝飾類只能加強已有的對象，具有的功能是相同的。因此裝飾類和被裝飾類屬於同一個體系

 

 

 

MyBuffereReader類：  本身寫一個MyBuffereReader類，功能與BuffereReader相同

 

[java]  view plain  copy
 
  1. class MyBufferedReader1  extends Reader{               
  2.     private Reader r;  
  3.     MyBufferedReader1(Reader r){  
  4.         this.r  = r;  
  5.     }  
  6.   
  7.     //一次讀一行數據的方法  
  8.     public String myReaderline()  throws IOException {  
  9.         //定義一個臨時容器，原BufferReader封裝的是字符數組。  
  10.         //爲了演示方便。定義一個StringBuilder容器。最終要將數據變成字符串  
  11.         StringBuilder sb = new StringBuilder();  
  12.         int ch = 0;  
  13.         while((ch = r.read()) != -1)  
  14.         {  
  15.             if(ch == '\r')   
  16.                 continue;  
  17.             if(ch == '\n')                    //遇到換行符\n,返回字符串  
  18.                 return sb.toString();  
  19.             else  
  20.             sb.append((char)ch);  
  21.         }  
  22.         if(sb.length()!=0)                    //當最後一行不是以\n結束時候，這裏須要判斷  
  23.             return sb.toString();  
  24.         return null;  
  25.     }  
  26.     /* 
  27.     須要覆蓋Reader中的抽象方法close()，read(); 
  28.     */  
  29.     public void close()throws IOException {  
  30.         r.close();  
  31.     }  
  32.   
  33.     public int read(char[] cbuf,int off, int len)throws IOException {   //覆蓋read方法  
  34.         return r.read(cbuf,off,len);  
  35.     }  
  36.   
  37.     public void myClose() throws IOException{  
  38.         r.close();  
  39.     }  
  40.   
  41.   
  42. }  

 

 

 

 

1、字節流

1.概述：

 

一、字節流和字符流的基本操做是相同的，可是要想操做媒體流就須要用到字節流。

二、字節流由於操做的是字節，因此能夠用來操做媒體文件。（媒體文件也是以字節存儲的）

三、讀寫字節流：InputStream   輸入流（讀）和OutputStream  輸出流（寫）

四、字節流操做能夠不用刷新流操做。

五、InputStream特有方法：

        int available();//返回文件中的字節個數

注：能夠利用此方法來指定讀取方式中傳入數組的長度，從而省去循環判斷。可是若是文件較大，而虛擬機啓動分配的默認內存通常爲64M。當文件過大時，此數組長度所佔內存空間就會溢出。因此，此方法慎用，當文件不大時，可使用。

練習：

需求：複製一張圖片F:\java_Demo\day9_28\1.BMP到F:\java_Demo\day9_28\2.bmp

 

[java]  view plain  copy
 
  1. import java.io.*;  
  2.   
  3.   
  4. class CopyPic {  
  5.     public static void main(String[] args){  
  6.         copyBmp();  
  7.         System.out.println("複製完成");  
  8.     }  
  9.   
  10.     public static void copyBmp() {  
  11.   
  12.         FileInputStream fis = null;  
  13.         FileOutputStream fos = null;  
  14.         try {  
  15.             fis = new FileInputStream("F:\\java_Demo\\day9_28\\1.bmp");             //寫入流關聯文件  
  16.             fos = new FileOutputStream("F:\\java_Demo\\day9_28\\2.bmp");            //讀取流關聯文件  
  17.             byte[] copy = new byte[1024];  
  18.             int len = 0;  
  19.             while((len=fis.read(copy))!=-1) {  
  20.             fos.write(copy,0,len);  
  21.             }  
  22.         }  
  23.         catch (IOException e) {  
  24.             e.printStackTrace();  
  25.             throw new RuntimeException("複製文件異常");  
  26.         }  
  27.         finally {  
  28.             try {  
  29.                 if(fis!=null) fis.close();  
  30.             }  
  31.             catch (IOException e) {  
  32.                 e.printStackTrace();  
  33.                 throw new RuntimeException("讀取流");  
  34.             }  
  35.         }  
  36.           
  37.     }  
  38.   
  39. }  

 

2. 字節流緩衝區

* 字節流緩衝區跟字符流緩衝區同樣，也是爲了提升效率。

注意事項：

1. read()：會將字節byte()提高爲int型值

2. write()：會將int類型轉換爲byte()類型，保留最後的8位。

練習：

1.複製MP3文件   1.MP3 -->  2.MP3

2.本身寫一個MyBufferedInputStream緩衝類，提高複製速度

代碼：

 

[java]  view plain  copy
 
  1. import java.io.*;  
  2.   
  3.   
  4. //本身的BufferedInputStream  
  5. class MyBufferedInputStream  {  
  6.     private InputStream in;                         //定義一個流對象  
  7.     private byte [] buf = new byte[1024*4];  
  8.     private int count = 0,pos = 0;  
  9.     public MyBufferedInputStream(InputStream in){  
  10.         this.in = in;  
  11.     }  
  12.   
  13.     public  int MyRead() throws IOException{  
  14.         if(count==0) {              //當數組裏的數據爲空時候，讀入數據  
  15.             count = in.read(buf);  
  16.             pos = 0;  
  17.             byte b = buf[pos];  
  18.             count--;  
  19.             pos++;  
  20.             return b&255;       //提高爲int類型，在前面三個字節補充0。避免1111 1111 1111 1111  
  21.         }  
  22.         else if(count > 0) {  
  23.             byte b = buf[pos];  
  24.             pos++;  
  25.             count--;  
  26.             return b&0xff;      //提高爲int類型，在前面三個字節補充0。避免1111 1111 1111 1111  
  27.         }  
  28.         return -1;  
  29.     }  
  30.   
  31.     public void myClose() throws IOException{  
  32.         in.close();  
  33.     }  
  34.   
  35. }  
  36.   
  37.   
  38.   
  39.   
  40. class BufferedCopyDemo {  
  41.     public static void main(String[] args) {  
  42.         long start = System.currentTimeMillis();  
  43.         copy();  
  44.         long end = System.currentTimeMillis();  
  45.         System.out.println("時間:"+(end-start)+"ms");  
  46.   
  47.   
  48.         start = System.currentTimeMillis();  
  49.         copy1();  
  50.         end = System.currentTimeMillis();  
  51.         System.out.println("時間:"+(end-start)+"ms");  
  52.     }   
  53.   
  54. public static void copy1() {                //    應用本身的緩衝區緩衝數據  
  55.   
  56.         MyBufferedInputStream bis = null;  
  57.         BufferedOutputStream  bos = null;  
  58.         try {  
  59.             bis = new MyBufferedInputStream(new FileInputStream("馬旭東-入戲太深.mp3"));//匿名類，傳入一個InputStream流對象  
  60.             bos = new BufferedOutputStream(new FileOutputStream("3.mp3"));  
  61.             int buf = 0;  
  62.             while((buf=bis.MyRead())!=-1) {  
  63.                 bos.write(buf);  
  64.             }  
  65.         }  
  66.         catch (IOException e) {  
  67.             e.printStackTrace();  
  68.             throw new RuntimeException("複製失敗");  
  69.         }  
  70.         finally {  
  71.             try {  
  72.                 if(bis!=null)  {  
  73.                     bis.myClose();  
  74.                     bos.close();  
  75.                 }  
  76.             }  
  77.             catch (IOException e) {  
  78.                 e.printStackTrace();  
  79.             }  
  80.   
  81.         }  
  82.   
  83.     }  
  84. }   

 

2、流操做規律

1. 鍵盤讀取，控制檯打印。

System.out: 對應的標準輸出設備：控制檯  //它是PrintStream對象，（PrintStream：打印流。OutputStream的子類）

System.in: 對應的標準輸入設備：鍵盤     //它是InputStream對象

示例：

 

[java]  view plain  copy
 
  1. /*================從鍵盤錄入流，打印到控制檯上================*/  
  2.     public static void InOutDemo(){  
  3.         //鍵盤的最多見的寫法  
  4.         BufferedReader bufr = null;  
  5.         BufferedWriter bufw = null;  
  6.         try {  
  7.               
  8.             /*InputStream ips = System.in;        //從鍵盤讀入輸入字節流 
  9.             InputStreamReader fr = new InputStreamReader(ips);             //將字節流轉成字符流 
  10.             bufr = new BufferedReader(fr);  */                 //將字符流增強，提高效率  
  11.   
  12.               
  13.             bufr = new BufferedReader(new InputStreamReader(System.in));            //匿名類。InputSteamReader:讀取字節並將其解碼爲字符  
  14.             bufw = new BufferedWriter(new OutputStreamWriter(System.out));      //OutputStreamWriter:要寫入流中的字符編碼成字節  
  15.             String line = null;  
  16.             while((line = bufr.readLine())!=null){  
  17.                 if("over".equals(line)) break;  
  18.                 bufw.write(line.toUpperCase());                     //打印  
  19.                 bufw.newLine();                                     //爲了兼容，使用newLine()寫入換行符  
  20.                 bufw.flush();                                       //必需要刷新。否則不會顯示  
  21.             }  
  22.             if(bufw!=null) {  
  23.                 bufr.close();  
  24.                 bufw.close();  
  25.             }  
  26.         }  
  27.         catch (IOException e) {  
  28.             e.printStackTrace();  
  29.         }  
  30.               
  31.           
  32.     }  
  33. }  

 



2. 整行錄入

1.從鍵盤錄入數據，並存儲到文件中。

2. 咱們在鍵盤錄入的是時候，read()方法是一個一個錄入的，能不能整行的錄入呢？這時候咱們想到了BufferedReader中ReadLine()方法。

3. 轉換流

爲了讓字節流可使用字符流中的方法，咱們須要轉換流。

 1. InputStreamReader:字節流轉向字符流；

  a、獲取鍵盤錄入對象。

              InputStream in=System.in;

  b、將字節流對象轉成字符流對象，使用轉換流。

              InputStreamReaderisr=new InputStreamReader(in);

  c、爲了提升效率，將字符串進行緩衝區技術高效操做。使用BufferedReader

              BufferedReaderbr=new BufferedReader(isr);

//鍵盤錄入最多見寫法

              BufferedReaderin=new BufferedReader(new InputStreamReader(System.in));

2.OutputStreamWriter:字符流通向字節流

示例：

 

[java]  view plain  copy
 
  1. /*================把鍵盤錄入的數據存到一個文件中==============*/  
  2.     public static void inToFile() {  
  3.             //鍵盤的最多見的寫法  
  4.         BufferedReader bufr = null;  
  5.         BufferedWriter bufw = null;  
  6.         try {  
  7.               
  8.             /*InputStream ips = System.in;        //從鍵盤讀入輸入字節流 
  9.             InputStreamReader fr = new InputStreamReader(ips);             //將字節流轉成字符流 
  10.             bufr = new BufferedReader(fr);  */                 //將字符流增強，提高效率  
  11.   
  12.               
  13.             bufr = new BufferedReader(new InputStreamReader(System.in));            //匿名類。InputSteamReader:讀取字節並將其解碼爲字符  
  14.             bufw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("out.txt")));     //OutputStreamWriter:要寫入流中的字符編碼成字節  
  15.             String line = null;  
  16.             while((line = bufr.readLine())!=null){  
  17.                 if("over".equals(line)) break;  
  18.                 bufw.write(line.toUpperCase());                     //打印  
  19.                 bufw.newLine();                                     //爲了兼容，使用newLine()寫入換行符  
  20.                 bufw.flush();                                       //必需要刷新。否則不會顯示  
  21.             }  
  22.             if(bufw!=null) {  
  23.                 bufr.close();  
  24.                 bufw.close();  
  25.             }  
  26.         }  
  27.         catch (IOException e) {  
  28.             e.printStackTrace();  
  29.         }  
  30.               
  31.   
  32.     }  


 

4. 流操做基本規律

爲了控制格式我將其寫入了Java代碼段中，以下：

示例1：文本 ~ 文本

 

 

[java]  view plain  copy
 
  1. /*  
  2. 流操做的基本規律。  
  3. 1、兩個明確：(明確體系)  
  4. 1. 明確源和目的  
  5.     源：輸入流  InputStream  Reader  
  6.     目的：輸出流  OutputStream Writer  
  7.   
  8. 2. 操做的數據是不是純文本  
  9.     是： 字符流  
  10.     否： 字節流  
  11. 2、明確體系後要明確具體使用的對象  
  12.     經過設備區分：內存，硬盤，鍵盤  
  13.     目的設備：內存，硬盤，控制檯  
  14.   
  15.   
  16. 示例1：將一個文本文件中的數據存儲到另外一個文件中: 複製文件  
  17.     1、明確體系  
  18.         源：文件-->讀取流-->(InputStream和Reader)  
  19.         是不是文本：是-->Reader  
  20.           
  21.           
  22.         目的：文件-->寫入流-->(OutputStream Writer)  
  23.         是否純文本：是-->Writer  
  24.       
  25.     2、 明確設備  
  26.         源：Reader  
  27.             設備：硬盤上一個文本文件 --> 子類對象爲：FileReader  
  28.                 FileReader fr = new FileReader("Goods.txt");  
  29.               
  30.             是否提升效率：是-->加入Reader中的緩衝區：BufferedReader  
  31.                 BufferedReader bufr = new BufferedReader(fr);  
  32.                   
  33.         目的：Writer  
  34.             設備：鍵盤上一個文本文件 --> 子類對象：FileWriter  
  35.                 FileWriter fw = new FileWriter("goods1.txt");  
  36.             是否提升效率：是-->加入Writer的緩衝區：BufferedWriter  
  37.                 BufferedWriter bufw = new BufferedWriter(fw);  
  38.               
  39.               
  40.               
  41. 示例2：將一個圖片文件數據複製到另外一個文件中：複製文件  
  42.     1、明確體系  
  43.         源：文件-->讀取流-->(InputStream和Reader)  
  44.         是不是文本：否-->InputStream  
  45.           
  46.           
  47.         目的：文件-->寫入流-->(OutputStream Writer)  
  48.         是否純文本：否-->OutputStream  
  49.       
  50.     2、 明確設備  
  51.         源：InputStream  
  52.             設備：硬盤上一個媒體文件 --> 子類對象爲：FileInputStream  
  53.                 FileInputStream fis = new FileInputStream("Goods.txt");  
  54.               
  55.             是否提升效率：是-->加入InputStream中的緩衝區：BufferedInputStream  
  56.                 BufferedInputStream bufi = new BufferedInputStream(fis);  
  57.                   
  58.         目的：OutputStream  
  59.             設備：鍵盤上一個媒體文件 --> 子類對象：FileOutputStream  
  60.                 FileOutputStream fos = new FileOutputStream("goods1.txt");  
  61.             是否提升效率：是-->加入OutputStream的緩衝區：BufferedOutputStream  
  62.                 BufferedOutputStream bufo = new BufferedOutputStream(fw);  
  63.   
  64. 示例3：將鍵盤錄入的數據保存到一個文本文件中  
  65.     1、明確體系  
  66.         源：鍵盤-->讀取流-->(InputStream和Reader)  
  67.         是不是文本：是-->Reader  
  68.           
  69.           
  70.         目的：文件-->寫入流-->(OutputStream Writer)  
  71.         是否純文本：是-->Writer  
  72.       
  73.     2、 明確設備  
  74.         源：InputStream  
  75.             設備：鍵盤 --> 對用對象爲：System.in --> InputStream  
  76.                 爲了操做方便，轉成字符流Reader --> 使用Reader中的轉換流：InputStreamReader  
  77.                 InputStreamReader isr = new InputStreamReader(System.in);  
  78.               
  79.             是否提升效率：是-->加入Reader中的緩衝區：BufferedReader  
  80.                 BufferedReader bufr = new BufferedReader(isr);  
  81.                   
  82.         目的：Writer  
  83.             設備：鍵盤上一個文本文件 --> 子類對象：FileWriter  
  84.                 FileWriter fw = new FileWriter("goods1.txt");  
  85.             是否提升效率：是-->加入Writer的緩衝區：BufferedWriter  
  86.                 BufferedWriter bufw = new BufferedWriter(fw);  

5.指定編碼表(轉換流能夠指定編碼表)

要求：用UTF-8編碼存儲一個文本文件

 

[java]  view plain  copy
 
  1. import java.io.*;  
  2. public class IOStreamLaw {  
  3.   
  4.     /** 
  5.      * @param args 
  6.      */  
  7.     public static void main(String[] args) throws IOException {  
  8.                 //鍵盤的最多見寫法  
  9.                 BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));  
  10.                 BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("goods1.txt"),"UTF-8"));  
  11.                 String line = null;  
  12.                 while((line=bufr.readLine())!=null){  
  13.                     if("over".equals(line)) break;  
  14.                     bufw.write(line.toUpperCase());  
  15.                     bufw.newLine();  
  16.                     bufw.flush();  
  17.                 }  
  18.                 bufr.close();  
  19.     }  
  20.   
  21.   
  22. }  
 

Java NIO流

     對於JavaNIO仍是不是很瞭解，以前認爲NIO的N是non-block IO的意思，非阻塞；可是原來是New IO的意思。這個新表示的是和原來的BIO而言是一種新的IO吧。NIO的主要特性就是緩衝區，通道，和選擇器（這個可能不是）。

      Java在JDK1.4版本呢，引入了NIO這個新的api。Sun公司官方說明NIO的特性以下：

1. 爲全部的原始類型提供了（Buffer）緩存支持；

2. 字符集編碼解碼解決方案

3. Channel（通道）：一個新的原始I/O抽象；

4. 支持鎖和內存映射文件的文件訪問接口；

5. 提供多路（non-blocking）非阻塞式的高伸縮網絡I/O。

      對於上面的特性，我是不大瞭解的。不過，不影響，咱們繼續介紹。

      NIO建立的目的是，實現高速的I/O，而無需編寫自定義的本機代碼。

      那NIO大概是怎麼作到的呢？它將最耗時的I/O操做轉回操做系統，於是能夠極大的提升速度。而最耗時的I/O操做是填充和提取緩衝區。

      原來的io和如今NIO最重要的區別就是，數據打包和傳輸的方式。之前是以流，如今是以塊的方式處理數據。

      以前用流的方式呢，只能一次一個字節的處理數據。一個輸入流產生一個字節的數據，而一個輸出流則消耗一個字節的數據。這樣的好處是，建立過濾器特別容易，能夠建立多個過濾器，每一個過濾器處理只處理一部分的數據。壞處就是，比較慢。

      而NIO用塊的方式呢，能夠一次一個塊的處理數據。每一步的操做都在產生或者消耗一個塊，好處是相對於流快得多，壞處是，不夠優雅和簡單。

緩衝區

      而後開始介紹緩衝區，緩衝區就是上面介紹到的NIO的特性第一條，爲全部的原始數據都提供了Buffer緩存的支持。它主要是將全部的原始數據放在數組中，以塊的形式處理。

      而每種緩衝區的類都有四個屬性：容量（Capacity），上界（Limit），位置（Position），以及標記（Mark），用於提供關於其所包含的數據元素的信息。

      容量：緩衝區可以容納的數據元素的最大數量，緩衝區建立時肯定，永遠不能被改變；

      上界：緩衝區第一個不能被讀或寫的元素，或者說，緩衝區現存元素的計數。

      位置：下一個要被讀或寫的元素的索引。該值會自動由相應的get(),put()函數更新；

      標記：一個備忘的位置。調用mark()來設定mark=position。調用reset()來設定position = mark；標記在設定前是未定義的undefined。

      緩衝區的分類有，ByteBuffer（字節緩衝區），CharBuffer（字符緩衝區），ShortBuffer（短整型緩衝區），IntBuffer（整型緩衝區），LongBuffer（長整型緩衝區），FloatBuffer（單精度浮點緩衝區），DoubleBuffer（雙精度浮點緩衝區），就是沒有布爾緩衝區。

      他們都是抽象類，因此不能實例化，而後他們都繼承了Buffer類，因此都有存get(），取set()方法，也均可以經過各自的靜態方法allocation，建立緩衝區。該方法是經過warpping將現有的數組包裝到緩衝區中來爲緩衝區的內容分配空間，或者經過建立現有字節緩衝區的視圖來建立。

      下面這是一個簡單的實例，從上到下，建立一個整型的緩衝區，而後將現有的數組放到該緩衝區中。能夠經過put改變數組中的數據，而且因爲緩衝區中的數據對數組是可見的，因此改變緩衝區也會改變數據，能夠認爲是傳引用。flip()，因爲get()每調用一次，position位置都會改變，原本pos會等於3的，而用flip可讓pos變爲0;clear()效果也同樣。而duplicate()能夠複製一個緩衝區，如出一轍，也是傳引用，修改哪一個都會影響到另外一個。

 

  1.  
    import java.nio.IntBuffer;
  2.  
    import java.util.Arrays;
  3.  
     
  4.  
    /**
  5.  
    * Created by liuyanling on 2017/6/30.
  6.  
    */
  7.  
    public class BufferTest {
  8.  
    public static void main(String[] args) {
  9.  
    //建立緩衝區，並指定大小
  10.  
    IntBuffer intBuffer = IntBuffer.allocate( 10);
  11.  
     
  12.  
    //給緩衝區賦值,創建數組
  13.  
    int[] intArray = new int[]{3,5,7};
  14.  
    intBuffer = intBuffer.wrap(intArray);
  15.  
     
  16.  
     
  17.  
    //修改元素
  18.  
    intBuffer.put( 0,9);
  19.  
     
  20.  
    //打印緩衝區數據
  21.  
    for(int i=0;i<intBuffer.limit();i++) {
  22.  
    System.out.print(intBuffer.get()+ "\t");
  23.  
    //System.out.print(intBuffer+"\t"); //
  24.  
    }
  25.  
     
  26.  
    System.out.println( "\n緩衝區的數據對數組是可見的,修改視圖,數組中的數據也會變;傳引用");
  27.  
    //打印原始數組
  28.  
    Arrays.stream(intArray).forEach(temp-> System.out.print(temp+ "\t"));
  29.  
     
  30.  
     
  31.  
    //intBuffer.flip();//get()會使pos改變,對緩衝區進行反轉,將limit=pos;pos=0; (將當前位置給limit,而後變爲0)
  32.  
    intBuffer.clear();
  33.  
    System.out.println(intBuffer);
  34.  
     
  35.  
    IntBuffer intBuffer2 = intBuffer.duplicate();
  36.  
    System.out.println(intBuffer2);
  37.  
     
  38.  
    intBuffer2.put( 0,11);
  39.  
     
  40.  
    //0 <= mark <= position <= limit <= capacity
  41.  
     
  42.  
    //打印緩衝區數據
  43.  
    for(int i=0;i<intBuffer.limit();i++) {
  44.  
    System.out.print(intBuffer.get()+ "\t");
  45.  
    }
  46.  
     
  47.  
    System.out.println( "\n複製的緩衝區對原來的緩衝區也是可見的;傳引用");
  48.  
    //打印原始數組
  49.  
    for(int i=0;i<intBuffer2.limit();i++) {
  50.  
    System.out.print(intBuffer2.get()+ "\t");
  51.  
    }
  52.  
    }
  53.  
    }

      結果是這樣

 

9	5	7	
緩衝區的數據對數組是可見的,修改視圖,數組中的數據也會變;傳引用
9	5	7	java.nio.HeapIntBuffer[pos=0 lim=3 cap=3]
java.nio.HeapIntBuffer[pos=0 lim=3 cap=3]
11	5	7	
複製的緩衝區對原來的緩衝區也是可見的;傳引用
11	5	7

      未完待續！

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程