一、File類

1、概述

• java.io.File類：是檔案和目錄(資料夾)路徑名的抽象表示，主要用於檔案和目錄的建立、刪除和查詢等操作。

• File是一個與作業系統無關的類，任何作業系統都可以使用這個類中的方法。

記住三個單詞：

​ file：檔案 directory：資料夾/目錄 path：路徑

2、Field

File類的靜態成員變數：

• public static final String pathSeparator 與系統有關的路徑分隔符；為了方便，它被表示為一個字串
• public static final char pathSeparatorChar 與系統有關的路徑分隔符

注意：兩者是一樣的

​ public static final String pathSeparator = "" + pathSeparatorChar;

• public static final String separator 與系統有關的預設名稱分隔符；為了方便，它被表示為一個字串
• public static final char separatorChar 與系統有關的預設名稱分隔符

注意：兩者是一樣的

​ public static final String separator = "" + separatorChar;

import java.io.File;
public class Demo1File{
    public static void main(String[] args){
        /*
        	注意：操作路徑時，路徑不能寫死。（因為各個OS所使用的分隔符不同）
        		C:\develop\a\a.txt  windows
                C:/develop/a/a.txt  linux
            "C:"+File.separator+"develop"+File.separator+"a"+File.separator+"a.txt"
        */
        String pathSeparator = File.pathSeparator;
        System.out.println(pathSeparator); //; 路徑分隔符。windows：分號;  linux：冒號:
        String separator = File.separator;
        System.out.println(separator); //\ 檔名稱分隔符。windows：反斜槓\  linux：正斜槓/
        
    }
}

 

3、路徑

絕對路徑：是一個完整的路徑，以碟符(c:，d:)開始的路徑。

​ C:\Users\Administrator\Desktop\Markdown study

​ D:\Course\JavaSE\基礎語法\src\day08\file\demo1\File

相對路徑：是一個簡化的路徑

​ 相對指的是相對於當前專案的根目錄；如果使用當前專案的根目錄，路徑可以簡化書寫。

​ D:\Course\JavaSE\基礎語法\src\a.txt --> 簡化為 a.txt(可以省略專案的根目錄)

注意：

• 路徑不區分大小寫
• 路徑中的檔名稱分隔符windows使用反斜槓，而在java中反斜槓是轉義字元，兩個反斜槓才代表一個普通的反斜槓。

4、Constructor

• public File(String pathname); 通過將給定的路徑名字串轉換為抽象路徑名來建立一個新File例項

import java.io.File;
public class Demo2File{
    public static void main(String[] args){
  /*
 	public File(String pathname); 通過將給定的路徑名字串轉換為抽象路徑名來建立一個新File例項
    	引數：
        	String pathname：路徑名字串
            路徑可以是以檔案結尾，也可以是以資料夾結尾
            路徑可以是相對路徑，也可以是絕對路徑
            路徑可以是存在，也可以是不存在
    	建立File物件，只是把字串路徑封裝為File物件，不考慮路徑的真假情況
  */
        //絕對路徑 以檔案結尾 且不存在
        File f1 = new File("C:\\Users\\Administrator\\Desktop\\Markdown study\\a.txt");
        //C:\Users\Administrator\Desktop\Markdown study\a.txt
        System.out.println(f1); //重寫了Object類的toString() 

        //絕對路徑 以資料夾結尾 存在
        File f2 = new File("C:\\Users\\Administrator\\Desktop\\Markdown study");
        System.out.println(f2); //C:\Users\Administrator\Desktop\Markdown study

        //相對路徑
        File f3 = new File("b.txt");
        System.out.println(f3); //b.txt
    }
}

• public File(String parent,String child); 根據父路徑字串和子路徑字串建立一個新File例項

import java.io.File;
public class Demo3File{
    public static void main(String[] args){
    /*
    	public File(String parent,String child); 根據父路徑字串和子路徑字串建立一個新File例項
        引數：把路徑分成了兩部分
            String parent：父路徑
            String child：子路徑
        好處：
            父路徑和子路徑可以單獨書寫，使用起來非常靈活；父路徑和子路徑都可以變化。
    */
        show02("c:\\","a.txt"); //c:\a.txt
        show02("d:\\","a.txt"); //d:\a.txt
    }
    
