IO流之File对象

File类：

• 用来将文件或者文件夹封装成对象
• 方便对文件与文件夹的属性等信息进行操作（因为流只能操作文件中的数据）
• File对象可以作为参考传递给流的构造函数

　　上下级文件夹之间使用分隔符分开：

　　在Windows中分隔符为‘\’ ，在Unix/Linux中分隔符为‘/’

　　跨平台分隔符：专业的做法是使用File.separatorChar，这个值会根据系统得到的相应的分隔符。

　　例：new File("c:"+File.separatorChar+"a.txt");

　　注意，如果是使用“\” ，则需要进行转义，写为“\\”才可以

　　绝对路径与相对路径：

　　绝对路径：c：\html\demo.txt

　　相对路径：demo.txt

　　对于UNIX平台，绝对路径名的前缀是"/"。相对路径名没有前缀。

　　对于Windows平台，绝对路径名的前缀由驱动器号和一个":"组成，例"c:\\..."。相对路径没有盘符前缀。

　　相对路径：

　　相对路径是指相对于某位置的路径，是指相对于当前目录。

　　在执行Java程序时，相对路径为执行java命令时当前所在的目录。

1.构造方法

　　【代码演示】

 import java.io.File;
 public class FileDemo {
     public static void main(String[] args) {
         //构造函数File(String pathname)
         File f1=new File("a.txt");
         //将a.txt封装成对象。（注意：既可以封装已存在的对象，也可以封装不存在的对象
         System.out.println(f1);//(注意上面对象封装的是什么就打印什么)

         //构造函数File(String parent,String child)
         String parent="C:\\html\\test";
         String child="demo.txt";
         File f2=new File(parent,child);
         System.out.println(f2);

         //构造函数File(File parent,String child)
         File parent1=new File("c:\\html\\test");
         String child1="java";
         File f3=new File(parent1,child1);
         System.out.println(f3);

         File f4=new File("c:\\html\\test\\demo.txt");
         //由于"c:\\html\\test\\demo.txt"代码不跨平台，在Windows中支持，在linux中却不支持
         //所以建议用separator代替\\
         File f5=new File("c:"+File.separator+"html"+File.separator+"test"+File.separator+"demo.txt");
         System.out.println(f5);
         System.out.println(f4);
     }
 }

2.File对象的常见方法

　　创建：boolean  createNewFile()：在指定位置创建文件，如果是第一次创建，返回ture，如果是第二次创建文件，由于该文件已存在，则不创建文件并返回false。

　　　　　　　　　　　　　　　　　注意这与流对象是不同的，在流对象中创建的文件已存在时，会覆盖已存在的文件。

　　　　　static  File   createTempFile(String prefix,String suffix)：在默认临时文件目录中创建一个空文件。运行时创建，运行完即删除。

　　　　　static  File   createTempFile(String prefix,String suffix,File directory)：重载，在指定目录创建临时文件。

　　　　　boolean  mkdir()：在指定位置创建一级目录（文件夹）。

　　　　　boolean  mkdirs()：在指定位置创建多级目录。

　　　　　

　　删除：boolean  delete()：删除文件或目录，删除成功返回true，删除失败返回false。

　　　　　boolean  deleteOnExit()：该方法实在程序运行完时，删除指定文件。

　　判断：

　　　　　boolean  exists()：判断该文件或目录是否存在，若存在则返回true，不存在则返回false。

　　　　　bollean   isFile()：判断是否为文件。

　　　　　boolean  isDirectory()：判断是否为目录。

　　　　　boolean  isHidden()：判断是否为隐藏文件。

　　　　　boolean  canExecute()：测试该文件是否可执行。

　　　　　boolean  canRead()：测试该文件是否可读。

　  获取：getName()：获取名字

　　　　　length()：获取文件的长度

　　　　　lastModified()：获取文件最后一次修改时间

　　　　　getPath()：获取对象封装时的路径

　　　　　getParent()：获取父目录的路径

　　　　　getAbsoluteFile()：获取绝对路径（以File的形式返回）

　　　　　getAbsolutePath()：获取绝对路径（以String的形式返回）

　　　　　boolean  renameTo(File  dest)：重新命名。

　　　　　eg:  File f1=new File("c:\\test.java");

