Java基礎IO流

流

流的本質是數據傳輸，根據數據傳輸特性將流抽象爲各類類，方便更直觀的進行數據操做。IO流最終要以對象來體現，對象都存在IO包中。

IO流的分類

根據處理數據類型的不一樣分爲：字符流和字節流

根據數據流向不一樣分爲：輸入流和輸出流

注意：流的操做只有兩種：讀和寫。

流的體系由於功能不一樣，可是有共性內容，不斷抽取，造成繼承體系。該體系一共有四個基類，並且都是抽象類。

字節流：InputStream  OutputStream

字符流：Reader  Writer

在這四個系統中，它們的子類，都有一個共性特色：子類名後綴都是父類名，前綴名都是這個子類的功能名稱。

Java流類圖結構

字節流

InputStream 和 OutputStream 是兩個 abstact 類，對於字節爲導向的 stream 都擴展這兩個基類。

InputStream：是表示字節輸入流的全部類的超類。

OutputStream：此抽象類是表示輸出字節流的全部類的超類。

處理字節數據的流對象。設備上的數據不管是圖片或者dvd，文字，它們都以二進制存儲的。二進制的最終都是以一個8位爲數據單元進行體現，因此計算機中的最小數據單元就是字節。意味着，字節流能夠處理設備上的全部數據，因此字節流同樣能夠處理字符數據。

• 向文件中寫入字符串

  • package heimablog;
    /**
     * 字節流
     * 向文件中寫入字符串
     * */
    import java.io.*;
    class hello{
        public static void main(String[] args) throws IOException {
            String fileName="D:"+File.separator+"hello.txt";
            File f=new File(fileName);
            OutputStream out =new FileOutputStream(f);
            String str="你好";
            byte[] b=str.getBytes();
            out.write(b);
            out.close();
        }
    }
    

• 向文件中追加新內容

  • package heimablog;
    /**
     * 字節流
     * 向文件中追加新內容：
     * */
    import java.io.*;
    class hello{
        public static void main(String[] args) throws IOException {
            String fileName="D:"+File.separator+"hello.txt";
            File f=new File(fileName);
            OutputStream out =new FileOutputStream(f,true);
            String str="Rollen";
            //String str="\r\nRollen";  能夠換行
            byte[] b=str.getBytes();
            for (int i = 0; i < b.length; i++) {
                out.write(b[i]);
            }
            out.close();
        }
    }
    

• 讀取文件內容

  • import java.io.*;
    class hello{
        public static void main(String[] args) throws IOException {
            String fileName="D:"+File.separator+"hello.txt";
            File f=new File(fileName);
            InputStream in=new FileInputStream(f);
            byte[] b=new byte[1024];
            in.read(b);
            in.close();
            System.out.println(new String(b));
        }
    }
    

  • 例子讀取出來會有大量的空格，咱們能夠利用in.read(b);的返回值來設計程序。以下：

    import java.io.*;
    class hello{
        public static void main(String[] args) throws IOException {
            String fileName="D:"+File.separator+"hello.txt";
            File f=new File(fileName);
            InputStream in=new FileInputStream(f);
            byte[] b=new byte[1024];
            int len=in.read(b);
            in.close();
            System.out.println("讀入長度爲："+len);
            System.out.println(new String(b,0,len));
        }
    }
    

  • 觀察上面的例子能夠看出，咱們預先申請了一個指定大小的空間，可是有時候這個空間可能過小，有時候可能太大，咱們須要準確的大小，這樣節省空間，那麼咱們能夠這樣幹：

    /**
     * 字節流
     * 讀文件內容,節省空間
     * */
    import java.io.*;
    class hello{
        public static void main(String[] args) throws IOException {
            String fileName="D:"+File.separator+"hello.txt";
            File f=new File(fileName);
            InputStream in=new FileInputStream(f);
            byte[] b=new byte[(int)f.length()];
            in.read(b);
            System.out.println("文件長度爲："+f.length());
            in.close();
            System.out.println(new String(b));
        }
    }
    

  • 將上面的例子改成一個一個讀：

    /**
     * 字節流
     * 讀文件內容,節省空間
     * */
    import java.io.*;
    class hello{
        public static void main(String[] args) throws IOException {
            String fileName="D:"+File.separator+"hello.txt";
            File f=new File(fileName);
            InputStream in=new FileInputStream(f);
            byte[] b=new byte[(int)f.length()];
            for (int i = 0; i < b.length; i++) {
                b[i]=(byte)in.read();
            }
            in.close();
            System.out.println(new String(b));
        }
    }
    

  • 上面的幾個例子都是在知道文件的內容多大，而後才展開的，有時候咱們不知道文件有多大，這種狀況下，咱們須要判斷是否獨到文件的末尾:

    /**
     * 字節流
     *讀文件
     * */
    import java.io.*;
    class hello{
        public static void main(String[] args) throws IOException {
            String fileName="D:"+File.separator+"hello.txt";
            File f=new File(fileName);
            InputStream in=new FileInputStream(f);
            byte[] b=new byte[1024];
            int count =0;
            int temp=0;
            while((temp=in.read())!=(-1)){
                b[count++]=(byte)temp;
            }
            in.close();
            System.out.println(new String(b));
        }
    }
    

字符流

Reader：用於讀取字符流的抽象類。子類必須實現的方法只有 read(char[], int, int) 和 close()。

Writer：寫入字符流的抽象類。子類必須實現的方法僅有 write(char[], int, int)、flush() 和 close()。

那麼爲何要有字符流呢？由於字符每一個國家都不同，因此涉及到了字符編碼問題，那麼GBK編碼的中文用unicode編碼解析是有問題的，因此須要獲取中文字節數據的同時+ 指定的編碼表才能夠解析正確數據。爲了方便於文字的解析，因此將字節流和編碼表封裝成對象，這個對象就是字符流。只要操做字符數據，優先考慮使用字符流體系。

