JAVA中IO流詳解

IO流：數據傳輸是需要通道的，而IO流就是數據傳輸的通道。

　　　　IO流可以形象的比喻為運送貨物的傳輸帶。

IO流的分類：

　　①根據操作的數據類型的不同可以分為 ：字節流與字符流。

　　②根據數據的流向分為：輸入流與輸出流，程序（內存）作為參照物，程序從外部讀取稱為輸入（Input），程序向外部寫數據成為輸出（Output）。

字節輸入流：

    父類：InputStream

　常用的字節輸入流：FileInputStream

1.FileInputStream

   ①構造方法：

　　FileInputStream（File）

　　FileInputStream（String  filename）

2.常用方法　

　　①read　：讀取一個字節，返回該字節的值，如果到達文件的末尾，則返回-1。需要注意：read()方法和迭代器一樣，會自動下移的

　　②read（byte[ ]）從輸入流中讀取至多一個數組長度的內容，到達文件末尾，則返回-1。　　　　

• 數組稱為緩沖區數組，大小一般取值為1024的整數倍。
• 轉換為字符時，使用String（byte [ ]   bytes，int offset，int length）
• available（）沒有讀取的剩余字節數，如果該文件還從未被讀取，就返回該文件的長度。
• close（） 關閉流並釋放資源

字節輸入流代碼演示：

其中1.txt位於本項目的根目錄下：內容為"abcdefg"

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class Demo6 {

    public static void main(String[] args) throws IOException{
        File file=new File("1.txt");     //新建一個文件的抽象路徑
        FileInputStream fis=new FileInputStream(file);  
        int result=fis.read();
        System.out.println(result);

    }

}

 程序執行的結果為97，因為讀取的a的ASCII碼值

 字節輸入流的循環讀取：

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class Demo7 {

    public static void main(String[] args) throws IOException{
        File file =new File("1.txt");
        FileInputStream fis=new FileInputStream(file);
        int result;
        while((result=fis.read())!=-1) {
            System.out.print(result+"\t");
        }
        

    }

}

 

 打印了a到g的ASCII碼值

 

字符流的讀取方法：

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class Demo8 {

    public static void main(String[] args) throws IOException{
        File file =new File("1.txt");
        FileInputStream fis=new FileInputStream(file);
        byte[] bt=new byte[1024];
        int count;
        while((count=fis.read(bt))!=-1) {
            String string =new String(bt,0,count);
            System.out.println(string);
        }
    }
}

 

輸出結果

 

下面可以用同樣的文件來比較字節輸入流和字符輸入流的讀取速度：

文件是一張格式為png圖片

先是字節輸入流的讀取速度

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class Demo9 {

    public static void main(String[] args) throws IOException{
        File file =new File("D:\\Java代碼\\123.png");
        FileInputStream fis=new FileInputStream(file);
        int count;
        long start=System.currentTimeMillis();
        while((count=fis.read())!=-1) {
            System.out.println(count);
        }
        long end=System.currentTimeMillis();
        System.out.println("======下面是所用的時間======");
        System.out.println(end-start);
    }

}

 

結果如下：

下面是字符輸入流：

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class Demo10 {

    public static void main(String[] args) throws IOException {
        File file=new File("D:\\Java代碼\\123.png");
        FileInputStream fis=new FileInputStream(file);
        byte[] bt=new byte[1024];
        int count;
        long start=System.currentTimeMillis();
        while((count=fis.read(bt))!=-1) {
            System.out.println(count);
        }
        long end=System.currentTimeMillis();
        System.out.println("======下面是所用的時間======");
        System.out.println(end-start);
    }
}

 

結果如下：

 

字節輸入流讀取文件花費了760毫秒，而字符輸入流讀取文件花費了3毫秒，由此可見，字符輸入流的速度要比字節輸入流更快。

 

文件字節輸出流：

字節輸出流：OutputStream  是所有輸出流的超類

常用子類：FileOutputStream  文件字節輸出流

構造方法：

　　  FileOutputStream（File file） /FileOutputStream（String name）

　　注意：如果父目錄不存在，會報FileNotFoundException異常，如果父目錄存在，會創建一個新的文件，如果此時已經有文件存在，會覆蓋原文件

　　 FileOutputStream(File file,boolean flag)/FileOutputStream(String name,boolean flag)

　　注意:如果當前文件需要從文件末尾進行插入（接着文件里的內容繼續寫），必須將第二個參數設置為true，默認不寫為false，會覆蓋原文件

常用方法：

　　write（int）向文件中寫入一個字節的值

　　write(byte[]) 向文件中寫入一個數組的數據。

