java IO流詳解

流的概念和做用

學習Java IO，不得不提到的就是JavaIO流。

流是一組有順序的，有起點和終點的字節集合，是對數據傳輸的總稱或抽象。即數據在兩設備間的傳輸稱爲流，流的本質是數據傳輸，根據數據傳輸特性將流抽象爲各類類，方便更直觀的進行數據操做。

IO流的分類

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

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

字符流和字節流

字符流的由來： 由於數據編碼的不一樣，而有了對字符進行高效操做的流對象。本質其實就是基於字節流讀取時，去查了指定的碼錶。字節流和字符流的區別：

（1）讀寫單位不一樣：字節流以字節（8bit）爲單位，字符流以字符爲單位，根據碼錶映射字符，一次可能讀多個字節。

（2）處理對象不一樣：字節流能處理全部類型的數據（如圖片、avi等），而字符流只能處理字符類型的數據。

（3）字節流在操做的時候自己是不會用到緩衝區的，是文件自己的直接操做的；而字符流在操做的時候下後是會用到緩衝區的，是經過緩衝區來操做文件，咱們將在下面驗證這一點。

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

輸入流和輸出流

對輸入流只能進行讀操做，對輸出流只能進行寫操做，程序中須要根據待傳輸數據的不一樣特性而使用不一樣的流。

Java流類圖結構：

 

Java IO流對象

1. 輸入字節流InputStream

定義和結構說明：

從輸入字節流的繼承圖能夠看出：

InputStream 是全部的輸入字節流的父類，它是一個抽象類。

ByteArrayInputStream、StringBufferInputStream、FileInputStream 是三種基本的介質流，它們分別從Byte 數組、StringBuffer、和本地文件中讀取數據。PipedInputStream 是從與其它線程共用的管道中讀取數據，與Piped 相關的知識後續單獨介紹。

ObjectInputStream 和全部FilterInputStream的子類都是裝飾流（裝飾器模式的主角）。意思是FileInputStream類能夠經過一個String路徑名建立一個對象，FileInputStream(String name)。而DataInputStream必須裝飾一個類才能返回一個對象，DataInputStream(InputStream in)。以下圖示：

實例操做演示：

【案例 】讀取文件內容

/**
 * 字節流
 * 讀文件內容
 * */
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));
    }
}

注意：該示例中因爲b字節數組長度爲1024，若是文件較小，則會有大量填充空格。咱們能夠利用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));
    }
}

注意：當讀到文件末尾的時候會返回-1.正常狀況下是不會返回-1的。

【案例】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);
    }
}

【案例】PushBackInputStream回退流操做

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.PushbackInputStream;
 
/**
 * 回退流操做
 * */
public class PushBackInputStreamDemo{
    public static void main(String[] args) throwsIOException{
       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);
           }
       }
    }
}

2. 輸出字節流OutputStream

定義和結構說明：

IO 中輸出字節流的繼承圖可見上圖，能夠看出：

OutputStream 是全部的輸出字節流的父類，它是一個抽象類。

ByteArrayOutputStream、FileOutputStream是兩種基本的介質流，它們分別向Byte 數組、和本地文件中寫入數據。PipedOutputStream 是向與其它線程共用的管道中寫入數據，

ObjectOutputStream 和全部FilterOutputStream的子類都是裝飾流。具體例子跟InputStream是對應的。

實例操做演示：

【案例】向文件中寫入字符串

/**
 * 字節流
 * 向文件中寫入字符串
 * */
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="Hello World";
       byte[] b=str.getBytes();
       out.write(b);
       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);
       OutputStream out =new FileOutputStream(f);
       String str="Hello World！！";
       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);
       OutputStream out =new FileOutputStream(f,true);//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 {
       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();
    }
}

【案例】使用內存操做流將一個大寫字母轉化爲小寫字母

/**
 * 使用內存操做流將一個大寫字母轉化爲小寫字母
 * */
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);
    }
}

【案例】驗證管道流：進程間通訊

/**
 * 驗證管道流
 * */
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();
    }
}

【案例】DataOutputStream類示例

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();
    }
}

【案例】ZipOutputStream類

先看一下ZipOutputStream類的繼承關係

java.lang.Object

java.io.OutputStream

java.io.FilterOutputStream

java.util.zip.DeflaterOutputStream

java.util.zip.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();
    }
}