• 向文件中寫入數據

  • /**
     * 字符流
     * 寫入數據
     * */
    import java.io.*;
    class hello{
        public static void main(String[] args) throws IOException {
            String fileName="D:"+File.separator+"hello.txt";
            File f=new File(fileName);
            Writer out =new FileWriter(f);
            String str="hello";
            out.write(str);
            out.close();
        }
    }
    

    這個例子和以前的例子沒什麼區別，只是你能夠直接輸入字符串，而不須要你將字符串轉化爲字節數組。

    當你若是想在文件中追加內容的時候，可使用將上面的聲明out的哪一行換爲：

    Writer out =new FileWriter(f,true);

    這樣，當你運行程序的時候，會發現文件內容變爲：hellohello若是想在文件中換行的話，須要使用「\r\n」

    好比將str變爲String str="\r\nhello";這樣文件追加的str的內容就會換行了。

  • 從文件中讀內容：

    /**
     * 字符流
     * 從文件中讀出內容
     * */
    import java.io.*;
    class hello{
        public static void main(String[] args) throws IOException {
            String fileName="D:"+File.separator+"hello.txt";
            File f=new File(fileName);
            char[] ch=new char[100];
            Reader read=new FileReader(f);
            int count=read.read(ch);
            read.close();
            System.out.println("讀入的長度爲："+count);
            System.out.println("內容爲"+new String(ch,0,count));
        }
    }
    

  • 固然最好採用循環讀取的方式，由於咱們有時候不知道文件到底有多大:

    /**
     * 字符流
     * 從文件中讀出內容
     * */
    import java.io.*;
    class hello{
        public static void main(String[] args) throws IOException {
            String fileName="D:"+File.separator+"hello.txt";
            File f=new File(fileName);
            char[] ch=new char[100];
            Reader read=new FileReader(f);
            int temp=0;
            int count=0;
            while((temp=read.read())!=(-1)){
                ch[count++]=(char)temp;
            }
            read.close();
            System.out.println("內容爲"+new String(ch,0,count));
        }
    }
    

BufferedWriter

BufferedWriter是給字符輸出流提升效率用的，那就意味着，緩衝區對象創建時，必需要先有流對象。明確要提升具體的流對象的效率。

package heimablog;

import java.io.BufferedWriter;
import java.io.FileWriter;

class ShowTest {
	public static void main(String[] args) throws Exception {
		FileWriter fw = new FileWriter("bufdemo.txt");
		BufferedWriter bufw = new BufferedWriter(fw);// 讓緩衝區和指定流相關聯。
		for (int x = 0; x < 4; x++) {
			bufw.write(x + "abc");
			bufw.newLine(); // 寫入一個換行符，這個換行符能夠依據平臺的不一樣寫入不一樣的換行符。
			bufw.flush();// 對緩衝區進行刷新，可讓數據到目的地中。
		}
		bufw.close();// 關閉緩衝區，其實就是在關閉具體的流。
	}
} 

 

BufferedReader

package heimablog;

import java.io.BufferedReader;
import java.io.FileReader;

class ShowTest {
	public static void main(String[] args) throws Exception {
		FileReader fr = new FileReader("bufdemo.txt");
		BufferedReader bufr  = new BufferedReader(fr);
		String line = null;
		while((line=bufr.readLine())!=null){  //readLine方法返回的時候是不帶換行符的。
			System.out.println(line);
		}
		bufr.close();
	}
}

記住:

讀取鍵盤錄入：BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));

輸出到控制檯：BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));

字節流和字符流的區別

實際上字節流在操做的時候自己是不會用到緩衝區的，是文件自己的直接操做的，可是字符流在操做的時候是會用到緩衝區的，是經過緩衝區來操做文件的。若是將上面的字節流和字符流的程序的最後一行關閉文件的代碼註釋掉，而後運行程序看看。你就會發現使用字節流的話，文件中已經存在內容，可是使用字符流的時候，文件中仍是沒有內容的，這個時候就要刷新緩衝區。

使用字節流好仍是字符流好呢？

答案是字節流。首先由於硬盤上的全部文件都是以字節的形式進行傳輸或者保存的，包括圖片等內容。可是字符只是在內存中才會造成的，因此在開發中，字節流使用普遍。

由於功能的不一樣，流的體系中提供N多的對象。那麼開始時，到底該用哪一個對象更爲合適呢？這就須要明確流的操做規律。

流的操做規律

• 明確源和目的。

數據源：就是須要讀取，可使用兩個體系：InputStream、Reader；

數據匯：就是須要寫入，可使用兩個體系：OutputStream、Writer；

• 操做的數據是不是純文本數據？

若是是：數據源：Reader    數據匯：Writer

若是不是：數據源：InputStream      數據匯：OutputStream

• 雖然肯定了一個體系，可是該體系中有太多的對象，到底用哪一個呢？明確操做的數據設備。

數據源對應的設備：硬盤(File)，內存(數組)，鍵盤(System.in)

數據匯對應的設備：硬盤(File)，內存(數組)，控制檯(System.out)。

• 須要在基本操做上附加其餘功能嗎？好比緩衝。【若是須要就進行裝飾】
  

轉換流特有功能：轉換流能夠將字節轉成字符，緣由在於，將獲取到的字節經過查編碼表獲取到指定對應字符。

轉換流的最強功能就是基於 字節流 + 編碼表 。沒有轉換，沒有字符流。

發現轉換流有一個子類就是操做文件的字符流對象：

InputStreamReader

|--FileReader

OutputStreamWriter

|--FileWrier

