Java基础--IO流之File类-CSDN博客

本文链接：https://blog.csdn.net/q549130180/article/details/45333425

凌风博客原创作品。转载请注明出处：http://blog.csdn.net/q549130180/article/details/45333425

File类常见方法

1.创建
boolean createNewFile(); 在指定位置创建文件，如果该文件已经存在，则不创建，返回false
和输出流不一样，输出流对象一建立就会创建文件，而且文件已经存在，会覆盖

boolean mkdir(); 创建文件夹，只能创建一级文件夹
boolean nkdirs(); 创建多级文件夹

2.删除
boolean delete(); 删除失败返回false
void deleteOnExit(); 在程序退出时删除指定文件。

3.判断
boolean exists(); 文件是否存在
isFile(); 判断此路径下是否是一个文件
isDirEctory(); 判断此路径下是否是一个文件夹
isHidden(); 判断此路径下是否是一个隐藏文件
isAbsolute(); 判断此抽象路径名是否为绝对路径名

4.获取信息
getName();
getPath();
getParent(); 获取父目录

getAbsolutePath() 获取绝对路径
long lastModified(); 返回此抽象路径名表示的文件最后一次被修改的时间。

long length();

[java]view plaincopy 
   
 class FileDemo19  
 {  
     public static void main(String[] args) throws IOException  
     {  
         method_2();  
     }  
   
     public static void method_5()  
     {  
         File f1 = new File("c:\\Test.java");  
         File f1 = new File("d:\\haha.java");  
   
         sop("rename"+f1.renameTo(f2));  //相当于剪切，并重命名  
     }  
   
     //获取信息  
     public static void method_4()  
     {  
         File f = new File("file.txt");  
   
         sop("path:"+f.getPath());  
         sop("Abspath:"+f.getAbsolutePath()); //即使文件不存在，也可以获取其路径  
         sop("parent:"+f.getParent());  //该方法返回的是绝对路径中的父目录，如果获取的是相对路径，则返回null  
                                         //如果相对路径中有上一层目录那么该目录就是返回结果。  
   
     }  
   
     //判断  
     public static void method_3() throws IOException  
     {  
         File f = new File("file.txt");  
   
         //f.createNewFile();  
   
         f.mkdir();  
   
         //记住在判断文件对象是否是文件或者目的时，必须要先判断该文件对象封装的内容是否存在。  
         //通过exists判断  
         sop("dir:"+f.isDirectory());  
         sop("file:"+f.isFile());  
   
         sop(f.isAbsolute());//判断此抽象路径名是否为绝对路径名  
     }  
   
   
     //判断  
     public static void method_2()  
     {  
         File f = new File("file.txt");  
   
         //sop("exists:"+f.exists());//判断文件是否存在  
         //sop("execute:"+f.canExecute()); //判断是否为可运行文件  
   
   
         //创建文件夹  
         File dir = new File("abc\\ddd\\ccfg\\ew\\aws\\sdf");  
   
         sop("mkdir:"+dir.mkdirs());  
   
   
     }  
       
   
   
   
     //创建和删除的演示  
     public static void method_1()  
     {  
         File f =new File("file.txt");  
   
         f.deleteOnExit();//在虚拟机退出时，将文件删除  
           
         //System.out.println("create:"+f.createNewFile());  //创建文件  
         System.out.println("delete"+f.delete());  
   
     }  
   
   
       
     //创建File对象  
     public static void consMethod() throws IOException  
     {  
         //将a.txt封装成file对象，可以将已有的和未出现的文件或者文件夹封装成对象  
         File f1 = new File("a.txt");  
   
         //"c:\\abc" 代表文件夹父目录，b.txt代表文件  
         File f2 = new File("c:\\abc","b.txt");  
   
         File d = new File("c:\\abc");  
         File f3 = new File(d,"c.txt");  
   
         System.out.println("f1"+f1);  
         System.out.println("f2"+f2);  
         System.out.println("f3"+f3);  
           
         //File.separator实现跨平台的分隔符  
         File f4 = new File("c:"+File.separator+"abc"+File.separator+"zzz"+File.separator+"a.txt");  
     }  
     public static void sop(Object obj)  
     {  
         System.out.println(obj);  
     }  
 }  