【案例】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 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 = newFileInputStream(files[i]);
                zipOut.putNextEntry(newZipEntry(file.getName()
                        + File.separator +files[i].getName()));
               int temp = 0;
                while((temp = input.read()) !=-1){
                    zipOut.write(temp);
                }
                input.close();
           }
       }
       zipOut.close();
    }
}

【案例】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());
    }
}

【案例】解壓縮文件（壓縮文件中只有一個文件的狀況）

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類解壓縮一個壓縮文件中包含多個文件的狀況

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();
       }
    }
}

3.字節流的輸入與輸出的對應圖示

圖中藍色的爲主要的對應部分，紅色的部分就是不對應部分。紫色的虛線部分表明這些流通常要搭配使用。從上面的圖中能夠看出Java IO 中的字節流是極其對稱的。哲學上講「存在及合理」，如今咱們看看這些字節流中不太對稱的幾個類吧！

4.幾個特殊的輸入流類分析

LineNumberInputStream

主要完成從流中讀取數據時，會獲得相應的行號，至於何時分行、在哪裏分行是由改類主動肯定的，並非在原始中有這樣一個行號。在輸出部分沒有對應的部分，咱們徹底能夠本身創建一個LineNumberOutputStream，在最初寫入時會有一個基準的行號，之後每次遇到換行時會在下一行添加一個行號，看起來也是能夠的。好像更不入流了。

PushbackInputStream

其功能是查看最後一個字節，不滿意就放入緩衝區。主要用在編譯器的語法、詞法分析部分。輸出部分的BufferedOutputStream 幾乎實現相近的功能。

StringBufferInputStream

已經被Deprecated，自己就不該該出如今InputStream部分，主要由於String 應該屬於字符流的範圍。已經被廢棄了，固然輸出部分也沒有必要須要它了！還容許它存在只是爲了保持版本的向下兼容而已。

SequenceInputStream

能夠認爲是一個工具類，將兩個或者多個輸入流當成一個輸入流依次讀取。徹底能夠從IO 包中去除，還徹底不影響IO 包的結構，卻讓其更「純潔」――純潔的Decorator 模式。

【案例】將兩個文本文件合併爲另一個文本文件

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 voidmain(String[] args) throws IOException{
        File file1 = newFile("d:" + File.separator + "hello1.txt");
        File file2 = newFile("d:" + File.separator + "hello2.txt");
        File file3 = newFile("d:" + File.separator + "hello.txt");
        InputStream input1 =new FileInputStream(file1);
        InputStream input2 =new FileInputStream(file2);
        OutputStream output =new FileOutputStream(file3);
        // 合併流
        SequenceInputStreamsis = new SequenceInputStream(input1, input2);
        int temp = 0;
        while((temp =sis.read()) != -1){
           output.write(temp);
        }
        input1.close();
        input2.close();
        output.close();
        sis.close();
    }
}
 

PrintStream

也能夠認爲是一個輔助工具。主要能夠向其餘輸出流，或者FileInputStream 寫入數據，自己內部實現仍是帶緩衝的。本質上是對其它流的綜合運用的一個工具而已。同樣能夠踢出IO 包！System.err和System.out 就是PrintStream 的實例！

【案例】使用PrintStream進行輸出

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

【案例】使用PrintStream進行格式化輸出

/**
 * 使用PrintStream進行輸出
 * 並進行格式化
 * */
import java.io.*;
class hello {
   public static void main(String[] args) throws IOException {
       PrintStream print = new PrintStream(new FileOutputStream(newFile("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("這些內容在文件中才能看到哦！");
    }
}

【案例】使用System.err重定向

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("這些在文件中才能看到哦！");
    }
}

【案例】System.in重定向

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(newFileInputStream(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));
       }
    }
}

5.字符輸入流Reader

定義和說明：

在上面的繼承關係圖中能夠看出：

Reader 是全部的輸入字符流的父類，它是一個抽象類。

CharReader、StringReader是兩種基本的介質流，它們分別將Char 數組、String中讀取數據。PipedReader 是從與其它線程共用的管道中讀取數據。

BufferedReader 很明顯就是一個裝飾器，它和其子類負責裝飾其它Reader 對象。

FilterReader 是全部自定義具體裝飾流的父類，其子類PushbackReader 對Reader 對象進行裝飾，會增長一個行號。

InputStreamReader 是一個鏈接字節流和字符流的橋樑，它將字節流轉變爲字符流。FileReader能夠說是一個達到此功能、經常使用的工具類，在其源代碼中明顯使用了將FileInputStream 轉變爲Reader 的方法。咱們能夠從這個類中獲得必定的技巧。Reader 中各個類的用途和使用方法基本和InputStream 中的類使用一致。後面會有Reader 與InputStream 的對應關係。