想要操做文本文件，必需要進行編碼轉換，而編碼轉換動做轉換流都完成了。因此操做文件的流對象只要繼承自轉換流就能夠讀取一個字符了。

可是子類有一個侷限性，就是子類中使用的編碼是固定的，是本機默認的編碼表，對於簡體中文版的系統默認碼錶是GBK。

FileReader fr = new FileReader("a.txt");

InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"),"gbk");

以上兩句代碼功能一致，

• 若是僅僅使用平臺默認碼錶，就使用FileReader fr = new FileReader("a.txt"); //由於簡化。
• 若是須要制定碼錶，必須用轉換流。

轉換流 = 字節流+編碼表。

轉換流的子類File = 字節流 + 默認編碼表。

凡是操做設備上的文本數據，涉及編碼轉換，必須使用轉換流。

OutputStreramWriter 和InputStreamReader類

OutputStreramWriter將輸出的字符流轉化爲字節流

InputStreamReader將輸入的字節流轉換爲字符流

可是無論如何操做，最後都是以字節的形式保存在文件中的。

• 將字節輸出流轉化爲字符輸出流

  /**
   * 將字節輸出流轉化爲字符輸出流
   * */
  import java.io.*;
  class hello{
      public static void main(String[] args) throws IOException {
          String fileName= "d:"+File.separator+"hello.txt";
          File file=new File(fileName);
          Writer out=new OutputStreamWriter(new FileOutputStream(file));
          out.write("hello");
          out.close();
      }
  }
  

• 將字節輸入流變爲字符輸入流

  /**
   * 將字節輸入流變爲字符輸入流
   * */
  import java.io.*;
  class hello{
      public static void main(String[] args) throws IOException {
          String fileName= "d:"+File.separator+"hello.txt";
          File file=new File(fileName);
          Reader read=new InputStreamReader(new FileInputStream(file));
          char[] b=new char[100];
          int len=read.read(b);
          System.out.println(new String(b,0,len));
          read.close();
      }
  }
  

• 前面列舉的輸出輸入都是以文件進行的，如今咱們之內容爲輸出輸入目的地，使用內存操做流：

   ByteArrayInputStream 主要將內容寫入內存

   ByteArrayOutputStream  主要將內容從內存輸出

  使用內存操做流將一個大寫字母轉化爲小寫字母：

  /**
   * 使用內存操做流將一個大寫字母轉化爲小寫字母
   * */
  import java.io.*;
  class hello{
      public static void main(String[] args) throws IOException {
          String str="ROLLENHOLT";
          ByteArrayInputStream input=new ByteArrayInputStream(str.getBytes());
          ByteArrayOutputStream output=new ByteArrayOutputStream();
          int temp=0;
          while((temp=input.read())!=-1){
              char ch=(char)temp;
              output.write(Character.toLowerCase(ch));
          }
          String outStr=output.toString();
          input.close();
          output.close();
          System.out.println(outStr);
      }
  }
  

  內容操做流通常使用來生成一些臨時信息採用的，這樣能夠避免刪除的麻煩。 

File類

將文件系統中的文件和文件夾封裝成了對象。提供了更多的屬性和行爲能夠對這些文件和文件夾進行操做。

這些是流對象辦不到的，由於流只操做數據。

File類常見方法

1：建立

boolean createNewFile()：在指定目錄下建立文件，若是該文件已存在，則不建立。

而對操做文件的輸出流而言，輸出流對象已創建，就會建立文件，若是文件已存在，會覆蓋。除非續寫。

boolean mkdir()：建立此抽象路徑名指定的目錄。

boolean mkdirs()：建立多級目錄。 

2：刪除

boolean delete()：刪除此抽象路徑名錶示的文件或目錄。

void deleteOnExit()：在虛擬機退出時刪除。

注意：在刪除文件夾時，必須保證這個文件夾中沒有任何內容，才能夠將該文件夾用delete刪除。

window的刪除動做，是從裏往外刪。注意：java刪除文件不走回收站。要慎用。

3：獲取

long length()：獲取文件大小。

String getName()：返回由此抽象路徑名錶示的文件或目錄的名稱。

String getPath()：將此抽象路徑名轉換爲一個路徑名字符串。

String getAbsolutePath()：返回此抽象路徑名的絕對路徑名字符串。

String getParent()：返回此抽象路徑名父目錄的抽象路徑名，若是此路徑名沒有指定父目錄，則返回 null。

long lastModified()：返回此抽象路徑名錶示的文件最後一次被修改的時間。

File.pathSeparator：返回當前系統默認的路徑分隔符，windows默認爲 「；」。

File.Separator：返回當前系統默認的目錄分隔符，windows默認爲 「\」。

4：判斷

boolean exists()：判斷文件或者文件夾是否存在。

boolean isDirectory()：測試此抽象路徑名錶示的文件是不是一個目錄。

boolean isFile()：測試此抽象路徑名錶示的文件是不是一個標準文件。

boolean isHidden()：測試此抽象路徑名指定的文件是不是一個隱藏文件。

boolean isAbsolute()：測試此抽象路徑名是否爲絕對路徑名。

5：重命名

 boolean renameTo(File dest)：能夠實現移動的效果。剪切+重命名。

 String[] list()：列出指定目錄下的當前的文件和文件夾的名稱。包含隱藏文件。

若是調用list方法的File 對象中封裝的是一個文件，那麼list方法返回數組爲null。若是封裝的對象不存在也會返回null。只有封裝的對象存在而且是文件夾時，這個方法纔有效。

建立一個新文件

import java.io.*;
class hello{
    public static void main(String[] args) {
        File f=new File("D:\\hello.txt");
        try{
            f.createNewFile();
        }catch (Exception e) {
            e.printStackTrace();
        }
    }
}  