　　***③ write(byte[] offset len) 將 偏移量為 offset 的索引位置的長度為 len 的數據，寫入到輸出流中。

代碼示例：

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

public class Demo11 {

    public static void main(String[] args) throws IOException {
        File file=new File("3.txt");
        FileOutputStream fos=new FileOutputStream(file);
        
        fos.write("沒有絕對的絕緣體，只有不努力的電壓。".getBytes());                
    }
}

 

執行結果，會在本項目的根目錄下生成一個3.txt 文件，並且將內容寫入進去。

 

文件復制：將一個文件通過IO流復制到另一個文件中去

代碼示例：

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Demo12 {

    public static void main(String[] args) throws IOException {
        File file=new File("1.txt");
        FileInputStream fis=new FileInputStream(file);
        FileOutputStream fos=new FileOutputStream(new File("4.txt"));
        byte[] bt=new byte[1024];
        int count;
        while((count=fis.read(bt))!=-1) {
            fos.write(bt,0,count);
        }
        fis.close();
        fos.close();
    }
}

 

結果會將1.txt的內容復制到4.txt中

 

帶緩沖區的字節流
1. 通過比較 read() 與 read(byte[]) 的方法復制文件的時間的長短，可以看出，帶緩沖區的讀寫文件的速度快，
java 上提供了專門帶緩沖區的字節流，用以提高讀寫速度。
2.BufferedInputStream /BufferedOutputStream 帶緩沖區的字節輸入 / 輸出流
3. 結論： 帶緩沖區的字節流 讀取速度高於字節流
代碼演示：

public class  帶緩沖區的字節流 {
public static void main(String[] args) throws IOException {
/*FileInputStream fis=new FileInputStream(new File("src\\com\\ 文件復制 .java"));
// 復制操作 ：
BufferedInputStream bis=new BufferedInputStream(fis);*/
// // 讀取
// BufferedInputStream bis=new BufferedInputStream(new FileInputStream(new File("src\\com\\ 文
件復制 .java")));
// // 寫入
// BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream(new File("1.java"))
);
// 讀取
BufferedInputStream bis=new BufferedInputStream(new FileInputStream(new File("D:\\0318java 班
\\day08\\ 錄屏 \\1_day08IO 流概述 .mp4")));
// 寫入
BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream(new File("C:\\Users\\
Administrator\\Desktop\\2.mp4")));
byte[] bt=new byte[1024];
int count=0;
long start=System.currentTimeMillis();
while((count=bis.read(bt))!=-1) {
bos.write(bt, 0, count);
}
long end=System.currentTimeMillis();
System.out.println(end-start);
bis.close();
bos.close();
}
}

 

jdk1.6 流的異常處理
1. 異常處理方式：
① try-catch-finally 異常的捕獲
② throws 異常的聲明
2. 以文件復制的形式來寫流的異常處理 :
在 1.7jdk 之前包括 1.6 不包含 1.7 的流的異常處理形式。
代碼演示：

public class  字節流的異常處理方式 {
public static void main(String[] args) {
// 為了在 finally 里面能夠使用關閉資源，提升作用域
FileInputStream fis=null;
FileOutputStream fos=null;
try {
// 輸入流
fis=new FileInputStream(new File("src\\com\\ 帶緩沖區的字節流 .java"));
// 輸出流
fos=new FileOutputStream(new File("2.java"));
// 文件復制
byte[] bt=new byte[1024];
int count=0;
while((count=fis.read(bt))!=-1) {
fos.write(bt,0,count);
}
}catch(Exception e) {
e.printStackTrace();
}finally {
close(fis, fos);
}
}
public static void close(InputStream fis,OutputStream fos) {
// 關閉資源
try {
// 為了防止空指針，需要判斷不為 null 再關閉
if (fis!=null) {
fis.close();
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
// 為了防止空指針，需要判斷不為 null 再關閉
if (fos!=null) {
fos.close();
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

Jdk1_7 流的異常處理形式

public class Jdk1_7 流的異常處理形式 {
public static void main(String[] args) {
try(
FileInputStream fis=new FileInputStream(new File("src\\com\\ 帶緩沖區的字節流 .java"));
FileOutputStream fos=new FileOutputStream(new File("3.java"));
){
/*Scanner sc=new Scanner(System.in);
sc.close();*/
byte[] bt=new byte[1024];
int count=0;
while((count=fis.read(bt))!=-1) {
fos.write(bt,0,count);
}
}catch (Exception e) {
e.printStackTrace();
}
Scanner sc1=new Scanner(System.in);
String name = sc1.nextLine();
}
}