　　　　　　　File f2=new File("c:\\haha.java");

　　　　　　　f1.renameTo(f2);

//将test文件从f1的位置（c盘中）的移到f2的位置（c盘），并改名为f2的名（haha.txt)

　　　　　eg:  File f1=new File("c:\\test.java");

　　　　　　　File f2=new File("d:\\haha.java");

　　　　　　　f1.renameTo(f2);

　　　　　　 //将test文件从f1的位置（c盘中）的移到f2的位置（D盘），并改名为f2的名（haha.txt)

　　　　　　

           

　　【代码演示】File对象的常用方法。

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

 public class FileFuntionDemo {
     public static void main(String[] args) throws IOException {
         String parent="C:\\html\\test";
         String child="funtion.txt";
         File f=new File(parent,child);
         System.out.println(f);

         System.out.println("第一次创建文件:"+f.createNewFile());
         //此次为第一次创建文件，则返回true
         System.out.println("第二次创建文件:"+f.createNewFile());
         //此次为第二次创建文件，由于该文件已存在，则不创建文件并返回false。
         // 注意这与流对象是不同的，在流对象中创建的文件已存在时，会覆盖已存在的文件。（覆盖的原理是删除已有的，创建新的）
         /**
          *    f.mkdir();//创建目录
          *    f.mkdirs();//创建多级目录
          *    要注意：创建的是文件还是目录是由创建方法决定的。
          *    即使封装的对象是"funtion.txt"，但只要使用的是mkdir()方法，创建出来的就是目录。
          *
           */

         //System.out.println("删除文件:"+f.delete());
         /**
          * 这个删除是有缺陷的，当前面代码出现异常时，执行不到这句时，就会造成文件删除失败
          * 即使放在try语句的finally中，也是无法执行成功的，因为文件在运行过程中是不允许删除的
          * 所以就出现了：deleteOnExit(),该方法是在程序运行完时，删除指定文件。
          */
         System.out.println("获取名字："+f.getName());
         System.out.println("获取文件长度："+f.length());
         System.out.println("获取文件最后一次修改的时间："+f.lastModified());
         System.out.println("获取文件对象路径："+f.getPath());//传进来什么打印什么
         System.out.println("获取父目录的路径："+f.getParent());//该方法返回的是绝对路径中的父目录，如果获取的是相对路径，则返回null
         System.out.println("获取目录的绝对路径："+f.getAbsolutePath());//绝对路径，即使文件不存在
         System.out.println("判断文件是否存在："+f.exists());//注意在判断该文件对象是文件还是目录时，要先判断其是否存在。
         System.out.println("判断文件是否为文件："+f.isFile());
         System.out.println("判断文件是否为目录："+f.isDirectory());
         System.out.println("判断文件是否为隐藏文件："+f.isHidden());
         System.out.println("判断文件是否可执行："+f.canExecute());
         System.out.println("判断文件是否可读："+f.canRead());

     }
 } 

 运行结果：

　　【代码演示】list()方法，listFiles()方法和list(FilenameFilter  filter)方法的区别。

 import java.io.File;
 import java.io.FilenameFilter;
 public class FileDemo2 {
     public static void main(String[] args) {
         File f=new File("c:\\html\\test");
         //调用list()方法的File对象必须是封装了一个目录，且该目录还必须存在。否则会报空指针异常。
         String[] names=f.list();//返回的是指定目录下的所有文件或目录（以相对路径的形式）
         for (String name:names) {
             System.out.println(name);
         }
         File[] fname=f.listFiles();//返回的是指定目录下的所有文件或目录（以File对象的形式：绝对路径）
         for(File  name:fname){
　　　　　　　　　System.out.println(name);
　　　　　　　}
         FilenameFilter filter=new FilenameFilter() {
             @Override
             public boolean accept(File dir, String name) {
                 /**
                  * dir指的是该File对象封装的目录，name指的是遍历的File对象封装的目录下的各个子目录（可能是文件，也可能是目录）
                  */
                 return name.contains("n.txt");//返回文件中包含“n.txt”字段的文件
             }
         };
         String[] spname=f.list(filter);  //该方法具有过滤功能，返回的是符合accept方法中的条件的文件。
         for (String  name:spname) {
             System.out.println(name);
         }
     }
 }