File類的兩個常量 

	System.out.println(File.separator);//  \
	System.out.println(File.pathSeparator);//  ;

刪除一個文件

/**
 * 刪除一個文件
 * */
import java.io.*;
class hello{
    public static void main(String[] args) {
        String fileName="D:"+File.separator+"hello.txt";
        File f=new File(fileName);
        if(f.exists()){
            f.delete();
        }else{
            System.out.println("文件不存在");
        }
         
    }
}  

建立一個文件夾

/**
 * 建立一個文件夾
 * */
import java.io.*;
class hello{
    public static void main(String[] args) {
        String fileName="D:"+File.separator+"hello";
        File f=new File(fileName);
        f.mkdir();
    }
}  

文件的複製

採用DOS命令：copy d:\hello.txt d:\rollen.txt

使用程序來複制文件的基本思路仍是從一個文件中讀入內容，邊讀邊寫入另外一個文件，就是這麼簡單：

/**
 * 文件的複製
 * */
import java.io.*;
class hello{
    public static void main(String[] args) throws IOException {
        if(args.length!=2){
            System.out.println("命令行參數輸入有誤，請檢查");
            System.exit(1);
        }
        File file1=new File(args[0]);
        File file2=new File(args[1]);
         
        if(!file1.exists()){
            System.out.println("被複制的文件不存在");
            System.exit(1);
        }
        InputStream input=new FileInputStream(file1);
        OutputStream output=new FileOutputStream(file2);
        if((input!=null)&&(output!=null)){
            int temp=0;
            while((temp=input.read())!=(-1)){
                output.write(temp);
            }
        }
        input.close();
        output.close();
    }
}  

而後在命令行下面

javac hello.java

java hello d:\hello.txt d:\rollen.txt

如今你就會在d盤看到rollen.txt了。

列出指定目錄的所有文件（包括隱藏文件）

/**
 * 使用list列出指定目錄的所有文件
 * */
import java.io.*;
class hello{
    public static void main(String[] args) {
        String fileName="D:"+File.separator;
        File f=new File(fileName);
        String[] str=f.list();
        for (int i = 0; i < str.length; i++) {
            System.out.println(str[i]);
        }
    }
}  

/**
 * 使用listFiles列出指定目錄的所有文件
 * listFiles輸出的是完整路徑
 * */
import java.io.*;
class hello{
    public static void main(String[] args) {
        String fileName="D:"+File.separator;
        File f=new File(fileName);
        File[] str=f.listFiles();
        for (int i = 0; i < str.length; i++) {
            System.out.println(str[i]);
        }
    }
} 

判斷一個指定的路徑是否爲目錄

/**
 * 使用isDirectory判斷一個指定的路徑是否爲目錄
 * */
import java.io.*;
class hello{
    public static void main(String[] args) {
        String fileName="D:"+File.separator;
        File f=new File(fileName);
        if(f.isDirectory()){
            System.out.println("YES");
        }else{
            System.out.println("NO");
        }
    }
}  

搜索指定目錄的所有內容

/**
 * 列出指定目錄的所有內容
 * */
import java.io.*;
class hello{
    public static void main(String[] args) {
        String fileName="D:"+File.separator;
        File f=new File(fileName);
        print(f);
    }
    public static void print(File f){
        if(f!=null){
            if(f.isDirectory()){
                File[] fileArray=f.listFiles();
                if(fileArray!=null){
                    for (int i = 0; i < fileArray.length; i++) {
                        //遞歸調用
                        print(fileArray[i]);
                    }
                }
            }
            else{
                System.out.println(f);
            }
        }
    }
}  

使用RandomAccessFile寫入文件

/**
 * 使用RandomAccessFile寫入文件
 * */
import java.io.*;
class hello{
    public static void main(String[] args) throws IOException {
        String fileName="D:"+File.separator+"hello.txt";
        File f=new File(fileName);
        RandomAccessFile demo=new RandomAccessFile(f,"rw");
        demo.writeBytes("asdsad");
        demo.writeInt(12);
        demo.writeBoolean(true);
        demo.writeChar('A');
        demo.writeFloat(1.21f);
        demo.writeDouble(12.123);
        demo.close();  
    }
}  

Java.io.outputstream.PrintStream：打印流

1. 提供了更多的功能，好比打印方法。能夠直接打印任意類型的數據。
2. 它有一個自動刷新機制，建立該對象，指定參數，對於指定方法能夠自動刷新。
3. 它使用的本機默認的字符編碼. 
4. 該流的print方法不拋出IOException。

該對象的構造函數:

• PrintStream(File file)  ：建立具備指定文件且不帶自動行刷新的新打印流。 
• PrintStream(File file, String csn) ：建立具備指定文件名稱和字符集且不帶自動行刷新的新打印流。 
• PrintStream(OutputStream out) ：建立新的打印流。 
• PrintStream(OutputStream out, boolean autoFlush) ：建立新的打印流。 
• PrintStream(OutputStream out, boolean autoFlush, String encoding) ：建立新的打印流。 
• PrintStream(String fileName) ：建立具備指定文件名稱且不帶自動行刷新的新打印流。 
• PrintStream(String fileName, String csn) 

PrintStream能夠操做目的：1：File對象。2：字符串路徑。3：字節輸出流。

前兩個都JDK1.5版本纔出現。並且在操做文本文件時，可指定字符編碼了。

當目的是一個字節輸出流時，若是使用的println方法，能夠在printStream對象上加入一個true參數。這樣對於println方法能夠進行自動的刷新，而不是等待緩衝區滿了再刷新。最終print方法都將具體的數據轉成字符串，並且都對IO異常進行了內部處理。

既然操做的數據都轉成了字符串，那麼使用PrintWriter更好一些。由於PrintWrite是字符流的子類，能夠直接操做字符數據，同時也能夠指定具體的編碼。

