文件 File

文件

1. 文件的一些經常使用方法

package com.ljw.study;

import java.io.File;
import java.util.Arrays;
import java.util.Date;

public class FileDemo {

    public static void main(String[] args) {
        // 構造文件對象
        // 絕對路徑,構造文件夾對象
        File f1 = new File("d:/work/code/ljw/Test");
        System.out.println(f1.exists()); // 文件是否存在
        
        // 相對路徑,若是是eclipse的話,就是相對於項目目錄
        File f2 = new File("employee.ser");
        System.out.println("f2的絕對路徑:" + f2.getAbsolutePath());
        System.out.println(f2.exists());
        
        // 以f1爲父目錄建立文件對象
        File f3 = new File(f1,"LOL.exe");
        System.out.println("f3的絕對路徑:" + f3.getAbsolutePath());
        
        System.out.println(f2.isDirectory()); // 是不是文件夾
        
        System.out.println(f2.isFile()); // 是否爲文件(非文件夾)
        
        System.out.println(f2.length()); // 文件長度
        
        System.out.println(new Date(f2.lastModified())); // 最後的修改時間
        
//      System.out.println(f2.renameTo(new File("employee.ser")));// 文件重命名
        
        System.out.println(Arrays.toString(f1.list())); // 以字符串數組的形式,返回當前文件夾下的全部文件(不包含子文件及子文件夾)
        
        System.out.println(Arrays.toString(f1.listFiles())); // 以文件數組的形式,返回當前文件夾下的全部文件(不包含子文件及子文件夾)
        
        // 以字符串形式返回獲取所在文件夾
        System.out.println(f1.getParent());
  
        // 以文件形式返回獲取所在文件夾
        f2.getParentFile();
        // 建立文件夾,若是父文件夾skin不存在,建立就無效
        f1.mkdir();
  
        // 建立文件夾,若是父文件夾skin不存在,就會建立父文件夾
        f1.mkdirs();
  
        // 建立一個空文件,若是父文件夾skin不存在,就會拋出異常
        f1.createNewFile();
        // 因此建立一個空文件以前,一般都會建立父目錄
        f1.getParentFile().mkdirs();
  
        // 列出全部的盤符c: d: e: 等等
        f1.listRoots();

        // 刪除文件
        f.delete();
  
        // JVM結束的時候,刪除文件,經常使用於臨時文件的刪除
        f.deleteOnExit()
    }
}

2. 讀取和寫入文件數據

2.1 以字節流方式

2.1.1 讀取數據

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
  
public class TestStream {
  
