JAVA中的I/O流以及文件操作

一 JAVA語言中主要通過流來完成IO操作。

流：計算機的輸入輸出之間流動的數據序列，也是類的對象。java中的流方式就像是建立在數據交換源和目的之間的一條通信路徑。

數據源：計算機中的數據源是指可以提供數據的地方，包括鍵盤，磁盤文件，網絡接口等。

輸入流：從程序外部傳向程序的流。輸入流只能從中讀數據。

輸出流: 從程序傳到外部的流。輸出流只能向其寫入數據。

所謂的輸入和輸出是以程序為中心的，數據流向程序即輸入流，數據從程序中流出即輸出流。

二 字節流

字節流是以字節為傳輸單位的數據讀寫形式，用於直接讀取二進制數據，如圖像和聲音文件等。

InputStream和OutputStream分別為面向字節的輸入流類的父類和輸出流類的父類。InputStream和OutputStream都是抽象類。

FileInputStream和FileOutputStream是文件流類，他們是InputStream和OutputStream的子類。

FileInputStream類的一般用法是：先創建一個FileInputStream對象關聯到要讀取的文件，然后調用read方法讀取字節數據到程序中，再進行其他處理。因為read方法是按字節的讀入的，所以漢字被讀入時會出現亂碼。

FileOutputStream類的一般用法是：先創建一個FileOutputStream對象關聯到要寫入的文件，然后調用write方法將字節數據寫到程序中。如果進行寫操作的文件不存在，則自動創建該文件，但是如果文件所在的路徑也不存在，則運行時會報錯。

例如 FileOutputStream fos = new FileOutputStream("D:\\test.txt");是不會報錯的，

      FileOutputStream fos = new FileOutputStream("D:\\tmp\\test.txt");如果之前在D盤中沒有tmp這個文件夾，那么此時運行這條語句會報錯。

 

代碼如下

package 文件操作_FileInputStream和FileOutputStream;

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