PrintWriter：具有了PrintStream的特色同時，還有自身特色：

該對象的目的地有四個：1：File對象。2：字符串路徑。3：字節輸出流。4：字符輸出流。【開發時儘可能使用PrintWriter】

方法中直接操做文件的第二參數是編碼表。

直接操做輸出流的，第二參數是自動刷新。

		// 讀取鍵盤錄入將數據轉成大寫顯示在控制檯.
		BufferedReader bufr = new BufferedReader(new InputStreamReader(
				System.in));// 源：鍵盤輸入

		// 目的：把數據寫到文件中，還想自動刷新。
		PrintWriter out = new PrintWriter(new FileWriter("out.txt"), true);// 設置true後自動刷新
		
		String line = null;
		while ((line = bufr.readLine()) != null) {
			if ("over".equals(line))
				break;
			out.println(line.toUpperCase());// 轉大寫輸出
		}
		// 注意：System.in，System.out這兩個標準的輸入輸出流，在jvm啓動時已經存在了。隨時可使用。當jvm結束了，這兩個流就結束了。可是，當使用了顯示的close方法關閉時，這兩個流在提早結束了。
		out.close();
		bufr.close();

管道流

管道流主要能夠進行兩個線程之間的通訊。

PipedOutputStream 管道輸出流

PipedInputStream 管道輸入流

• 驗證管道流

  /**
   * 驗證管道流
   * */
  import java.io.*;
   
  /**
   * 消息發送類
   * */
  class Send implements Runnable{
      private PipedOutputStream out=null;
      public Send() {
          out=new PipedOutputStream();
      }
      public PipedOutputStream getOut(){
          return this.out;
      }
      public void run(){
          String message="hello , Rollen";
          try{
              out.write(message.getBytes());
          }catch (Exception e) {
              e.printStackTrace();
          }try{
              out.close();
          }catch (Exception e) {
              e.printStackTrace();
          }
      }
  }
   
  /**
   * 接受消息類
   * */
  class Recive implements Runnable{
      private PipedInputStream input=null;
      public Recive(){
          this.input=new PipedInputStream();
      }
      public PipedInputStream getInput(){
          return this.input;
      }
      public void run(){
          byte[] b=new byte[1000];
          int len=0;
          try{
              len=this.input.read(b);
          }catch (Exception e) {
              e.printStackTrace();
          }try{
              input.close();
          }catch (Exception e) {
              e.printStackTrace();
          }
          System.out.println("接受的內容爲 "+(new String(b,0,len)));
      }
  }
  /**
   * 測試類
   * */
  class hello{
      public static void main(String[] args) throws IOException {
          Send send=new Send();
          Recive recive=new Recive();
          try{
  //管道鏈接
              send.getOut().connect(recive.getInput());
          }catch (Exception e) {
              e.printStackTrace();
          }
          new Thread(send).start();
          new Thread(recive).start();
      }
  } 

• 打印流

  /**
   * 使用PrintStream進行輸出
   * */
  import java.io.*;
   
  class hello {
      public static void main(String[] args) throws IOException {
          PrintStream print = new PrintStream(new FileOutputStream(new File("d:"
                  + File.separator + "hello.txt")));
          print.println(true);
          print.println("Rollen");
          print.close();
      }
  }
  

• 固然也能夠格式化輸出

  /**
   * 使用PrintStream進行輸出
   * 並進行格式化
   * */
  import java.io.*;
  class hello {
      public static void main(String[] args) throws IOException {
          PrintStream print = new PrintStream(new FileOutputStream(new File("d:"
                  + File.separator + "hello.txt")));
          String name="Rollen";
          int age=20;
          print.printf("姓名：%s. 年齡：%d.",name,age);
          print.close();
      }
  } 

• 使用OutputStream向屏幕上輸出內容

  /**
   * 使用OutputStream向屏幕上輸出內容
   * */
  import java.io.*;
  class hello {
      public static void main(String[] args) throws IOException {
          OutputStream out=System.out;
          try{
              out.write("hello".getBytes());
          }catch (Exception e) {
              e.printStackTrace();
          }
          try{
              out.close();
          }catch (Exception e) {
              e.printStackTrace();
          }
      }
  }
  

• 輸入輸出重定向

  import java.io.File;
  import java.io.FileNotFoundException;
  import java.io.FileOutputStream;
  import java.io.PrintStream;
   
  /**
   * 爲System.out.println()重定向輸出
   * */
  public class systemDemo{
      public static void main(String[] args){
          // 此刻直接輸出到屏幕
          System.out.println("hello");
          File file = new File("d:" + File.separator + "hello.txt");
          try{
              System.setOut(new PrintStream(new FileOutputStream(file)));
          }catch(FileNotFoundException e){
              e.printStackTrace();
          }
          System.out.println("iadanac");
      }
  }
  

  【運行結果】：eclipse的控制檯輸出的是hello。而後當咱們查看d盤下面的hello.txt文件的時候，會在裏面看到：iadanac!

  import java.io.File;
  import java.io.FileNotFoundException;
  import java.io.FileOutputStream;
  import java.io.PrintStream;
   
  /**
   * System.err重定向 這個例子也提示咱們可使用這種方法保存錯誤信息
   * */
  public class systemErr{
      public static void main(String[] args){
          File file = new File("d:" + File.separator + "hello.txt");
          System.err.println("這些在控制檯輸出");
          try{
              System.setErr(new PrintStream(new FileOutputStream(file)));
          }catch(FileNotFoundException e){
              e.printStackTrace();
          }
          System.err.println("這些在文件中才能看到哦！");
      }
  }
  

  【運行結果】：你會在eclipse的控制檯看到紅色的輸出：「這些在控制檯輸出」，而後在d盤下面的hello.txt中會看到：這些在文件中才能看到哦！

  import java.io.File;
  import java.io.FileInputStream;
  import java.io.FileNotFoundException;
  import java.io.IOException;
   
  /**
   * System.in重定向
   * */
  public class systemIn{
      public static void main(String[] args){
          File file = new File("d:" + File.separator + "hello.txt");
          if(!file.exists()){
              return;
          }else{
              try{
                  System.setIn(new FileInputStream(file));
              }catch(FileNotFoundException e){
                  e.printStackTrace();
              }
              byte[] bytes = new byte[1024];
              int len = 0;
              try{
                  len = System.in.read(bytes);
              }catch(IOException e){
                  e.printStackTrace();
              }
              System.out.println("讀入的內容爲：" + new String(bytes, 0, len));
          }
      }
  }
  

  【運行結果】：前提是個人d盤下面的hello.txt中的內容是：「這些文件中的內容哦！」，而後運行程序，輸出的結果爲：讀入的內容爲：這些文件中的內容哦！

