Java 的 IO 流

時間 2019-12-09

標籤 java 欄目 Java 简体版

原文原文鏈接

　　接着上一篇的「Java 的 File 類」的隨筆，在File類的基礎上，咱們就走進Java的IO流吧。java

流的概念和做用

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

流的分類：

　　（1）、按照數據流向的不一樣分爲：輸入流（從磁盤、網絡等讀取到內存，只能讀，不能寫）、輸出流（從內存寫出到磁盤、網絡，只能寫，不能讀）網絡

　　（2）、按照處理數據的單位不一樣分爲：字節流（以字節爲基本操做單位）、字符流（以字符爲基本操做單位）學習

　　（3）、按照角色的不一樣分爲：節點流（向某個IO設備/節點（磁盤文件、網絡等）直接讀寫數據，也稱爲低級流）、處理流（用於包裝一個已存在的流，經過這個已存在的流來進行讀寫操做，並不直接操做IO節點，也稱爲高級流、包裝流）spa

Java流類結構：

分類code	字節輸入流視頻	字節輸出流對象	字符輸入流blog	字符輸出流圖片
抽象基類	InputStream	OutputStream	Reader	Writer
操做文件	FileInputStream	FileOutputStream	FileReader	FileWriter
操做數組	ByteArrayInputStream	ByteArrayOutputStream	CharArrayReader	CharArrayWriter
操做字符串			StringReader	StringWriter
緩衝流	BufferedInputStream	BufferedOutputStream	BufferedReader	BufferedWriter
轉換流			InputStreamReader	OutputStreamWriter
對象流（用於序列化）	ObjectInputStream	ObjectOutputStream
抽象基類（用於過濾）	FilterInputStream	FilterOutputStream	FilterReader	FilterWriter
打印流（輸出功能極其大）		PrintStream		PrintWriter

java的IO流的用法

InputStream是字節輸入流的頂級父類，經常使用方法：

int read() //讀取一個字節，返回該字節數據的Unicode碼值
int read(byte[] buff) //最多讀取buff.length個字節，將讀取的數據放在buff數組中，返回實際讀取的字節數
int read(byte[] buff, int off, int length) //最多讀取length個字節，放在buff數組中，從數組的off位置開始放置數據，返回實際讀取的字節數。off通常設置爲0，length通常設置爲buff的長度。

        //一、建立一個File類的對象
        File file = new File("hello.txt");
        //二、建立一個FileInputStream類的對象
        FileInputStream fis = new FileInputStream(file);
        //三、調用FileInputStream的方法，實現file文件的讀取
        int b = fis.read();
        while(b != -1){
            System.out.print((char)b+" ");
            b = fis.read();
        }
        fis.close();

OutputStream是字節輸出流的頂級父類，經常使用方法：