    public static void main(String[] args) {
        try {
            //準備文件lol.txt其中的內容是AB,對應的ASCII分別是65 66
            File f =new File("d:/lol.txt");
            //建立基於文件的輸入流
            FileInputStream fis =new FileInputStream(f);
            //建立字節數組,其長度就是文件的長度
            byte[] all =new byte[(int) f.length()];
            //以字節流的形式讀取文件全部內容
            fis.read(all);
            for (byte b : all) {
                //打印出來是65 66
                System.out.println(b);
            }
             
            //每次使用完流,都應該進行關閉
            fis.close();
              
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

2.1.2 寫入數據

package com.ljw.practice;

import java.io.File;
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) {
        // TODO Auto-generated method stub
        File f = new File("d:/xyz/abc/def/lol2.txt");
        f.getParentFile().mkdirs();
        
        try {
            FileOutputStream outputFile = new FileOutputStream(f);
            String s = "秋天,多了一些思念";
            byte[] b = s.getBytes(); // 將字符串轉換爲字節數組byte[]
            outputFile.write(b);
            outputFile.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
    }
}

2.2 以字符流方式

2.2.1 讀取數據

package com.ljw.practice;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class FileDemo {

    public static void main(String[] args) {
        File f = new File("d:/lol.txt");
        
        try(FileReader fr = new FileReader(f)){ // 數據流寫在try()裏面,系統會幫咱們自動關閉數據流
            char[] c = new char[(int) f.length()];
            fr.read(c);
            for(char i:c) {
                System.out.print(i);
            }
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

2.2.2 寫入數據

package com.ljw.practice;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class FileDemo {

    public static void main(String[] args) {
        File f = new File("d:/lol.txt");
        File f2 = new File("d:/lol2.txt");
        
        try(FileReader fr = new FileReader(f);FileWriter fw = new FileWriter(f2)){
            char[] c = new char[(int) f.length()];
            fr.read(c); // 讀出數據到字符數組
            fw.write(c); // 寫入數據從數組到文件
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

2.3 以緩存流方式

  • 緩存流必須創建在一個存在的流的基礎上
  • 以介質是硬盤爲例,字節流和字符流的弊端:在每一次讀寫的時候,都會訪問硬盤。 若是讀寫的頻率比較高的時候,其性能表現不佳。
  • 爲了解決以上弊端,採用緩存流。緩存流在讀取的時候,會一次性讀較多的數據到緩存中,之後每一次的讀取,都是在緩存中訪問,直到緩存中的數據讀取完畢,再到硬盤中讀取。
  • 若是須要當即將緩存中的數據寫入硬盤,可使用flush()方法

2.3.1 讀取數據

package stream;

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

public class TestStream {
    public static void main(String[] args) {
        File f = new File("d:/lol.txt");
        // 建立文件字符流
        // 緩存流必須創建在一個存在的流的基礎上
        try (
                FileReader fr = new FileReader(f);
                BufferedReader br = new BufferedReader(fr);
            )
        {
            while (true) {
                // 一次讀一行
                String line = br.readLine();
                if (null == line)
                    break;
                System.out.println(line);
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    
    }
}

2.3.2 寫入數據

package com.ljw.practice;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

public class FileDemo {

    public static void main(String[] args) {
        File f = new File("d:/lol2.txt");
        
        try (
                // 建立文件字符流
                FileWriter fw = new FileWriter(f);
                // 緩存流必須創建在一個存在的流的基礎上              
                PrintWriter pw = new PrintWriter(fw);              
        ) {
            pw.println("garen kill teemo");
            pw.println("teemo revive after 1 minutes");
            pw.println("teemo try to garen, but killed again");
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

2.4 以數據流方式

  • 使用數據流的writeUTF()和readUTF() 能夠進行數據的格式化順序讀寫
  • 要用DataInputStream 讀取一個文件,這個文件必須是由DataOutputStream 寫出的,不然會出現EOFException,由於DataOutputStream 在寫出的時候會作一些特殊標記,只有DataInputStream 才能成功的讀取。

2.4.1 實例

  • 以數據流的方式讀寫數據
package com.ljw.practice;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
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) {
        write();
        read();
    }
    
    private static void read() {
        File f = new File("d:/lol2.txt");
        try(
                FileInputStream fi = new FileInputStream(f); 
                DataInputStream di = new DataInputStream(fi); // 建立一個數據流對象
            ) 
        {
            boolean b = di.readBoolean();
            int i = di.readInt();
            String s = di.readUTF();
            System.out.println(b);
            System.out.println(i);
            System.out.println(s);
            
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }
        
    }
    
    private static void write() {
        File f = new File("d:/lol2.txt");
        
        try(
                FileOutputStream fo = new FileOutputStream(f);
                DataOutputStream dos = new DataOutputStream(fo);
            )
        {
            dos.writeBoolean(false);
            dos.writeInt(200);
            dos.writeUTF("中國");
            
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

2.5 以對象流(序列化對象)

  • 把一個對象序列化有一個前提是:這個對象的類,必須實現了Serializable接口
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
  
import charactor.Hero;
    
public class TestStream {
    
    public static void main(String[] args) {
        //建立一個Hero garen
        //要把Hero對象直接保存在文件上,務必讓Hero類實現Serializable接口
        Hero h = new Hero();
        h.name = "garen";
        h.hp = 616;
          
        //準備一個文件用於保存該對象
        File f =new File("d:/garen.lol");
 
        try(
            //建立對象輸出流
            FileOutputStream fos = new FileOutputStream(f);
            ObjectOutputStream oos =new ObjectOutputStream(fos);
            //建立對象輸入流              
            FileInputStream fis = new FileInputStream(f);
            ObjectInputStream ois =new ObjectInputStream(fis);
        ) {
            oos.writeObject(h);
            Hero h2 = (Hero) ois.readObject();
            System.out.println(h2.name);
            System.out.println(h2.hp);
               
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

3. 拆分文件 和 合併文件

3.1 拆分文件

package com.ljw.practice;

import java.io.File;
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) {
        // TODO Auto-generated method stub
        File file = new File("d:/F.docx");
        
        try {
            FileInputStream inFile = new FileInputStream(file);
            int i = 1;
            while(true) {
                byte[] b = new byte[1024*100];
                int n = inFile.read(b);
                if(n==-1) {  // 沒有讀到數據返回 -1
                    break;
                }
                File f1 = new File(String.format("d:/F-%d.docx",i)); // 佔位符
                FileOutputStream outFile = new FileOutputStream(f1);
                outFile.write(b);
                i++;
            }   
            
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

3.2 合併文件

package com.ljw.practice;

import java.io.File;
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) {
        // TODO Auto-generated method stub
        File newF = new File("d:/newF.docx");
        try {
            FileOutputStream outNewF = new FileOutputStream(newF);
            for(int i=1;i<5;i++) {
                File f = new File(String.format("d:/F-%d.docx", i));
                byte[] b = new byte[(int) f.length()];
                FileInputStream inf = new FileInputStream(f);
                inf.read(b);
                outNewF.write(b);
                inf.close();
            }
            outNewF.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

4. 中文問題

package com.ljw.practice;

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

public class FileDemo {

    public static void main(String[] args) {
        File f = new File("d:/lol.txt");
        try (FileInputStream fis = new FileInputStream(f);) {
            byte[] all = new byte[(int) f.length()];
            fis.read(all);
        
            //文件中讀出來的數據是
            System.out.println("文件中讀出來的數據是:");
            for (byte b : all)
            {
                int i = b&0xff;  //只取16進制的後兩位
                System.out.println(Integer.toHexString(i));
            }
            System.out.println("把這個數字,放在GBK的棋盤上去:");
            String str = new String(all,"GBK");
            System.out.println(str);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

綜合練習

  • 複製文件或文件夾
  • 查找指定的內容
package com.ljw.practice;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;

public class FilePractice {

    public static void main(String[] args) {
        //----------複製文件--------------
        File srcFile = new File("d:/lol.txt");
        File destFile = new File("d:/lol3.txt");
        copyFile(srcFile,destFile);
        
        //----------複製文件夾------------
        File srcFolder = new File("d:/xyz");
        File destFolder = new File("d:/xyz-副本");
        copyFolder(srcFolder,destFolder);
        
        //----------查找---------------
        String s = "hello";
        findFileContent(s, srcFolder);
        
    }
    
    /**
     * 複製文件
     * @param srcFile:源文件
     * @param destFile:目標文件
     * @return void
     */
    public static void copyFile(File srcFile, File destFile) {
        if(srcFile.exists()) {
            try(    
                    // 建立讀取文件流對象
                    FileInputStream fi = new FileInputStream(srcFile);          
                    // 建立寫入文件流對象
                    FileOutputStream fo = new FileOutputStream(destFile);
                    
                )
            {
                byte[] b = new byte[10];
                int i;
                while(true) {
                    i = fi.read(b);
                    if(-1==i) {
                        break;        
                    }
                    fo.write(b,0,i);
                }
            } catch (FileNotFoundException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
        }else {
            System.out.println("文件不存在");
        }
    }
        
        
    /**
     * 複製文件夾
     * @param srcFile
     * @param destFile
     */
    public static void copyFolder(File srcFile, File destFile) {
        if(srcFile.isDirectory()) {
            File[] files = srcFile.listFiles();
            destFile.mkdir();
            for(File f:files) {
                if(f.isDirectory()) {
                    String newFolderPath = destFile.getAbsolutePath()+"\\"+f.getName();
                    File newFolder = new File(newFolderPath);
                    newFolder.mkdir();
                    System.out.println("新文件夾的位置是:"+newFolderPath);
                    copyFolder(f,newFolder);
                }else {
                    String newFilePath = destFile.getAbsolutePath()+"\\"+f.getName();
                    System.out.println("新文件的位置是:"+newFilePath);
                    File newF = new File(newFilePath);
                    copyFile(f,newF);
                }
            }
        }else {
            copyFile(srcFile, destFile);
        }
    }
    
    /**
     * 查找指定的文件內容
     * @param s:要查找的字符串
     * @param file:要查找的文件對象
     */
    public static void findFileContent(String s,File file) {
        if(file.isDirectory()) {
            File[] files = file.listFiles();
            for(File f:files) {
                findFileContent(s,f);
            }
        }else {
            try(
                    FileReader fr = new FileReader(file);
                    BufferedReader br = new BufferedReader(fr);
                ) {
                
                while(true) {
                    String str = br.readLine();
                    if(null == str) {break;}
                    if(str.contains(s)) {
                        System.out.println("找到目標字符串"+s+",在文件:"+file.getAbsolutePath());
                        break;
                    }
                }
                
            } catch (FileNotFoundException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (IOException e1) {
                // TODO Auto-generated catch block
                e1.printStackTrace();
            }
        }
    }
}
相關文章
相關標籤/搜索