BufferedReader

注意： BufferedReader只能接受字符流的緩衝區，由於每個中文須要佔據兩個字節，因此須要將System.in這個字節輸入流變爲字符輸入流，採用：

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

下面給一個實例：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
 
/**
 * 使用緩衝區從鍵盤上讀入內容
 * */
public class BufferedReaderDemo{
    public static void main(String[] args){
        BufferedReader buf = new BufferedReader(
                new InputStreamReader(System.in));
        String str = null;
        System.out.println("請輸入內容");
        try{
            str = buf.readLine();
        }catch(IOException e){
            e.printStackTrace();
        }
        System.out.println("你輸入的內容是：" + str);
    }
}

Scanner類

其實咱們比較經常使用的是採用Scanner類來進行數據輸入，下面來給一個Scanner的例子吧

import java.util.Scanner;
 
/**
 * Scanner的小例子，從鍵盤讀數據
 * */
public class ScannerDemo{
    public static void main(String[] args){
        Scanner sca = new Scanner(System.in);
        // 讀一個整數
        int temp = sca.nextInt();
        System.out.println(temp);
        //讀取浮點數
        float flo=sca.nextFloat();
        System.out.println(flo);
        //讀取字符
    }
}  

其實Scanner能夠接受任何的輸入流，下面給一個使用Scanner類從文件中讀出內容：

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
 
/**
 * Scanner的小例子，從文件中讀內容
 * */
public class ScannerDemo{
    public static void main(String[] args){
 
        File file = new File("d:" + File.separator + "hello.txt");
        Scanner sca = null;
        try{
            sca = new Scanner(file);
        }catch(FileNotFoundException e){
            e.printStackTrace();
        }
        String str = sca.next();
        System.out.println("從文件中讀取的內容是：" + str);
    }
}  

數據操做流DataOutputStream、DataInputStream類

import java.io.DataOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
 
public class DataOutputStreamDemo{
    public static void main(String[] args) throws IOException{
        File file = new File("d:" + File.separator + "hello.txt");
        char[] ch = { 'A', 'B', 'C' };
        DataOutputStream out = null;
        out = new DataOutputStream(new FileOutputStream(file));
        for(char temp : ch){
            out.writeChar(temp);
        }
        out.close();
    }
}  

 如今咱們在上面例子的基礎上，使用DataInputStream讀出內容

import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
 
public class DataOutputStreamDemo{
    public static void main(String[] args) throws IOException{
        File file = new File("d:" + File.separator + "hello.txt");
        DataInputStream input = new DataInputStream(new FileInputStream(file));
        char[] ch = new char[10];
        int count = 0;
        char temp;
        while((temp = input.readChar()) != 'C'){
            ch[count++] = temp;
        }
        System.out.println(ch);
    }
}    

合併流 SequenceInputStream

 SequenceInputStream主要用來將2個流合併在一塊兒，好比將兩個txt中的內容合併爲另一個txt。下面給出一個實例：

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.SequenceInputStream;
 
/**
 * 將兩個文本文件合併爲另一個文本文件
 * */
public class SequenceInputStreamDemo{
    public static void main(String[] args) throws IOException{
        File file1 = new File("d:" + File.separator + "hello1.txt");
        File file2 = new File("d:" + File.separator + "hello2.txt");
        File file3 = new File("d:" + File.separator + "hello.txt");
        InputStream input1 = new FileInputStream(file1);
        InputStream input2 = new FileInputStream(file2);
        OutputStream output = new FileOutputStream(file3);
        // 合併流
        SequenceInputStream sis = new SequenceInputStream(input1, input2);
        int temp = 0;
        while((temp = sis.read()) != -1){
            output.write(temp);
        }
        input1.close();
        input2.close();
        output.close();
        sis.close();
    }
}  

文件壓縮 ZipOutputStream類

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;
 
public class ZipOutputStreamDemo1{
    public static void main(String[] args) throws IOException{
        File file = new File("d:" + File.separator + "hello.txt");
        File zipFile = new File("d:" + File.separator + "hello.zip");
        InputStream input = new FileInputStream(file);
        ZipOutputStream zipOut = new ZipOutputStream(new FileOutputStream(
                zipFile));
        zipOut.putNextEntry(new ZipEntry(file.getName()));
        // 設置註釋
        zipOut.setComment("hello");
        int temp = 0;
        while((temp = input.read()) != -1){
            zipOut.write(temp);
        }
        input.close();
        zipOut.close();
    }
}  

上面的這個例子測試的是壓縮單個文件，下面的們來看看如何壓縮多個文件：

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;
 
/**
 * 一次性壓縮多個文件
 * */