[java]view plaincopy 
   
 import java.io.*;  
 class FileDemo19_2   
 {  
     public static void main(String[] args)   
     {  
         listDemo2();  
     }  
   
   
     //listFiles获取的是文件对象  
     public static void listFilesDemo()  
     {  
         File dir new File("c:\\");  
   
         File[] files = dir.listFiles();  
   
         for(File f : files)  
         {  
             System.out.println(f.getName()+":::"+f.length());  
         }  
     }  
       
     //带参数的list  
     public static void listDemo2()  
     {  
         File dir = new File("G:\\Java Test\\IO流");  
         String[] arr = dir.list(new FilenameFilter()  
         {  
             public boolean accept(File dir,String name)  
             {  
                 //System.out.println("dir:"+dir+"....name:"+name);  
                 /* 
                 if(name.endsWith(".bmp") 
                     return true; 
                 else 
                     return false; 
                 */  
   
                 return name.endsWith(".java");  
   
             }  
         });  
   
         System.out.println("len:"+arr.length);  
         for(String name : arr)  
         {  
             System.out.println(name);  
         }  
     }  
       
     //返回某一目录下的所有文件和文件夹信息  
     public static void listDemo()  
     {  
         File f = new File("d:\\");  
   
         String[] names = f.list();   //调用list方法的file对象必须是封装了一个目录，该目录还必须存在  
         for(String name : names)  
         {  
             System.out.println(name);  
         }  
     }  
   
     //返回系统下所有的盘符信息  
     public static void listRootsDemo()  
     {  
         File[] files = File.listRoots();  
   
         for(File f : files)  
         {  
             System.out.println(f);  
         }  
     }  
 }  

列出指定目录下文件或者文件夹，包含子目录中的内容
也就是列出指定目录下所有内容

因为目录中还有目录，只要使用同一个列出目录功能的函数完成即可
在列出工程中出现的还是目录的话，还可以再次调用本功能
也就是函数自身调用自身
这种表现形式，或者编程手法，称为递归

递归要注意：
1.限定条件
2.要注意递归的次数，尽量避免内存溢出

[java]view plaincopy 
   
 import java.io.*;  
 class FileDemo19_3   
 {  
     public static void main(String[] args)   
     {  
         File dir = new File("G:\\Java Test");  
         showDir(dir,0);  
     }  
   
     //实现带层级的目录  
     public static String getLevel(int level)  
     {  
         StringBuilder sb = new StringBuilder();  
   
         sb.append("|--");  
         for (int x = 0;x<level ;x++ )  
         {  
             //sb.append("|--");  
             sb.insert(0,"   ");  
         }  
         return sb.toString();  
     }  
       
     //列出指定目录下文件或者文件夹，包含子目录中的内容  
     public static void showDir(File dir,int level)  
     {  
         System.out.println(getLevel(level)+dir.getName());  
   
         level++;  
         File[] files = dir.listFiles();  
         for (int x = 0;x<files.length ;x++ )  
         {  
             if(files[x].isDirectory())  
                 showDir(files[x],level);  
             else  
                 System.out.println(getLevel(level)+files[x]);  
         }  
     }  
 }  

删除原理：
在windows中，删除目录从里面往外删除的

既然是从里往外删除，就需要用到递归

[java]view plaincopy 
   
 import java.io.*;  
 class RemoveDir20  
 {  
     public static void main(String[] args)   
     {  
         File dir = new File("d:\\test");  
         removeDir(dir);  
     }  
     public static void removeDir(File dir)  
     {  
         File[] files = dir.listFiles();  
   
         for (int x = 0;x<files.length ;x++ )  
         {  
             if(files[x].isDirectory())  
                 removeDir(files[x]);  
             else  
                 System.out.println(files[x].toString()+":-file-:"+files[x].delete());  
         }  
         System.out.println(dir+"::dir::"+dir.delete());  
     }  
 }  

练习：
将一个指定目录下的java文件的绝对路径，存储到一个文本文件中

思路：
1.对指定的目录进行递归
2.获取递归过程所有的java文件的路径
3.将这些路径存储到集合中
4.将集合中的数据写入到一个文件中

[java]view plaincopy 
   
 import java.io.*;  
 import java.util.*;  
 class JavaFileList21   
 {  
     public static void main(String[] args) throws IOException  
     {  
         File dir = new File("G:\\Java Test");  
   
         List<File> list = new ArrayList<File>();  
   
         fileToList(dir,list);  
   
         File file = new File(dir,"javalist.txt");  
   
         writerToFile(list,file.toString());  
     }  
     //递归取出所有对象，存入到List中  
     public static void fileToList(File dir,List<File> list)  
     {  
         File[] files = dir.listFiles();  
   
         for (File file : files )  
         {  
             if(file.isDirectory())  
                 fileToList(file,list);  
             else  
             {  
                 if(file.getName().endsWith(".java"))//过滤.java文件  
                     list.add(file);  
             }  
         }  
     }  
       
     //将List集合中的对象信息取出，写入到文件中  
     public static void writerToFile(List<File> list,String javaListFile) throws IOException  
     {  
         BufferedWriter bufw = null;  
         try  
         {  
             bufw = new BufferedWriter(new FileWriter(javaListFile));  
             for(File f : list)  
             {  
                 String path = f.getAbsolutePath();  
                 bufw.write(path);  
                 bufw.newLine();  
                 bufw.flush();  
   
             }  
         }  
         catch (Exception e)  
         {  
             throw e;  
         }  
         finally  
         {  
             try  
             {  
                 if(bufw!=null)  
                     bufw.close();  
             }  
             catch (Exception e)  
             {  
                 throw e;  
             }  
         }  
     }  
 }  