Java入門系列-22-IO流

極客大全發表於2018-11-09
Java

File類的使用

Java程式如何訪問檔案？通過 java.io.File 類

使用File類需要先建立檔案物件 File file=new File(String pathname);，建立時在建構函式中指定物理檔案或目錄，然後通過檔案物件的方法操作檔案或目錄的屬性。

是特殊字元，要使用需要轉義 \

File 類常用方法

方法名稱 說明
boolean exists() 判斷檔案或目錄是否存在
boolean isFile() 判斷是否是檔案
boolean isDirectory() 判斷是否是目錄
String getPath() 返回此物件表示的檔案的相對路徑名
String getAbsolutePath() 返回此物件表示的檔案的絕對路徑
String getName() 返回此物件指定的檔案或目錄
boolean createNewFile() 建立名稱的空檔案，不建立資料夾
long length() 返回檔案的長度，單位為位元組，檔案不存在則返回0L
File[] listFiles() 返回一個抽象路徑名陣列，這些路徑名錶示此抽象路徑名錶示的目錄中的檔案。
static File[] listRoots() 列出可用檔案系統根
boolean mkdirs() 建立此抽象路徑名指定的目錄，包括所有必需但不存在的父目錄。

使用示例：

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

public class TestFile {

    public static void main(String[] args) {
        //建立File物件 傳入檔案的路徑
        File file=new File("D:\a.txt");
        //建立File物件 傳入資料夾的路徑
        File dir=new File("D:/word");
        //判斷是否存在
        if(file.exists()) {
            if(file.isFile()) {
                //getName()獲取名字
                System.out.println(file.getName()+" 是檔案");
            }else if(file.isDirectory()){
                System.out.println(file.getName()+" 是目錄");
            }            
        }else {
            System.out.println(file.getName()+" 不存在！");
            try {
                //建立檔案
                file.createNewFile();
                System.out.println("檔案大小："+file.length()+" 位元組");
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        
        if(dir.exists()) {
            if(dir.isFile()) {
                System.out.println(dir.getName()+" 是檔案");
            }else if(dir.isDirectory()) {
                System.out.println(dir.getName()+" 是資料夾");
                //絕對路徑
                System.out.println(dir.getAbsolutePath());
            }            
        }else {
            System.out.println(dir.getName()+" 不存在！");
            //建立目錄
            dir.mkdirs();
        }
        
    }
}

流

流：指一連串流動的字元，是以先進先出方式傳送資訊的通道

輸入流：源資料流向程式(讀)

輸入流：程式中的資料流向目標資料來源(寫)

Java流的分類

按流向

  • 輸出流(OutputStream和Writer作為基類)
  • 輸入流(InputStream和Reader作為基類)

輸入輸出流是相對於計算機記憶體來說的

按照處理資料單元劃分

  • 位元組流

    • 位元組輸入流(InputStream基類)
    • 位元組輸出流(OutputStream基類)

  • 字元流

    • 字元輸入流(Reader基類)
    • 字元輸出流(Writer基類)

位元組流是8位(1B)通用位元組流，字元流是16位(2B)Unicode字元流

位元組流

FileInputStream 是 InputStream 的子類

InputStream 類常用方法

方法名稱 說明
int read() 從輸入流中讀取資料的下一個位元組。返回0到255的int值，如果到達流的末尾，則返回-1
int read(byte[] b) 從輸入流中讀取一定數量的位元組，並將其儲存在緩衝區陣列 b 中。返回讀入緩衝區的總位元組數，如果達到末尾則返回-1
int read(byte[] b,int off,int len) 將輸入流中最多 len 個資料位元組讀入 byte陣列
void close() 關閉此輸入流並釋放與該流關聯的所有系統資源
int available() 返回此輸入流下一個方法呼叫可以不受阻塞地從此輸入流讀取的估計位元組數

FileInputStream 類常用構造方法

名稱 說明
FileInputStream(File file) 通過開啟一個到實際檔案的連線來建立一個 FileInputStream，該檔案通過檔案系統中的 File 物件 file 指定。
FileInputStream(String name) 通過開啟一個到實際檔案的連線來建立一個 FileInputStream，該檔案通過檔案系統中的路徑名 name 指定。

使用 FileInputStream 讀取檔案

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class TestFileInputStream {

    public static void main(String[] args) {
        FileInputStream fis=null;
        try {
            fis=new FileInputStream("D:\a.txt");
            //讀取結果存入StringBuffer
            StringBuffer sb=new StringBuffer();
            System.out.println("預計讀取："+fis.available()+"位元組");
            //記錄每次讀取的長度
            int len=0;
            //緩衝區位元組陣列
            byte[] buff=new byte[1024];
            while((len=fis.read(buff))!=-1) {
                System.out.println("還剩餘："+fis.available()+"位元組");
                sb.append(new String(buff,0,len));
            }
            System.out.println("結果：");
            System.out.println(sb);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (fis!=null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

FileOutputStream 是 OutputStream 的子類

OutputStream 類常用方法

方法名稱 說明
void write(int c) 將制定的位元組寫入此輸出流
void write(byte[] buf) 將 b.length 個位元組從指定的 byte 陣列寫入此輸入流
void write(byte[] b,int off,int len) 將指定 byte 陣列中從偏移量 off 開始的 len 個位元組寫入此輸出流
void close() 關閉此輸出流並釋放與此流有關的所有系統資源

FileOutputStream的構造方法

名稱 說明
FileOutputStream(File file) 建立一個向指定 File 物件表示的檔案中寫入資料的檔案輸出流
FileOutputStream(String name) 建立一個向具有指定名稱的檔案中寫入資料的輸出檔案流
FileOutputStream(String name,boolean append) 第二個引數為 true，則將位元組寫入檔案末尾處，而不是寫入檔案開始處

使用 FileOutputStream 寫檔案

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class TestFileOutputStream {

    public static void main(String[] args) {
        FileOutputStream fos=null;
        try {
            //建立輸出流物件
            fos=new FileOutputStream("D:\c.txt");
            //要輸出的字元
            String str="hello world 你好";
            //將字串轉成位元組陣列並寫入到流中
            fos.write(str.getBytes());
            //重新整理流
            fos.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (fos!=null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

字元流

上面的內容我們看到，位元組流不能直接操作字元，所以操作字元用字元流。

FileReader 是 Reader 的子類

Reader 類常用方法

方法名稱 說明
int read() 讀取單個字元
int read(char[] c) 將字元讀入陣列
read(char[] c,int off,int len) 將字元讀入陣列的某一部分
void close() 關閉該流並釋放與之關聯的所有資源

使用 FileReader 讀取文字檔案

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

public class TestReader {

    public static void main(String[] args) {
        Reader r=null;
        try {
            //建立FileReader物件
            r=new FileReader("D:\a.txt");
            //字元緩衝陣列
            char[] chrs=new char[512];
            //記錄每次讀取的個數
            int len=0;
            //迴圈讀取
            while((len=r.read(chrs))!=-1) {
                String str=new String(chrs, 0, len);
                System.out.println(str);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (r!=null) {
                try {
                    r.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

FileWriter 是 Writer 的子類

Writer 類常用方法

方法名稱 說明
write(String str) 寫入字串
write(String str,int off,int len) 寫入字串的某一部分
void close() 關閉此流，但要先重新整理它
void flush 重新整理該流的緩衝

使用 FileWriter 寫入文字檔案

import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

public class TestWriter {

    public static void main(String[] args) {
        Writer w=null;
        try {
            //建立字元輸出流
            w=new FileWriter("D:\msg.txt");
            String msg="hello every bady 兄嘚";
            //將字串寫入到流中
            w.write(msg);
            w.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (w!=null) {
                try {
                    w.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

緩衝字元流

如果頻繁的對字元進行讀寫操作，牆裂建議使用緩衝！

BufferedReader 類帶有緩衝區，可以先把一批資料讀到緩衝區，接下來的讀操作都是從緩衝區內獲取資料，避免每次都從資料來源讀取資料進行字元編碼轉換，從而提高讀取操作的效率。

使用BufferedReader讀取文字檔案

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class TestBufferedReader {

    public static void main(String[] args) {
        FileReader reader=null;
        BufferedReader br=null;
        try {
            //建立字元讀入流
            reader=new FileReader("D:\a.txt");
            //將字元讀入流包裝成字元緩衝流
            br=new BufferedReader(reader);
            //記錄每行讀入的內容
            String line=null;
            //用於拼接儲存每行讀入的內容
            StringBuffer content=new StringBuffer();
            while ((line=br.readLine())!=null) {
                content.append(line+"
");
            }
            System.out.println("所有內容：");
            System.out.println(content);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if (reader!=null) {
                    reader.close();
                }
                if (br!=null) {
                    br.close();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

BufferedReader 是 Reader 的子類，帶有緩衝區，特有方法 readLine() 按行讀取內容

BufferedWriter 類帶有緩衝區，與BufferedReader的方向正好相反，BufferedWriter 是把一批資料寫到緩衝區，當緩衝區滿的時候，再把緩衝區的資料寫到字元輸出流中。避免每次都執行物理寫操作，提高寫操作的效率。

使用 BufferedWriter 寫檔案

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

public class TestBufferedWriter {

    public static void main(String[] args) {
        FileWriter writer=null;
        BufferedWriter bw=null;
        try {
            writer=new FileWriter("D:\out.txt");
            bw=new BufferedWriter(writer);
            bw.write("hello");
            //內容換行
            bw.newLine();
            bw.write("world");
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if (bw!=null) {
                    bw.close();
                }
                if (writer!=null) {
                    writer.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

關閉流的順序與建立流的順序相反

資料流

DataInputStream 類

  • FileInputStream 的子類
  • 與 FileInputStream 類結合使用讀取二進位制檔案

DataOutputStream 類

  • FileOutputStream 的子類
  • 與 FileOutputStream 類結合使用寫二進位制檔案

使用資料流複製圖片

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class TestCopy {

    public static void main(String[] args) {
        //檔案輸入流
        FileInputStream fis=null;
        //資料輸入流(包裝fis得到)
        DataInputStream dis=null;
        //檔案輸出流
        FileOutputStream fos=null;
        //資料輸出流(包裝fos得到)
        DataOutputStream dos=null;
        
        try {
            fis=new FileInputStream("D:\a.jpg");
            dis=new DataInputStream(fis);
            fos=new FileOutputStream("F:\b.jpg");
            dos=new DataOutputStream(fos);
            //緩衝陣列
            byte[] buff=new byte[1024];
            //記錄每次讀取的位元組個數
            int len=0;
            //迴圈讀入
            while((len=dis.read(buff))!=-1) {
                //迴圈寫入len個位元組
                dos.write(buff,0,len);
            }
            System.out.println("完成");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if (dis!=null) {
                    dis.close();
                }
                if (dos!=null) {
                    dos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}


相關文章