    public static void show02(String parent,String child) {
   		 File file = new File(parent,child);
       	 System.out.println(file);
   }
}

• public FIle(File parent,String child); 根據 parent 抽象路徑名和 child 路徑名字串建立一個新File例項

import java.io.File;
public class Demo4File{
    public static void main(String[] args){
    /*
    public File(File parent,String child); 根據父抽象路徑名和子路徑名字串建立一個新File例項
    引數：把路徑分成了兩部分
        String parent：父路徑
        String child：子路徑
    好處：
        父路徑和子路徑可以單獨書寫，使用起來非常靈活；父路徑和子路徑都可以變化。
        父路徑是File型別，可以使用File的方法對路徑進行一些操作，再使用路徑建立物件。
    */
        show03();
    }
    
    public static void show03(){
        File parent = new File("d:\\");
        File file = new File(parent,"hello.java");
        System.out.println(file); //d:\hello.java
    }
}

5、常用方法

5.1 獲取功能的方法

• public String getAbsolutePath(); 返回此File的絕對路徑名字串

import java.io.File;
public class Demo5File{
    public static void main(String[] args){
    /*
    	public String getAbsolutePath(); 返回此File的絕對路徑名字串
            獲取的構造方法中傳遞的路徑
            無論路徑是絕對的還是相對的，getAbsolutePath方法返回的都是絕對路徑
    */
        File f1 = new File("D:\\Course\\JavaSE\\基礎語法\\src\\Day08\\a.txt");
        String absolutePath1 = f1.getAbsolutePath();
        System.out.println(absolutePath1); //D:\Course\JavaSE\基礎語法\src\Day08\a.txt

        File f2 = new File("a.txt");
        String absolutePath2 = f2.getAbsolutePath();
        System.out.println(absolutePath2); //D:\Course\JavaSE\基礎語法\src\a.txt
    }
}

• public String getPath(); 將此File轉換為路徑名字串

import java.io.File;
public class Demo6File{
    public static void main(String[] args){
    /*
    	public String getPath();  將此File轉換為路徑名字串
        	獲取的構造方法中傳遞的路徑
            傳遞的是絕對路徑就返回絕對路徑，傳遞的相對路徑就返回相對路徑。

        File類中重寫的toString()呼叫的就是getPath()。
        原始碼：
            public String toString() {
                return getPath();
            }
    */
        
        File f1 = new File("C:\\Users\\Administrator\\Desktop\\Markdown study");
        File f2 = new File("b.txt");
        String path1 = f1.getPath();
        String path2 = f2.getPath();
        System.out.println(path1); //C:\Users\Administrator\Desktop\Markdown study
        System.out.println(path2); //b.txt

        System.out.println(f1); //C:\Users\Administrator\Desktop\Markdown study
        System.out.println(f1.toString()); //C:\Users\Administrator\Desktop\Markdown study

    }
}

• public String getName(); 返回由此File表示的檔案/目錄的名稱

import java.io.File;
public class Demo7File{
    public static void main(String[] args){
    /*
    	public String getName();  返回由此File表示的檔案/目錄的名稱
            獲取的就是構造方法傳遞路徑的結尾部分（檔案/資料夾）
    */
        
        File f1 = new File("C:\\Users\\Administrator\\Desktop\\Markdown study\\a.txt");
        String name1 = f1.getName();
        System.out.println(name1); //a.txt 獲取的結尾部分是檔案

        File f2 = new File("C:\\Users\\Administrator\\Desktop\\Markdown study");
        String name2 = f2.getName();
        System.out.println(name2); //Markdown study  獲取的結尾部分是資料夾
        
    }
}

• public long length(); 返回由此File表示的檔案的大小