public class FileDemo {
    public static void main(String[] args) {
        try {
            FileInputStream fis = new FileInputStream("D:\\test.txt");
            int  ch = fis.read();
            while (ch != -1) {
                System.out.print((char) ch);
                ch = fis.read();
            }
//            byte[] buffer = new byte[8];
//            fis.read(buffer);
//            for (int i = 0; i < buffer.length; i++) {
//                System.out.print((char) buffer[i]);
//            }
            FileOutputStream fos = new FileOutputStream("D:\\test1.txt");
            byte[] b = {'a', 'c', 'd', 'e', 'x'};
            fos.write(b);
            fis.close();
            fos.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    

}

 

緩存流 BufferedInputStream 和 BufferedOutputStream

使用緩存流可以提高大文件的讀寫效率。例如從文件讀入數據時，每次從輸入流中讀取較大的數據量存入內存緩沖區，具體的讀操作針對該緩沖區進行；執行緩沖輸出時，每次將輸出流中的數據寫入到內存緩沖區，知道緩沖區寫滿，才將數據寫入到最終的介質中。

使用緩存流的缺點：當計算機突然關閉時，可能會丟失數據。通過清空緩沖區的數據可以減少這種情況的發生，使用flush()方法即可。

代碼如下

package 文件操作_BufferedInputStream;

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

public class BufferDemo {
    public static void main(String[] args) {
        try {
            FileInputStream fis = new FileInputStream("D:\\test.txt");
            BufferedInputStream bis = new BufferedInputStream(fis); //默認的輸入緩沖區是2048B
            int ch = bis.read();
            while (ch != -1) {
                System.out.print((char)ch);
                ch = bis.read();
            }
                    
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

 

三 字符流

Reader 和 Writer類是所有字符流的父類。一次讀取或是寫入兩個字節，16位，即一個Unicode字符，因此可以使用字符流直接讀寫漢字內容。

BufferedReader 和 BufferedWriter類的用法示例

package 文件操作_字符流_BufferedReader和BufferedWriter;

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

public class BufferedDemo {
    public static void main(String[] args) {
        try {
            FileReader fr = new FileReader("D:\\test.txt");
            BufferedReader br = new BufferedReader(fr);
            FileWriter fw = new FileWriter("D:\\test1.txt");
            BufferedWriter bw = new BufferedWriter(fw);
            String str = br.readLine();
            while (str != null) {
                bw.write(str);
                bw.newLine();
                str = br.readLine();
            }
            br.close();
            bw.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

 

四 File文件類

File aa = new File(aaName); 這里的aa可以指向文件，也可以指向文件夾

在進行文件的操作時，若操作的對象是文件，那么在進行文件的創建，刪除，復制之前，

（1）需要判斷文件是否存在，
（2）以及File所指向的對象是一個文件還是一個文件夾(目錄)
（3）該文件所在的文件夾是否存在，file.getParentFile().exists()
 (4)若文件所在的文件夾不存在，需要建立其父文件夾，若未建立成功，返回false
       if (!file.getParentFile().mkdirs()) return false;

在對文件夾(目錄)進行操作時，

（1）首先判斷 dirName 是不是以文件分隔符 File.separator結尾，如果不是，

     則 dirName += File.separator;

(2)需要判斷 File dir = new File(dirName) 中的dir是不是存在以及指向的是不是一個文件夾 dir.exists() dir.isDirctory();
(3) 在對文件夾進行復制，刪除等操作時，一般會用到遞歸，因為文件夾里面有時候會存在子文件夾。

 

程序示例1 刪除指定目錄下的文件

package 輸入輸出流_刪除指定目錄下的文件;

import java.io.File;

//delete()方法可以刪除文件和文件夾，當成功刪除文件或文件夾后，返回true  否則返回false
//在使用delete()方法時，如果此路徑名表示一個文件夾（目錄），則此目錄必須為空才能刪除
//(若要刪除文件夾，需要先刪除文件夾中的文件和文件夾，才能刪除該文件夾)
public class FileDemo_05 {
    
    public static boolean deleteFilesOrDir (String fileName) {//判斷將指定文件或文件夾刪除是否成功
        File file = new File(fileName);
        if (!file.exists()) {   //指定的文件或文件夾不存在，返回false
            System.out.println("文件刪除失敗，因為文件" + fileName + "不存在");
            return false;
        } else {  //指定的文件或是文件夾存在
            if (file.isFile()) {   //若file 是文件
                return FileDemo_05.deleteFiles(fileName);
            } else {              //若file是文件夾
                return FileDemo_05.deleteDir(fileName);
            }
        }
        
    }
    
    public static boolean deleteFiles(String fileName) { //判斷刪除指定文件是否成功
        File file = new File(fileName);
        if ( file.exists() && file.isFile() ) {
            if (file.delete()) {
                System.out.println("文件" + fileName + "刪除成功！");
                return true;
            } else {
                System.out.println("文件" + fileName + "刪除失敗！");
                return false;
            }
        } else {
            System.out.println("文件刪除失敗 ： " + fileName + "文件不存在！");
            return false;
        }
        
    }
    
    public static boolean deleteDir(String dir) { //判斷刪除指定文件夾以及文件夾下的文件是否成功
         if (!dir.endsWith(File.separator)) {
             dir += File.separator;
         }
         File dirFile = new File(dir);
         if (!dirFile.exists() || !dirFile.isDirectory()) {
             System.out.println("文件夾刪除失敗！" + dir + "文件夾不存在");
             return false;
         }
         boolean flag = true;
         File[] files = dirFile.listFiles();
         for (int i = 0; i < files.length; i++) {
             if (files[i].isFile()) {            //刪除文件
                 flag = FileDemo_05.deleteFiles(files[i].getAbsolutePath());
                 if (!flag) {
                     break;
                 }
             } else if (files[i].isDirectory()) {  //刪除子文件夾，此處為遞歸
                 flag = FileDemo_05.deleteDir(files[i].getAbsolutePath());
                 if (!flag) {
                     break;
                 }
             } 
         }
         if (!flag) {
             System.out.println("刪除文件夾失敗");
         }
         if (dirFile.delete()) {
             System.out.println("文件夾" + dir + "刪除成功！");
             return true;
         } else {
             return false;
         }
    }
    
    

}

程序示例2 移動指定目錄下的文件，該程序用到了 程序示例1

package 輸入輸出流_移動指定目錄下的文件;

import java.io.File;

public class FileDemo_06 {
    //英東某個指定的文件，但移動成功后不會覆蓋已存在的文件
    public static boolean moveA_File(String sourceFileName, String targetFileName) {
        return FileDemo_06.moveA_File(sourceFileName, targetFileName, false);
    }
    
    //移動某個指定的文件，但移動成功后可以根據isOverlay的值來決定是否覆蓋已存在的目標文件
    public static boolean moveA_File(String sourceFileName, String targetFileName,
                                        boolean isOverlay) {
        File sourceFile = new File(sourceFileName);
        if (!sourceFile.exists()) {
            System.out.println("文件" + sourceFileName + "不存在，移動失敗");
            return false;
        } else if (!sourceFile.isFile()) {
            System.out.println(sourceFileName + "不是文件，移動失敗");
            return false;
        }
        File targetFile = new File(targetFileName);
        if (targetFile.exists()) {
            if (isOverlay) {
                System.out.println("目標文件已經存在，准備刪除它");
                if (!FileDemo_05.deleteFilesOrDir(targetFileName)) {
                    System.out.println("文件移動失敗，文件" + targetFileName + "刪除失敗");
                    return false;
                } 
            } else {
                System.out.println("文件移動失敗，因為文件" + targetFileName + "已經存在");
                return false;
            }
        } else {
            if (!targetFile.getParentFile().exists()) {
                System.out.println("文件" + targetFile + "所在的目錄不存在，正在創建");
                if (!targetFile.getParentFile().mkdirs()) {
                    System.out.println("移動文件失敗，因為創建文件坐在的文件夾失敗");
                    return false;
                }
            }
        }
        
        //移動源文件至目標文件
        if (sourceFile.renameTo(targetFile)) {
            System.out.println("移動源文件" + sourceFileName + "到" + targetFileName 
                    + "成功" );
            return true;
        } else {
            System.out.println("移動源文件" + sourceFileName + "到" + targetFileName 
                    + "失敗" );
            return false;
        }
        
        
    }
    
    public static boolean moveDir(String sourceDirName, String targetDirName) {
        //默認為不覆蓋目標文件
        return FileDemo_06.moveDir(sourceDirName, targetDirName, false);
    }
    
    //移動某個指定的目錄，但移動成功后可以根據isOverlay的值來決定是否覆蓋當前已存在的目標目錄
    public static boolean moveDir(String sourceDirName, String targetDirName,
                                boolean isOverlay) {
        //判斷原目錄是否存在
        File sourceDir = new File(sourceDirName);
        if (!sourceDir.exists()) {
            System.out.println("源目錄" + sourceDirName + "不存在，移動目錄失敗");
            return false;
        } else if (!sourceDir.isDirectory()) {
            System.out.println("移動目錄失敗，" + sourceDirName + "不是目錄");
            return false;
        }
        //如果目標文件名不是以文件分割符結尾，自動添加文件分隔符
        if (!targetDirName.endsWith(File.separator)) {
            targetDirName += File.separator;
        }
        File targetDir = new File(targetDirName);
        //如果目標文件夾存在
        if (targetDir.exists()) {
            if (isOverlay) {
                //允許刪除則刪除已存在的目標目錄
                System.out.println("該目錄已經存在，准備刪除它");
                if (!FileDemo_05.deleteFilesOrDir(targetDirName)) {
                    System.out.println("移動目錄失敗，因為目標目錄已經存在。   刪除目錄" + 
                        targetDirName + "失敗！"                        );
                }
            } else {
                System.out.println("移動目錄失敗:該目錄" + targetDirName + "已存在！");
                return false;
            }
        } else {
            //創建目標目錄
            System.out.println("該目錄不存在，正在創建");
            if (!targetDir.mkdirs()) {
                System.out.println("移動目錄失敗： 創建目標目錄失敗");
                return false;
            }
        }
        boolean flag = true;
        //移動原目錄下的文件和子目錄到目標目錄下
        File[] files = sourceDir.listFiles();
        for (int i = 0; i < files.length; i++) {
            //移動子文件
            if (files[i].isFile()) {
                flag = FileDemo_06.moveA_File(files[i].getAbsolutePath(),
                        targetDirName + files[i].getName(), isOverlay);
                if (!flag) {
                    break;
                }
            } else if (files[i].isDirectory()) { //移動子目錄
                flag = FileDemo_06.moveDir(files[i].getAbsolutePath(),
                        targetDirName + files[i].getName(), isOverlay);
                if (!flag) {
                    break;
                }
                
            }
        }
        
        if (!flag) {
            System.out.println("目錄" + sourceDirName + "移動到" + targetDirName + "失敗");
            return false;
        }
        //刪除原目錄
        if (FileDemo_05.deleteDir(sourceDirName)) {
            System.out.println("目錄" + sourceDirName + "移動到" + targetDirName + "成功");
            return true;
        } else {
            System.out.println("目錄" + sourceDirName + "移動到" + targetDirName + "失敗");
            return false;
        }
    }
    
    
    public static void main(String[] args) {
        //移動文件，如果目標文件存在，則替換
        System.out.println("調用moveA_File方法的結果如下");
        String sourceFileName = "D:\\aa\\temp\\key.txt";
        String targetFileName = "D:\\bbb\\ddd\\";
        FileDemo_06.moveA_File(sourceFileName, targetFileName);
        //移動目錄，如果目標目錄存在，則不覆蓋
        System.out.println("\n調用moveDir方法的結果如下");
        String sourceDir = "D:\\aa";
        String targetDir = "C:\\mm";
        FileDemo_06.moveDir(sourceDir, targetDir,false);
    }
    

}