Java入門系列-22-IO流

時間 2019-12-08

標籤 java 入門系列欄目 Java 简体版

原文原文鏈接

File類的使用

Java程序如何訪問文件？經過 java.io.File 類java

使用File類須要先建立文件對象 File file=new File(String pathname);，建立時在構造函數中指定物理文件或目錄，而後經過文件對象的方法操做文件或目錄的屬性。數組

\ 是特殊字符，要使用須要轉義 \\app

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

流

流：指一連串流動的字符，是以先進先出方式發送信息的通道code

輸入流：源數據流向程序(讀)對象

輸入流：程序中的數據流向目標數據源(寫)圖片

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+"\n");
            }
            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();
            }
        }
    }
}