import java.io.File;
public class Demo8File{
    public static void main(String[] args){
  	/*
  		public long length();   返回由此File表示的檔案的大小
            獲取的是構造方法指定的檔案的大小，以位元組為單位。
        注意：
            1.資料夾是沒有大小概念的，不能獲取資料夾的大小
            2.如果構造方法中給出的路徑不存在，那麼length方法返回0
  	*/     
        
        File f1 = new File("C:\\Users\\Administrator\\Desktop\\a\\1.jpg");
        long l1 = f1.length();
        System.out.println(l1); //388260位元組

        File f2 = new File("C:\\Users\\Administrator\\Desktop\\a\\2.jpg");
        System.out.println(f2.length()); //0

        File f3 = new File("C:\\Users\\Administrator\\Desktop\\a");
        System.out.println(f3.length()); //0 資料夾是沒有大小概念的
        
    }
}

5.2 判斷功能的方法

• public boolean exists(); 判斷此File表示的檔案/目錄是否實際存在

import java.io.File;
public class Demo9File{    
  public static void main(String[] args){    
  /*    	
    public boolean exists(); 判斷此File表示的檔案/目錄是否實際存在            
    用於判斷構造方法中的路徑是否存在                
      存在：true                
      不存在：false    
  */                    
    File f1 = new File("C:\\Users\\Administrator\\Desktop\\Markdown study");        
    System.out.println(f1.exists()); //true        
    File f2 = new File("C:\\Users\\Administrator\\Desktop\\Markdown study\\a.txt");        
    System.out.println(f2.exists()); //false        
    File f3 = new File("day03");        
    System.out.println(f3.exists()); //true        
    File f4 = new File("dayday");        
    System.out.println(f4.exists()); //false            
  }
}

• public boolean isDirectory(); 判斷此File表示的是否為目錄
• public boolean isFile(); 判斷此File表示的是否為檔案

import java.io.File;
public class Demo10File{   
  public static void main(String[] args){    
  /*    	
    public boolean isDirectory(); 判斷此File表示的是否為目錄            
    用於判斷構造方法中給定的路徑是否以資料夾結尾                
      是：true                
      否：false        
    public boolean isFile(); 判斷此File表示的是否為檔案            
    用於判斷構造方法中給定的路徑是否以檔案結尾                
      是：true                
      否：false        
    注意：            
      電腦的硬碟只有檔案和資料夾，兩個方法是互斥            
      這兩個方法使用前提：路徑必須是存在的，否則都返回false    
  */                 
    File f1 = new File("C:\\Users\\Administrator\\Desktop\\Markdown study\\t.txt");        
    System.out.println(f1.isDirectory()); //false 檔案不存在        
    System.out.println(f1.isFile()); //false  檔案不存在        
    File f2 = new File("C:\\Users\\Administrator\\Desktop\\Markdown study");        
    //加個判斷，不存在就沒有必要獲取        
    if(f2.exists()){            
      System.out.println(f2.isDirectory()); //true 存在 以資料夾結尾            
      System.out.println(f2.isFile()); //false 存在 不是以檔案結尾        
    }        
    File f3 = new File("C:\\Users\\Administrator\\Desktop\\Markdown study\\Day01.md");        
    if(f3.exists()){            
      System.out.println(f3.isDirectory()); //false 存在 不是以檔案結尾            
      System.out.println(f3.isFile()); //true 存在 以檔案結尾        
    }            
  }
}

5.3 建立、刪除功能的方法

• public boolean creatNewFile(); 當且僅當具有該名稱的檔案不存在時，建立一個新的檔案

import java.io.File;
public class Demo11File{    
  public static void main(String[] args){    
  /*    	 
    public boolean createNewFile(); 當且僅當具有該名稱的檔案不存在時，建立一個新的檔案            
    建立檔案的路徑和名稱在構造方法中給出(構造方法的引數)        
    返回值：布林值            
      true：檔案不存在，建立檔案，返回true            
      false：檔案存在，不會建立，返回false        
    注意：            
      1.此方法只能建立檔案，不能建立資料夾            
      2.建立檔案的路徑必須存在，否則會丟擲異常。    
  */                
    //絕對路徑：        
    File f1 = new File("C:\\Users\\Administrator\\Desktop\\a\\xzw.txt");        
    boolean b1 = f1.createNewFile();        
    System.out.println("b1: " + b1); //true        
    //相對路徑：相對於當前專案所在的根目錄        
    File f2 = new File("lyq.txt");        
    boolean b2 = f2.createNewFile();        
    System.out.println("b2: " + b2);        
    File f3 = new File("C:\\Desktop\\lss\\xzw\\lyq.txt");        
    boolean b3 = f3.createNewFile();        
    System.out.println(b3); //路徑不存在 丟擲IOException！            
  }
}