void write(int i) \\輸出一個字節，i是碼值，即read()獲得的碼值，輸出i對應的字節
void write(byte[] buff) //輸出整個字節數組的內容
void write(byte[] buff, int off, int length) //把字節數組從off位置開始，輸出長度爲length字節的內容

        File file = new File("hello1.txt");
        FileOutputStream fos = null;
        try{
            fos = new FileOutputStream(file);
            fos.write(new String("\nI Love CYT!").getBytes());
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            if(fos != null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

Reader時字符輸入流的頂級父類，經常使用方法：

int read() //讀取一個字符，返回該字符的Unicode碼值，注意並非返回該字符。
int read(char[] buff) //最多讀取buff.length個字符，放在buff數組中，返回實際讀取的字符數

int read(char[] buff, int off, int length） //最多讀取length個字節，放在buff數組中，從數組的off位置開始放置數據，返回實際讀取的字符數。off通常設置爲0，length通常設置爲buff的長度

        File file = new File("1.txt");
        FileReader fr = null;
        try{
            fr = new FileReader(file);
            char[] c = new char[24];
            int len;
            while((len = fr.read(c)) != -1){
                for(int i=0;i<len;i++){
                    System.out.print(c[i]);
                }
            }
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            if(fr != null){
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

Writer是字符輸出流的頂級父類，經常使用方法：

void write(int i) //輸出一個字符，i是碼值，輸出的是i對應的字符
void write(char[] buff) //輸出整個char[]的內容
void write(char[] buff, int off, int length) //把char[]從off位置開始，輸出長度爲length字符的內容

能夠用String代替char[]，因此Writer還具備如下2個方法：

void write(String str)
void write(String str, int off, int length)

        FileWriter fw = null;
        try{
            fw = new FileWriter(new File("1.txt"));
            String str = "我喜歡Java,我要成爲Java工程師。";
            fw.write(str);
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            if(fw != null){
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

緩衝流是和4級頂級父類對應的：加前綴Buffered

　　InputStream BufferedInputStream 字節輸入緩衝流，可做爲全部字節輸入流類的緩衝流

　　OutputStream BufferedOutputStream 字節輸出緩衝流

　　Reader BufferedReader 字符輸入緩衝流

　　Writer　　BufferedWriter 字符輸出緩衝流

//用 BufferedReader 把文件讀進來， 再用 BufferedWriter 把內容寫出去
        File file = new File("hello.txt");
        File file1 = new File("hello3.txt");
        FileReader fr = null;
        BufferedReader br = null;
        FileWriter fw = null;
        BufferedWriter bw = null;
        try{
            fr = new FileReader(file);
            fw = new FileWriter(file1);
            br = new BufferedReader(fr);
            bw = new BufferedWriter(fw);
            String str;
            while((str = br.readLine()) != null){
//                System.out.println(str);
                bw.write(str);
                bw.newLine();
                bw.flush();
            }
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            if(bw != null){
                try {
                    bw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(br != null){
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

其餘方法我就不一一說明了。有興趣的同窗能夠本身再深刻研究。

最後我就提供文件複製的通用方法吧。本身寫的通用類。讓本身更好的去了解Java的IO流的使用。

package io;
/*
 * 實現文件的複製
 */
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class CopyFile {

    // 字節文件的複製方法
    public static void copyFileByte(String src, String dest) {
        // 一、提供讀入、寫出的文件
        File file1 = new File(src);
        File file2 = new File(dest);
        // 二、提供相應的流
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream(file1);
            fos = new FileOutputStream(file2);
            // 三、實現文件的複製
            byte[] b = new byte[20];
            int len;
            while ((len = fis.read(b)) != -1) {
                fos.write(b, 0, len);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /*
     * 使用FileReader 、 FileWriter 能夠實現文本文件的複製
     * 對於非文本文件(視頻文件、音頻文件、圖片)，只能使用字節流複製。
     */
    public static void copyFileChar(String src, String dest) {
        // 一、提供讀入、寫出的文件
        File file1 = new File(src);
        File file2 = new File(dest);
        // 二、提供相應的流
        FileReader fr = null;
        FileWriter fw = null;
        try {
            fr = new FileReader(file1);
            fw = new FileWriter(file2);
            // 三、實現文件的複製
            char[] c = new char[24];
            int len;
            while ((len = fr.read(c)) != -1) {
                fw.write(c, 0, len);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (fw != null) {
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fr != null) {
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    
    //使用BufferedInputStream和BufferedOutputStream實現非文本文件的複製
    public static void copyFileBuffered1(String src, String dest) {
        //一、提供讀入、寫出的文件
        File file1 = new File(src);
        File file2 = new File(dest);
        //二、先建立相應的節點流:FileInputStream、 FileOutputStream
        FileInputStream fis = null;
        FileOutputStream fos = null;
        //三、再建立緩衝流:BufferedInputStream 、 BufferedOutputStream
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            fis = new FileInputStream(file1);
            fos = new FileOutputStream(file2);
            bis = new BufferedInputStream(fis);
            bos = new BufferedOutputStream(fos);
            //四、具體實現文件複製的操做
            byte[] b = new byte[1024];
            int len;
            while((len = bis.read(b)) != -1){
                bos.write(b, 0, len);
                bos.flush();
            }
        }catch (Exception e) {
            e.printStackTrace();
        } finally {
            if(bos != null){
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }if(bis != null){
                try {
                    bis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

如今本身也準備大四了，因此本身要捉緊時間去學習，博客裏面有什麼問題的能夠跟我說一下，你們一塊兒交流一下學習的經驗。

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。