public class ZipOutputStreamDemo2{
    public static void main(String[] args) throws IOException{
        // 要被壓縮的文件夾
        File file = new File("d:" + File.separator + "temp");
        File zipFile = new File("d:" + File.separator + "zipFile.zip");
        InputStream input = null;
        ZipOutputStream zipOut = new ZipOutputStream(new FileOutputStream(
                zipFile));
        zipOut.setComment("hello");
        if(file.isDirectory()){
            File[] files = file.listFiles();
            for(int i = 0; i < files.length; ++i){
                input = new FileInputStream(files[i]);
                zipOut.putNextEntry(new ZipEntry(file.getName()
                        + File.separator + files[i].getName()));
                int temp = 0;
                while((temp = input.read()) != -1){
                    zipOut.write(temp);
                }
                input.close();
            }
        }
        zipOut.close();
    }
}  

 你們天然想到，既然能壓縮，天然能解壓縮，在談解壓縮以前，咱們會用到一個ZipFile類，先給一個這個例子吧。java中的每個壓縮文件都是可使用ZipFile來進行表示的

import java.io.File;
import java.io.IOException;
import java.util.zip.ZipFile;
 
/**
 * ZipFile演示
 * */
public class ZipFileDemo{
    public static void main(String[] args) throws IOException{
        File file = new File("d:" + File.separator + "hello.zip");
        ZipFile zipFile = new ZipFile(file);
        System.out.println("壓縮文件的名稱爲：" + zipFile.getName());
    }
}

 來看看如何加壓縮文件了，和以前同樣，先讓咱們來解壓單個壓縮文件（也就是壓縮文件中只有一個文件的狀況），咱們採用前面的例子產生的壓縮文件hello.zip

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
 
/**
 * 解壓縮文件（壓縮文件中只有一個文件的狀況）
 * */
public class ZipFileDemo2{
    public static void main(String[] args) throws IOException{
        File file = new File("d:" + File.separator + "hello.zip");
        File outFile = new File("d:" + File.separator + "unZipFile.txt");
        ZipFile zipFile = new ZipFile(file);
        ZipEntry entry = zipFile.getEntry("hello.txt");
        InputStream input = zipFile.getInputStream(entry);
        OutputStream output = new FileOutputStream(outFile);
        int temp = 0;
        while((temp = input.read()) != -1){
            output.write(temp);
        }
        input.close();
        output.close();
    }
}  

ZipInputStream類【來解壓一個壓縮文件中包含多個文件】

當咱們須要解壓縮多個文件的時候，ZipEntry就沒法使用了，若是想操做更加複雜的壓縮文件，咱們就必須使用ZipInputStream類

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import java.util.zip.ZipInputStream;
 
/**
 * 解壓縮一個壓縮文件中包含多個文件的狀況
 * */
public class ZipFileDemo3{
    public static void main(String[] args) throws IOException{
        File file = new File("d:" + File.separator + "zipFile.zip");
        File outFile = null;
        ZipFile zipFile = new ZipFile(file);
        ZipInputStream zipInput = new ZipInputStream(new FileInputStream(file));
        ZipEntry entry = null;
        InputStream input = null;
        OutputStream output = null;
        while((entry = zipInput.getNextEntry()) != null){
            System.out.println("解壓縮" + entry.getName() + "文件");
            outFile = new File("d:" + File.separator + entry.getName());
            if(!outFile.getParentFile().exists()){
                outFile.getParentFile().mkdir();
            }
            if(!outFile.exists()){
                outFile.createNewFile();
            }
            input = zipFile.getInputStream(entry);
            output = new FileOutputStream(outFile);
            int temp = 0;
            while((temp = input.read()) != -1){
                output.write(temp);
            }
            input.close();
            output.close();
        }
    }
} 

 PushBackInputStream回退流

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.PushbackInputStream;
 
/**
 * 回退流操做
 * */
public class PushBackInputStreamDemo{
    public static void main(String[] args) throws IOException{
        String str = "hello,rollenholt";
        PushbackInputStream push = null;
        ByteArrayInputStream bat = null;
        bat = new ByteArrayInputStream(str.getBytes());
        push = new PushbackInputStream(bat);
        int temp = 0;
        while((temp = push.read()) != -1){
            if(temp == ','){
                push.unread(temp);
                temp = push.read();
                System.out.print("(回退" + (char) temp + ") ");
            }else{
                System.out.print((char) temp);
            }
        }
    }
}  

/**
 * 取得本地的默認編碼
 * */
public class CharSetDemo{
    public static void main(String[] args){
        System.out.println("系統默認編碼爲：" + System.getProperty("file.encoding"));
    }
}

 亂碼的產生：

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
 
/**
 * 亂碼的產生
 * */
public class CharSetDemo2{
    public static void main(String[] args) throws IOException{
        File file = new File("d:" + File.separator + "hello.txt");
        OutputStream out = new FileOutputStream(file);
        byte[] bytes = "你好".getBytes("ISO8859-1");
        out.write(bytes);
        out.close();
    }
} 

 通常狀況下產生亂碼，都是因爲編碼不一致的問題。

對象的序列化

對象序列化就是把一個對象變爲二進制數據流的一種方法。

一個類要想被序列化，就行必須實現java.io.Serializable接口。雖然這個接口中沒有任何方法，就如同以前的cloneable接口同樣。實現了這個接口以後，就表示這個類具備被序列化的能力。

先讓咱們實現一個具備序列化能力的類吧：

import java.io.*;
/**
 * 實現具備序列化能力的類
 * */
public class SerializableDemo implements Serializable{
    public SerializableDemo(){
         
    }
    public SerializableDemo(String name, int age){
        this.name=name;
        this.age=age;
    }
    @Override
    public String toString(){
        return "姓名："+name+"  年齡："+age;
    }
    private String name;
    private int age;
} 