• public boolean delete(); 刪除由此File表示的檔案或目錄
• public boolean mkdir(); 建立單級資料夾
• public boolean mkdirs(); 既可以建立單級資料夾，也可以建立多級資料夾

/*        
public boolean mkdir(); 建立單級資料夾        
public boolean mkdirs(); 既可以建立單級資料夾，也可以建立多級資料夾            
建立檔案的路徑和名稱在構造方法中給出(構造方法的引數)        
  返回值：布林值            
    true：資料夾不存在，建立資料夾，返回true            
    false：資料夾存在，不會建立，返回false；構造方法中給出的資料夾路徑不存在，也返回false        
  注意：            
    此方法只能建立資料夾，不能建立檔案        

public boolean delete(); 刪除由此File表示的檔案或目錄            
此方法，可以刪除構造方法路徑中給出的檔案/資料夾        
  返回值：布林值            
    true：檔案/資料夾刪除成功，返回true            
    false：資料夾中有內容，不會刪除返回false；構造方法中路徑不存在，也返回false        
  注意:            
    delete方法是直接在硬碟刪除檔案/資料夾，不走回收站，刪除要謹慎！     
*/

5.4 File類遍歷(資料夾)目錄功能

• public String[ ] list(); 返回一個String陣列，表示該File目錄中的所有子檔案或目錄

import java.io.File;
public class Demo12File{    
  public static void main(String[] args){    
    /*    	
      public String[] list(); 返回一個String陣列，表示該File目錄中的所有子檔案或目錄            
        遍歷構造方法中給出的目錄，會獲取目錄中所有檔案/資料夾的名稱，把獲取到的多個名稱            
        儲存到一個String型別的陣列中。        	
      能夠獲取到隱藏的檔案/資料夾。    
    */            
    //NullPointerException  檔案不存在        
    //File f1 = new File("D:\\Course\\JavaSE\\基礎語法\\src\\Day0\\file");         
    //NullPointerException  給出的路徑不是一個目錄        
    //File f1 = new File("D:\\Course\\JavaSE\\基礎語法\\src\\基礎語法.iml");         
    File f1 = new File("D:\\Course\\JavaSE\\基礎語法\\src\\Day08\\file");        
    String[] arr1 = f1.list();        
    for (String s : arr1) {            
      System.out.println(s);        
    }            
  }
}

• public File[ ] listFiles(); 返回一個File陣列，表示該File目錄中的所有子檔案或目錄

import java.io.File;
public class Demo13File{    
  public static void main(String[] args){    
  /*    	
    public File[] listFiles();  返回一個File陣列，表示該File目錄中的所有子檔案或目錄            
    遍歷構造方法中給出的目錄，會獲取目錄中所有檔案/資料夾的名稱，把檔案/資料夾封裝為File物件，            
    將多個File物件儲存到陣列中。    
  */                
    File f1 = new File("D:\\Course\\JavaSE\\基礎語法\\src\\Day08\\file");        
    File[] arr = f1.listFiles();        
    for(File f : arr){            
      System.out.println(f);        
    }            
  }
}

注意：
   list和listFiles方法遍歷的是構造方法中給出的目錄
   如果構造方法中給出的目錄的路徑不存在，會丟擲空指標異常!
   如果構造方法給出的路徑不是一個目錄，也會丟擲空指標異常！

二、遞迴

1、概述

• 指在當前方法內呼叫自己的這種現象。（方法自己呼叫自己）

2、分類

• 直接遞迴：方法自身呼叫自己。
• 間接遞迴：A方法呼叫B方法，B方法呼叫C方法，C方法呼叫A方法。

注意事項：

​ a. 遞迴一定要有條件限定，保證遞迴能夠停止下來，否則會發生棧記憶體溢位。

