javase_15(File类的应用)

File类:
用来将文件或者文件夹封装成对象
方便对文件或者文件夹的操作
File对象可以作为参数传递给一个流.
递归:
函数自己调用自己
应用场景:
当某一个功能需要重复调用..
1.遍历一个文件,并且让让这个文件写入到一个文本里面,(需要树状的排序)

 

package com.javami.kudy.CodeAM;
 import java.io.BufferedWriter;
 import java.io.IOException;
 import java.io.File;
 /*
  * getSpace
  * listAllFiles
  */
 public class FileList {
     public static void main(String[]args)
     {
         File file = new File("F:/test");
         BufferedWriter bw = null;
         int val = 0; //默认为零
         listAllFiles(file,val);
     }
 
     /*
      *遍历出所有文件夹和文件,用到ListFiles()
      *2.利用增强for遍历所有的目录下的文件和文件夹()
      *3.输出文件的绝对路径
      *4.如果是目录的,咱们就递归
      *
      *
      */
     private static void listAllFiles(File dir,int val)    
     {    
         File[] files = dir.listFiles();
         for(File file : files)
         {
             System.out.println(getSpace(val)+file.getAbsolutePath());
             if(file.isDirectory())//当你迭代到没有目录的时候,就结束.
             {
                 listAllFiles(file,val+1);  //首先从这里边标记一下+多少个
             }
         }
     }
 
     private static String getSpace(int val)
     {
         String line = "-|"; 
         for(int i=0; i<val; i++)
         {
             line+="-";
         }
         return line;
     }
 }

 

2.删除一个目录(利用递归实现)

package com.javami.kudy.CodeAM;
 import java.io.File;
 public class DeleteDirTest {
     /*
      * 删除一个目录
      * (注意: 首先要把里面的文件删除才可以删除一个目录)
      * delete(删除抽象路径名表示的目录或者文件)
      * 思路: 
      * 首先判断如果是否是目录(递归,利用listFiles是一个抽象的文件路径),如果不是目录.就直接删除.
      */
     public static void main(String[]args)
     {
         File f = new File("F:/复件 复件 a"); 
         deleteDir(f);
     }
 
     private static void deleteDir(File f)
     {
         if(f.isDirectory()) //判断是否是一个目录  //递归完是会出来的
         {
             File [] files = f.listFiles(); //如果是目录,递归/找里面的目录执行重复一个过程
             for(File file : files)  //   a / b / cc    a / b
             {
                 deleteDir(file); //递归最终都是会走出来的
             }
         }
         f.delete(); //我不管你是目录还是什么.都给我删除
     }
     }

 

3.指定一个目录,把java文件写入到一个文本里面去.  集合 写入..

package com.javami.kudy.CodeAM;
 
 import java.io.BufferedReader;
 import java.io.BufferedWriter;
 import java.io.File;
 import java.io.FileWriter;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.util.ArrayList;
 public class javaFileList {
     private static int val;
 
 
     /*
      * 指定一个目录,把java文件写入到一个文本里面去.  
      * 必须要利用过滤器功能去实现
      * 要实现一个规范化
      * 
      * 总结: 注意流的写法,如果写流的,必须要在外面正确创建,才可以正确关闭流.
      * 要不然刷新不了 - - !懂了..有收获了...
      */
     public static void main(String[]args)
     {
         ArrayList<File> al = new ArrayList<File>();
         BufferedReader br = null;
         BufferedWriter bw = null;
         int val = 0;
         try
         {
             br = new BufferedReader(new InputStreamReader(System.in));
             bw = new BufferedWriter(new FileWriter("src/369.txt"));
             javaArrList(getDir(br),al,val);
             listFilePath(al,bw);
         }
         catch(IOException e)
         {
             e.printStackTrace();
         }
         finally
         {
             try
             {
                 CloseUtil.close(br, bw);
             }
             catch(IOException e)
             {
                 e.printStackTrace();
             }
         }
         
     }
     
 
     /*
      * 1.树形结构
      */
     private static String getSpack(int val) {
         String spack = "-|";
         for(int i=0 ;i<val; i++)
         {
             spack+="-";
         }
         return spack;
     }
     
     /*
      * 2.请用户输入一个路径
      */
     private static File getDir(BufferedReader br) throws IOException
     {
                     
         String dir = null;
         System.out.println("请输入一个目录:");
         while(true)
         {
             dir = br.readLine(); //读取
             /*
              * 判断它是否是一个目录, 判断这个文件夹是否存在
             */
             File file = new File(dir); //封装一个路径
             if(!file.exists())
             {
                 System.out.println("该文件不存在,请重新输入");
                 continue;
             }
             if(!file.isAbsolute())
             {
                 System.out.println("不是一个目录,请重新输入:");
                 continue;
             }
             break;
         }
         return new File(dir);
     }
     
     /*
      *第三: 把递归到的java文件保存到集合里面
      */
     private static void javaArrList(File dir, ArrayList<File> al,int val)
     {
         File[] files = dir.listFiles();
         if(files ==null)
             return ;        
         for(File file : files)
         {
             if(file.isDirectory()) //如果是一个目录.咱们要递归它
                 javaArrList(file, al,val+1);
             else if(file.getName().endsWith(".java"))
             {
                 al.add(file);
             }//如果里面的目录名是以java为结尾的  就把它放到集合里面去
         }
         
     }
     /*
      * 第四.把集合写入到一个文件里面
      */
     private static void listFilePath(ArrayList<File> al,BufferedWriter bw)  throws IOException{ 
         
         for(File f : al)
         {
              bw.write(getSpack(val)+f.getAbsolutePath());
              bw.newLine();
             // bw.flush();
         }
     }
 
 
 }

 