這個類就具備實現序列化能力，在繼續將序列化以前，先看一下ObjectInputStream和ObjectOutputStream這兩個類

當咱們查看產生的hello.txt的時候，看到的是亂碼，由於是二進制文件。

雖然咱們不能直接查看裏面的內容，可是咱們可使用ObjectInputStream類查看：

import java.io.File;
import java.io.FileInputStream;
import java.io.ObjectInputStream;
 
/**
 * ObjectInputStream示範
 * */
public class ObjectInputStreamDemo{
    public static void main(String[] args) throws Exception{
        File file = new File("d:" + File.separator + "hello.txt");
        ObjectInputStream input = new ObjectInputStream(new FileInputStream(
                file));
        Object obj = input.readObject();
        input.close();
        System.out.println(obj);
    }
}

到底序列化什麼內容呢？其實只有屬性會被序列化。

Externalizable接口

被Serializable接口聲明的類的對象的屬性都將被序列化，可是若是想自定義序列化的內容的時候，就須要實現Externalizable接口。

當一個類要使用Externalizable這個接口的時候，這個類中必需要有一個無參的構造函數，若是沒有的話，在構造的時候會產生異常，這是由於在反序列話的時候會默認調用無參的構造函數。

如今咱們來演示一下序列化和反序列話：

package IO;
 
import java.io.Externalizable;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
 
/**
 * 序列化和反序列化的操做
 * */
public class ExternalizableDemo{
    public static void main(String[] args) throws Exception{
        ser(); // 序列化
        dser(); // 反序列話
    }
 
    public static void ser() throws Exception{
        File file = new File("d:" + File.separator + "hello.txt");
        ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(
                file));
        out.writeObject(new Person("rollen", 20));
        out.close();
    }
 
    public static void dser() throws Exception{
        File file = new File("d:" + File.separator + "hello.txt");
        ObjectInputStream input = new ObjectInputStream(new FileInputStream(
                file));
        Object obj = input.readObject();
        input.close();
        System.out.println(obj);
    }
}
 
class Person implements Externalizable{
    public Person(){
 
    }
 
    public Person(String name, int age){
        this.name = name;
        this.age = age;
    }
 
    @Override
    public String toString(){
        return "姓名：" + name + "  年齡：" + age;
    }
 
    // 複寫這個方法，根據須要能夠保存的屬性或者具體內容，在序列化的時候使用
    @Override
    public void writeExternal(ObjectOutput out) throws IOException{
        out.writeObject(this.name);
        out.writeInt(age);
    }
 
    // 複寫這個方法，根據須要讀取內容 反序列話的時候須要
    @Override
    public void readExternal(ObjectInput in) throws IOException,
            ClassNotFoundException{
        this.name = (String) in.readObject();
        this.age = in.readInt();
    }
 
    private String name;
    private int age;
}  

【運行結果】：

姓名：rollen  年齡：20

本例中，咱們將所有的屬性都保留了下來，

Serializable接口實現的操做實際上是吧一個對象中的所有屬性進行序列化，固然也可使用咱們上使用是Externalizable接口以實現部分屬性的序列化，可是這樣的操做比較麻煩，

當咱們使用Serializable接口實現序列化操做的時候，若是一個對象的某一個屬性不想被序列化保存下來，那麼咱們可使用transient關鍵字進行說明：

package IO;
 
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
 
/**
 * 序列化和反序列化的操做
 * */
public class serDemo{
    public static void main(String[] args) throws Exception{
        ser(); // 序列化
        dser(); // 反序列話
    }
 
    public static void ser() throws Exception{
        File file = new File("d:" + File.separator + "hello.txt");
        ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(
                file));
        out.writeObject(new Person1("rollen", 20));
        out.close();
    }
 
    public static void dser() throws Exception{
        File file = new File("d:" + File.separator + "hello.txt");
        ObjectInputStream input = new ObjectInputStream(new FileInputStream(
                file));
        Object obj = input.readObject();
        input.close();
        System.out.println(obj);
    }
}
 
class Person1 implements Serializable{
    public Person1(){
 
    }
 
    public Person1(String name, int age){
        this.name = name;
        this.age = age;
    }
 
    @Override
    public String toString(){
        return "姓名：" + name + "  年齡：" + age;
    }
 
    // 注意這裏
    private transient String name;
    private int age;
}  

【運行結果】：
姓名：null  年齡：20
最後在給一個序列化一組對象的例子吧：

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
 
/**
 * 序列化一組對象
 * */
public class SerDemo1{
    public static void main(String[] args) throws Exception{
        Student[] stu = { new Student("hello", 20), new Student("world", 30),
                new Student("rollen", 40) };
        ser(stu);
        Object[] obj = dser();
        for(int i = 0; i < obj.length; ++i){
            Student s = (Student) obj[i];
            System.out.println(s);
        }
    }
 
    // 序列化
    public static void ser(Object[] obj) throws Exception{
        File file = new File("d:" + File.separator + "hello.txt");
        ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(
                file));
        out.writeObject(obj);
        out.close();
    }
 
    // 反序列化
    public static Object[] dser() throws Exception{
        File file = new File("d:" + File.separator + "hello.txt");
        ObjectInputStream input = new ObjectInputStream(new FileInputStream(
                file));
        Object[] obj = (Object[]) input.readObject();
        input.close();
        return obj;
    }
}
 
class Student implements Serializable{
    public Student(){
 
    }
 
    public Student(String name, int age){
        this.name = name;
        this.age = age;
    }
 
    @Override
    public String toString(){
        return "姓名：  " + name + "  年齡：" + age;
    }
 
    private String name;
    private int age;
}  

【運行結果】：

姓名：  hello  年齡：20

姓名：  world  年齡：30

姓名：  rollen  年齡：40