​ b. 在遞迴中雖然有限定條件，但是遞迴次數不能太多，否則也會發生棧記憶體溢位。

​ c. 構造方法，禁止遞迴。

​ 構造方法是建立物件使用的，一直遞迴會導致記憶體中有無數多個物件，直接編譯報錯。

使用遞迴的前提：

​ 當呼叫方法的時候，方法的主體不變，每次呼叫方法的引數不同，可以使用遞迴。

3、案例分析

3.1 計算1~n的和

/*    
  利用遞迴：計算1~n的和。 (用for迴圈更好！) 
*/
public class Demo1Recursion {    
  public static void main(String[] args) {        
    System.out.println(sum(100));    
  }    

  public static int sum(int n){        
    if(n == 1){            
      return 1;        
    }        
    return n + sum(n-1);    
  }
}

3.2 計算n!

/*	
  利用遞迴：計算n的階乘。
*/
public class Demo2Recursion {    
  public static void main(String[] args) {        
    int result = f(5);        
    System.out.println(result);    
  }    

  public static int f(int n){        
    if(n == 1){            
      return 1;        
    }        
    return n * f(n - 1);    
  }
}

3.3 用遞迴列印多級目錄

import java.io.File;
/*    
  遞迴列印多級目錄：        
  C:\Users\Administrator\Desktop\abc             
    a資料夾：                
      a.txt                
      1.jpg            
    b資料夾：                
      b.txt                
      2.jpg            
    lyq.java檔案            
    xzw.txt檔案 
*/
public class Demo3Recursion {    
  public static void main(String[] args) {        
    File file = new File("C:\\Users\\Administrator\\Desktop\\abc");        
    getAllFile(file);    
  }    
  //定義一個遍歷資料夾的方法    
  public static void getAllFile(File dir) {        
    System.out.println(dir.getName()); //列印遍歷的目錄名稱        
    File[] files = dir.listFiles();        
    for (File f : files) {            
    //對遍歷的物件進行判斷，判斷是否為資料夾            
      if (f.isDirectory()) {                
        //f是一個資料夾，則繼續遍歷這個資料夾                
        //發現getAllFile方法就是傳遞資料夾，遍歷資料夾的方法                
        //所以直接呼叫getAllFile方法即可：遞迴（自己呼叫自己）                
        getAllFile(f);            
      } else {                
        //是一個檔案，直接列印即可                
        System.out.println(f);            
      }        
    }    
  }
}

3.4 用遞迴進行檔案搜尋

import java.io.File;
/*    
  檔案搜尋：搜尋C:\Users\Administrator\Desktop\abc目錄中以.java結尾的檔案：    
  abc資料夾包含：        
    a資料夾：            
      a.txt            
      1.jpg        
    b資料夾：            
      b.txt            
      2.jpg        
    lyq.java檔案        
    xzw.txt檔案 
*/
public class Demo5Recursion {    
  public static void main(String[] args) {        
    File file = new File("C:\\Users\\Administrator\\Desktop\\abc");        
    getAllFile(file);    
  }    

  public static void getAllFile(File dir) {        
    File[] files = dir.listFiles();        
    for (File f : files) {            
      //對遍歷的物件進行判斷，判斷是否為資料夾            
      if (f.isDirectory()) {                
        //f是一個資料夾，則繼續遍歷這個資料夾                
        //發現getAllFile方法就是傳遞資料夾，遍歷資料夾的方法                
        //所以直接呼叫getAllFile方法即可：遞迴（自己呼叫自己）                
        getAllFile(f);            
      } else {                
          //是一個檔案，直接列印即可                
        /*                    
            C:\Users\Administrator\Desktop\abc\lyq.java                    
              只要.java結尾的檔案                    
              1.把File物件f，轉為字串物件                 
        */                
        /*                
          //String name = f.getName(); //lyq.java                
          //String path = f.getPath(); 	
          //C:\Users\Administrator\Desktop\abc\lyq.java                
          String s = f.toString(); //C:\Users\Administrator\Desktop\abc\lyq.java                
          //把字串轉換為小寫                
          s = s.toLowerCase();                
          //2.呼叫String類中的方法endsWith判斷字串是否以.java結尾                
          boolean b = s.endsWith(".java");                
          //3.如果是以.java結尾的，則輸出                
          if(b){                    
            System.out.println(f);                
          }                 
        */                
          //鏈式程式設計：簡化程式碼                
          if(f.toString().toLowerCase().endsWith(".java")){                    
            System.out.println(f);                
          }            
        }        
      }    
    }
}