4.指定一个目录,使其删除:

package com.javami.kudy.CodeAM;
 import java.io.BufferedReader;
 import java.io.File;
 import java.io.IOException;
 import java.io.InputStreamReader;
 public class DeleteDirTest {
     public static void main(String[]args)
     {
         /*
          * 请输入一个目录,把目录里面的内容删除
          * (空文件才可以删除目录)
          */
         BufferedReader br = null;
         try
         {
             br = 
                 new BufferedReader(new InputStreamReader(System.in));
             deleteDir(getDir(br)); //删除一个目录
         }catch(IOException e)
         {
             e.printStackTrace();
         }
         finally
         {
             try
             {
                 br.close();
             }catch(IOException e)
             {
                 e.printStackTrace();
             }
         }
     }
 
     /*
      * 1.生成一个目录
      */
     private static File getDir(BufferedReader br)throws IOException {
         String dir = null;
         System.out.println("请输入一个目录:");
         while(true)
         {
             dir = br.readLine();
             File file = new File(dir);
             if(!file.exists()){//判断该文件是否存在
                 System.out.println("该文件不存在,请重新输入:");
                 continue;
             }
             if(!file.isDirectory()){
                 System.out.println("该目录不存在.请重新输入:");
                 continue;
             }
             break;
         }
         System.out.println("目录已经成功创建");
         return new File(dir);
     }
     /*
      * 2.删除一个目录
      */
     private static void deleteDir(File dir) {    
         if(dir.isDirectory())  //首先判断是否是目录
         {
             File[] files = dir.listFiles();  //把目录放到数组里面去
             for(File file : files) //遍历里面 的内容
             {
                 deleteDir(file); //如果是目录就递归  ,递归完毕最终会返回到跟目录
             }
         }
         dir.delete(); //这一步每次递归都会执行删除一次..
 
         
     }
     }

 

5.拷贝一个目录:

package com.javami.kudy.CodeAM;
 import java.io.BufferedInputStream;
 import java.io.BufferedOutputStream;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;
 public class CopyDir {
     public static void main(String[]args)
     {
         /*
          * 拷贝一个目录
          * 1.首先要判断是否是标准文件或者是一个目录
          * 如果是    在目标目录下创建一个同名的目录
          *         遍历目录,递归,将目录下的所有文件拷贝至新创建的目录
          * 如果是标准文件,在目标目录下创建同名文件,通过IO流来进行拷贝.
          */
         File a = new File("F:/a");
         File b = new File("F:/b");
         try
         {
             copyDir(a, b);
         }catch(IOException e)
         {
             e.printStackTrace();
         }
     }
 
     private static void copyDir(File a, File b)throws IOException {
         if(a.isDirectory())  //判断是否是一个目录
         {
             //如果是目录,封装新目录的路径
             File newDir = new File(b,a.getName());
             //创建一个新目录
             newDir.mkdir();
             File[] files = a.listFiles(); //里面的路径
             for(File file : files)
             {
                 copyDir(file, newDir);
             }
         }else //这里面的只有文件
         {
             File newFile = new File(b,a.getName()); //如果没有这个文件.以下语句会创建一个空文件
             newFile.createNewFile(); //如果没有这个路径,则创建的意思.名字以上
             //把a目录下面的文件写入到b目录下面来
             copyFile(a,newFile);  //a里面代表的是一个文件  newFile也是代表一个文件(等待写入数据的)
         }
     }
     
     /*
      * 把a里面的文件复制到f里面去
      * 
      */
     private static void copyFile(File a, File f) throws IOException
     {
         BufferedInputStream bis = null;
         BufferedOutputStream bos = null;
         try
         {
             //其实a里面封装的假设是: f:a/1.txt 注意类型的关系(file文件可以直接仍进去.)
             //不能写成"a"这样就是放了一个a路径进去啦
             //
             bis =
                 new BufferedInputStream(new FileInputStream(a));//代表是a是一个文件
             bos = 
                 new BufferedOutputStream(new FileOutputStream(f)); //代表是一个同名的a文件,只不过是空的
             int ch;
             while((ch=bis.read())!=-1)
             {
                 bos.write(ch);
             }
         }finally
         {
             try
             {
                 if(bis!=null)
                     bis.close();
             }
             finally
             {
                 if(bos!=null)
                     bos.close();
             }
         }
     }
     
 }
 遍历指定目录下的所有java文件,拷贝到F盘下指定的一个目录下.    如果是为java结尾的文件.咱们要把它的名字更改成jdk
 
 package com.javami.kudy.CodeAM;
 import java.io.BufferedReader;
 import java.io.BufferedWriter;
 import java.io.File;
 import java.io.FileReader;
 import java.io.FileWriter;
 import java.io.IOException;
 import java.io.InputStreamReader;
 public class JavaFileCopy {
     public static void main(String[]args)
     {
         try
         {
             listJAVAFile(getDir());
         }
         catch(IOException e)
         {
             e.printStackTrace();
         }
     }
     
 
     /*
      * 1.获取到一个目录
      */
     private static File getDir()throws IOException
     {
         BufferedReader br = 
                     new BufferedReader(new InputStreamReader(System.in));
         String dir = null;
         System.out.println("请输入一个目录:");
         while(true)
         {
             dir = br.readLine();
             File file = new File(dir); //封装一个这个路径
             if(!file.exists())
             {
                 System.out.println("该文件不存在!请重新输入:");
                 continue;
             }
             if(!file.isDirectory())
             {
                 System.out.println("该目录不存在,请重新输入:");
                 continue;
             }
             break;
         }
         return new File(dir);
     }

 

6.遍历指定目录下的所有java文件,拷贝到F盘下指定的一个目录下. 如果是为java结尾的文件.咱们要把它的名字更改成jdk

package com.javami.kudy.CodeAM;
 import java.io.BufferedReader;
 import java.io.BufferedWriter;
 import java.io.File;
 import java.io.FileReader;
 import java.io.FileWriter;
 import java.io.IOException;
 import java.io.InputStreamReader;
 public class JavaFileCopy {
     public static void main(String[]args)
     {
         try
         {
             listJAVAFile(getDir());
         }
         catch(IOException e)
         {
             e.printStackTrace();
         }
     }
     
 
     /*
      * 1.获取到一个目录
      */
     private static File getDir()throws IOException
     {
         BufferedReader br = 
                     new BufferedReader(new InputStreamReader(System.in));
         String dir = null;
         System.out.println("请输入一个目录:");
         while(true)
         {
             dir = br.readLine();
             File file = new File(dir); //封装一个这个路径
             if(!file.exists())
             {
                 System.out.println("该文件不存在!请重新输入:");
                 continue;
             }
             if(!file.isDirectory())
             {
                 System.out.println("该目录不存在,请重新输入:");
                 continue;
             }
             break;
         }
         return new File(dir);
     }
     /*
      * 遍历所有目录下的java文件.
      */
     private static void listJAVAFile(File dir)throws IOException
     {
         File[] files = dir.listFiles();
         
         for(File file : files)
         {
             //如果是目录,就递归.
             if(file.isDirectory()) //判断是否是目录
             {
                 listJAVAFile(file);
             }
             //如果是文件.并且是java为结尾的文件.获取文件名,替换文件名,创建新文件
             else if(file.getName().endsWith(".java")); //获取这个文件名
             {
                 //获取到一个文件名 
                 String fileName = file.getName();
                 //把文件名修改成jdk 
                 String newFileName = fileName.replaceAll(".java$", ".jdk");
                 //从 f:/dj目录下创建文件
                 File newFile = new File("f:/dj",newFileName);  //XX.jdk
                 newFile.createNewFile(); //如果这个路径不存在.存在一个与之同名的文件  //**.jdk结果
                 copyfile(file,newFile);
                 //file:是一个java文件  而newFile文件是一个为jdk为结果的文件
             }
         }
     }
 
 
     private static void copyfile(File file, File newFile)throws IOException
     {
         BufferedReader br = null;
         BufferedWriter bw = null;
         try
         {
             br = new BufferedReader(new FileReader(file));//file代表的是一个java的路径
             bw = new BufferedWriter(new FileWriter(newFile));//是一个jdk的file文件的复制品
             String line = null;
             while((line=br.readLine())!=null)
             {
                 bw.write(line);
                 bw.newLine();
             }
         }finally
         {
             try
             {
                 CloseUtil.close(br, bw);
             }catch(IOException e)
             {
                 e.printStackTrace();
             }
         }
     }
 }

 

这次学习个人的心得总结:
在这个关闭一个流上面有所收获.第二: 必须要正确的了解递归,这个其实不难- >但要想从一个深入的角度去理解,应用.还是需要多加复习与锻炼的,递归最主要的目前对于我个人了解:
判断是否是一个目录,判断是否是一个文件夹  .  递归 : a --> b --> c它最终会返回最高处的那个目录.
这里面写一个简单的递归.

package com.javami.kudy.CodeAM;
 
 import java.io.File;
 
 public class Test {
     public static void main(String[]args)
     {
         /*
          * 简单的递归
          */
         File file = new File("F:/a");
         listArr(file);
 
     }
     public static void listArr(File file)
     {
         File[]files = file.listFiles();
         for(File f : files)
         {
             //判断是否是一个目录
             if(f.isDirectory())
             {
                 listArr(f);//注意递归
             }
             System.out.println(f.getAbsolutePath()); //如果不是目录.就输出
         }
     }
 }