實例操做演示：

【案例】從文件中讀取內容

/**
 * 字符流
 * 從文件中讀出內容
 * */
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));
    }
}

【案例】BufferedReader的小例子

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

BufferedReader buf = new BufferedReader(newInputStreamReader(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(
                newInputStreamReader(System.in));
       String str = null;
       System.out.println("請輸入內容");
       try{
           str = buf.readLine();
       }catch(IOException e){
           e.printStackTrace();
       }
       System.out.println("你輸入的內容是：" + str);
    }
}

【案例】Scanner類實例

import java.util.Scanner;
/**
 *Scanner的小例子，從鍵盤讀數據
 * */
public class ScannerDemo{
    publicstatic 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類從文件中讀出內容

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);
    }
}

6.字符輸出流Writer

定義和說明：

在上面的關係圖中能夠看出：

Writer 是全部的輸出字符流的父類，它是一個抽象類。

CharArrayWriter、StringWriter 是兩種基本的介質流，它們分別向Char 數組、String 中寫入數據。

PipedWriter 是向與其它線程共用的管道中寫入數據，

BufferedWriter 是一個裝飾器爲Writer 提供緩衝功能。

PrintWriter 和PrintStream 極其相似，功能和使用也很是類似。

OutputStreamWriter 是OutputStream 到Writer 轉換的橋樑，它的子類FileWriter 其實就是一個實現此功能的具體類（具體能夠研究一SourceCode）。功能和使用和OutputStream 極其相似，後面會有它們的對應圖。

實例操做演示：

【案例】向文件中寫入數據

/**
 * 字符流
 * 寫入數據
 * */
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的內容就會換行了。

7.字符流的輸入與輸出的對應

8.字符流與字節流轉換

轉換流的特色：

（1）其是字符流和字節流之間的橋樑

（2）可對讀取到的字節數據通過指定編碼轉換成字符

（3）可對讀取到的字符數據通過指定編碼轉換成字節

什麼時候使用轉換流？

當字節和字符之間有轉換動做時；

流操做的數據須要編碼或解碼時。

具體的對象體現：

InputStreamReader:字節到字符的橋樑

OutputStreamWriter:字符到字節的橋樑

這兩個流對象是字符體系中的成員，它們有轉換做用，自己又是字符流，因此在構造的時候須要傳入字節流對象進來。

字節流和字符流轉換實例：

【案例】將字節輸出流轉化爲字符輸出流

/**
 * 將字節輸出流轉化爲字符輸出流
 * */
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();
    }
}

9.File類

File類是對文件系統中文件以及文件夾進行封裝的對象，能夠經過對象的思想來操做文件和文件夾。 File類保存文件或目錄的各類元數據信息，包括文件名、文件長度、最後修改時間、是否可讀、獲取當前文件的路徑名，判斷指定文件是否存在、得到當前目錄中的文件列表，建立、刪除文件和目錄等方法。

【案例 】建立一個文件

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();
       }
    }
}

【案例2】File類的兩個常量

import java.io.*;
class hello{
   public static void main(String[] args) {
       System.out.println(File.separator);
       System.out.println(File.pathSeparator);
    }
}

此處多說幾句：有些同窗可能認爲，我直接在windows下使用\進行分割不行嗎？固然是能夠的。可是在linux下就不是\了。因此，要想使得咱們的代碼跨平臺，更加健壯，因此，你們都採用這兩個常量吧，其實也多寫不了幾行。

【案例3】File類中的常量改寫案例1的代碼：

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

【案例4】刪除一個文件（或者文件夾）

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("文件不存在");
       }
        
    }
}

【案例5】建立一個文件夾

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

【案例6】列出目錄下的全部文件

/**
 * 使用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]);
       }
    }
}

注意使用list返回的是String數組，。並且列出的不是完整路徑，若是想列出完整路徑的話，須要使用listFiles.它返回的是File的數組。

【案例7】列出指定目錄的所有文件（包括隱藏文件）：

/**
 * 使用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]);
       }
    }
}

【案例8】判斷一個指定的路徑是否爲目錄

/**
 * 使用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");
       }
    }
}

【案例9】遞歸搜索指定目錄的所有內容，包括文件和文件夾

* 列出指定目錄的所有內容
 * */
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

10.RandomAccessFile類