4、FileFilter檔案過濾器

import java.io.File;
import java.io.FileFilter;
/*    
  需求：        
    遍歷C:\Users\Administrator\Desktop\abc資料夾，及abc資料夾的子資料夾        
    只要以.java結尾的檔案：    
  C:\Users\Administrator\Desktop\abc        
    C:\Users\Administrator\Desktop\abc\lyq.java        
    C:\Users\Administrator\Desktop\abc\xzw.txt        
    C:\Users\Administrator\Desktop\abc\a            
      C:\Users\Administrator\Desktop\abc\a\1.jpg            
      C:\Users\Administrator\Desktop\abc\a\a.JAVA        
    C:\Users\Administrator\Desktop\abc\b            
      C:\Users\Administrator\Desktop\abc\b\b.java            
      C:\Users\Administrator\Desktop\abc\b\b.txt    

  可以使用過濾器來實現：    
  在File類中有兩個和listFiles過載的方法，方法的引數傳遞的就是過濾器： 
       
  File[] listFiles(FileFilter filter)        
  java.io.FileFilter介面：用於抽象路徑名（File物件）的過濾器            
  作用：用來過濾檔案（File物件）            
  包含抽象方法：用來過濾檔案的方法                
    boolean accept(File pathname) 測試指定抽象路徑名是否應該包含在某個路徑名列表中                
    引數：                    
      File pathname：使用listFiles方法遍歷目錄，得到的每一個檔案物件。    
     
  File[] listFiles(FilenameFilter filter)         
  java.io.FilenameFilter介面：實現此介面的類例項可用於過濾器檔名。            
  作用：用來過濾檔名稱            
  包含抽象方法：用來過濾檔案的方法                
    boolean accept(File dir,String name) 測定指定檔案是否應該包含在某一檔案列表中                
    引數：                    
      File dir：構造方法中傳遞的被遍歷的目錄                    
      String name：使用listFiles方法遍歷目錄，獲取的每一個檔案/資料夾的名稱   
 
  注意：        
    兩個過濾器介面是沒有實現類的，需要我們自己寫實現類，重寫過濾的方法accept，在方法中定義過濾的規則。 
*/
public class Demo1Filter {    
  public static void main(String[] args) {        
    File file = new File("C:\\Users\\Administrator\\Desktop\\abc");        
    getAllFile(file);    
  }    

  //定義一個方法：引數傳遞File型別的目錄，方法中對目錄進行遍歷    
  public static void getAllFile(File dir) {        
    File[] files = dir.listFiles(new FileFilterImpl(            
    /*   				 
      建立過濾器FileFilter的實現類（匿名內部類）   				 
      重寫過濾方法accept，定義過濾規則。			 
    */            
      @Override            
      public boolean accept(File pathname) {                
      /*                    
        過濾的規則：                        
          在accept方法中，判斷File物件是否以.java結尾                        
            如果是，返回true                        
            否則，返回false                 
      */                
      //如果pathname是一個資料夾，返回true，繼續遍歷這個資料夾                
      if(pathname.isDirectory()){                    
        return true;                
      }                
      return pathname.getName().toLowerCase().endsWith(".java");    		
    }));                 

    //傳遞過濾器物件        
    for (File f : files) {            
      //對遍歷的物件進行判斷，判斷是否為資料夾            
      if (f.isDirectory()) {                
        //f是一個資料夾，則繼續遍歷這個資料夾                
        //發現getAllFile方法就是傳遞資料夾，遍歷資料夾的方法                
        //所以直接呼叫getAllFile方法即可：遞迴（自己呼叫自己）                
        getAllFile(f);            
      } else {                
        //是一個檔案，直接列印即可                
        System.out.println(f);            
      }        
    }    
  }
}