运行结果：

　　【代码演示】打印出指定目录下的所有文件，包括所有子目录。

 import java.io.File;
 import java.util.Scanner;

 public class digun {
     public static void main(String[] args) {
         Scanner in=new Scanner(System.in);
         System.out.println("请指定目录：");
         String name=in.nextLine();
         File file=new File(name);
         showAllDir(file);
     }
     public static void showAllDir(File file){
         System.out.println(file);
         File[]  filesname=file.listFiles();
         for (File name:filesname) {
             if (name.isDirectory()){
                 showAllDir(name);
             }else {
                 System.out.println(name);
             }
         }
         return;
     }
 }

运行结果：

    【代码演示】打印出指定目录下的所有符合条件的文件或目录，包括所有子目录中的。

 import java.io.File;
 import java.util.ArrayList;
 import java.util.Scanner;

 public class digun {
     static  ArrayList arrayList=new ArrayList();
     static String ff;
     public static void main(String[] args) {
         Scanner in=new Scanner(System.in);
         System.out.println("请指定目录：");
         String name=in.nextLine();
         System.out.println("过滤条件：");
         ff=in.nextLine();
         File file=new File(name);
         showAllDir(file);
         for (int i = 0; i <arrayList.size() ; i++) {
             System.out.println(arrayList.get(i));
         }
     }
     public static void showAllDir(File file){
         File[]  filesname=file.listFiles();
         for (File name:filesname) {
             if(name.getName().contains(ff)){
                 arrayList.add(name);
             }
             if (name.isDirectory()){
                 showAllDir(name);
             }
         }
         return;
     }
 }

　　运行结果：

   【代码演示】以树状的形式打印出指定目录下的文件。

 import java.io.File;
 import java.util.Scanner;

 public class TreeDirectory {
     public static void main(String[] args) {
         Scanner in=new Scanner(System.in);
         System.out.println("请输入指定的目录：");
         String filename=in.nextLine();
         File file=new File(filename);
         showTreeDir(0,file);
     }

     public static String level(int level){  //根据层级数，打印该层的前缀
         StringBuilder sb=new StringBuilder();
         for (int i=0;i<level;i++){
             sb.append("\t");
         }
         sb.append("|---");
         return sb.toString();
     }
     public static void showTreeDir(int level,File  file){
         level++;  //先将上级目录的层级数加一，变成此目录的层级数
         System.out.println(level(level)+file.getName());//然后将调用该方法的层目录打印出来
         File[] names=file.listFiles();//将该层目录下的子目录或文件返回来，存储到names数组中
         for (int i = 0; i <names.length ; i++) {   //对各个子目录进行遍历
             if (names[i].isDirectory()){  //如果是目录，则继续调用showTreeDir方法，并将此层目录的层级数传递给子目录
                 showTreeDir(level,names[i]);
             }else {//如果是文件，则将文件名打印出来
                 System.out.println(level(level+1)+names[i].getName());
             }
         }
     }
 }
    

　　运行结果：

【代码演示】如何删除一个带内容的目录。

 import java.io.File;
 import java.util.Scanner;

 public class FileDelete {
     public static void main(String[] args) {
         Scanner in=new Scanner(System.in);
         System.out.println("请输入所要删除的目录：");
         String filename=in.nextLine();
         File file=new File(filename);
         removeDir(file);
     }
     public static void removeDir(File file){
         File[] subfiles=file.listFiles();
         //此方法返回的是该层目录的子目录，如果存在子目录，则将子目录存放在一个数组中，然后返回数组的引用，如果不存在子目录，则返回null
         if (subfiles==null){   //当数组为空时，说明不存在子目录，则直接删除此目录。
          //所以此处判断数组是否为空时，应用subfiles==null来判断，如果用subfiles.length==0判断会报空指针异常
             System.out.println(file.delete());
         }else { //当数组不为空时，说明存在子目录，则应该先删除子目录。
             for (int i = 0; i <subfiles.length ; i++) {
                 removeDir(subfiles[i]);
             }
             System.out.println(file.delete());//所有子目录删除后，再将此目录删除
         }
     }
 }

　　注意：Java删除不经过回收站。