該對象並非流體系中的一員，其封裝了字節流，同時還封裝了一個緩衝區（字符數組），經過內部的指針來操做字符數組中的數據。該對象特色：

該對象只能操做文件，因此構造函數接收兩種類型的參數：a.字符串文件路徑；b.File對象。

該對象既能夠對文件進行讀操做，也能進行寫操做，在進行對象實例化時可指定操做模式(r,rw)

注意：該對象在實例化時，若是要操做的文件不存在，會自動建立；若是文件存在，寫數據未指定位置，會從頭開始寫，即覆蓋原有的內容。能夠用於多線程下載或多個線程同時寫數據到文件。

【案例】使用RandomAccessFile寫入文件

/**
 * 使用RandomAccessFile寫入文件
 * */
import java.io.*;
class hello{
    public static void main(String[]args) throws IOException {
        StringfileName="D:"+File.separator+"hello.txt";
        File f=new File(fileName);
        RandomAccessFile demo=newRandomAccessFile(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流的高級概念

編碼問題

【案例 】取得本地的默認編碼

/**
 * 取得本地的默認編碼
 * */
publicclass 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();
    }//輸出結果爲亂碼，系統默認編碼爲GBK，而此處編碼爲ISO8859-1
}

對象的序列化

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

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

【案例 】實現具備序列化能力的類

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

【案例 】序列化一個對象 – ObjectOutputStream

import java.io.Serializable;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
/**
 * 實現具備序列化能力的類
 * */
public class Person implements Serializable{
    public Person(){
     }
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString(){
        return "姓名：" +name + "  年齡：" +age;
    }
    private String name;
    private int age;
}
/**
 * 示範ObjectOutputStream
 * */
public class ObjectOutputStreamDemo{
    public static voidmain(String[] args) throws IOException{
        File file = newFile("d:" + File.separator + "hello.txt");
        ObjectOutputStream oos= new ObjectOutputStream(new FileOutputStream(
                file));
        oos.writeObject(newPerson("rollen", 20));
        oos.close();
    }
}

【案例 】反序列化—ObjectInputStream

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

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

當一個類要使用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 voidmain(String[] args) throws Exception{
        ser(); // 序列化
        dser(); // 反序列話
    }
 
    public static void ser()throws Exception{
        File file = newFile("d:" + File.separator + "hello.txt");
        ObjectOutputStream out= new ObjectOutputStream(new FileOutputStream(
                file));
        out.writeObject(newPerson("rollen", 20));
        out.close();
    }
 
    public static void dser()throws Exception{
        File file = newFile("d:" + File.separator + "hello.txt");
        ObjectInputStreaminput = 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 voidwriteExternal(ObjectOutput out) throws IOException{
       out.writeObject(this.name);
        out.writeInt(age);
    }
 
    // 複寫這個方法，根據須要讀取內容 反序列話的時候須要
    @Override
    public voidreadExternal(ObjectInput in) throws IOException,
           ClassNotFoundException{
        this.name = (String)in.readObject();
        this.age =in.readInt();
    }
 
    private String name;
    private int age;
}

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

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

【案例 】使用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 voidmain(String[] args) throws Exception{
        ser(); // 序列化
        dser(); // 反序列話
    }
 
    public static void ser()throws Exception{
        File file = newFile("d:" + File.separator + "hello.txt");
        ObjectOutputStream out= new ObjectOutputStream(new FileOutputStream(
                file));
        out.writeObject(newPerson1("rollen", 20));
        out.close();
    }
 
    public static void dser()throws Exception{
        File file = newFile("d:" + File.separator + "hello.txt");
        ObjectInputStreaminput = new ObjectInputStream(new FileInputStream(
                file));
        Object obj =input.readObject();
        input.close();
       System.out.println(obj);
    }
}
 
class Person1 implements Serializable{
    public Person1(){
 
    }
 
    public Person1(Stringname, int age){
        this.name = name;
        this.age = age;
    }
 
    @Override
    public String toString(){
        return "姓名：" +name + "  年齡：" +age;
    }
 
    // 注意這裏
    private transient Stringname;
    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 voidmain(String[] args) throws Exception{
        Student[] stu = { newStudent("hello", 20), new Student("world", 30),
                newStudent("rollen", 40) };
        ser(stu);
        Object[] obj = dser();
        for(int i = 0; i

參考文獻：

一、http://www.cnblogs.com/rollenholt/archive/2011/09/11/2173787.html

二、http://www.cnblogs.com/oubo/archive/2012/01/06/2394638.html

三、轉載自紅黑聯盟