javase_15(File类的应用)

最新推荐文章于 2023-06-14 10:22:28 发布

转载最新推荐文章于 2023-06-14 10:22:28 发布 · 105 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/woxin/archive/2012/08/11/2634092.html

本文介绍如何使用Java进行文件和目录的基本操作，包括遍历文件、删除目录、拷贝文件等，并详细展示了递归的应用场景及具体实现。

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

 1 package com.javami.kudy.CodeAM;
 2 import java.io.BufferedWriter;
 3 import java.io.IOException;
 4 import java.io.File;
 5 /*
 6  * getSpace
 7  * listAllFiles
 8  */
 9 public class FileList {
10     public static void main(String[]args)
11     {
12         File file = new File("F:/test");
13         BufferedWriter bw = null;
14         int val = 0; //默认为零
15         listAllFiles(file,val);
16     }
17 
18     /*
19      *遍历出所有文件夹和文件,用到ListFiles()
20      *2.利用增强for遍历所有的目录下的文件和文件夹()
21      *3.输出文件的绝对路径
22      *4.如果是目录的,咱们就递归
23      *
24      *
25      */
26     private static void listAllFiles(File dir,int val)    
27     {    
28         File[] files = dir.listFiles();
29         for(File file : files)
30         {
31             System.out.println(getSpace(val)+file.getAbsolutePath());
32             if(file.isDirectory())//当你迭代到没有目录的时候,就结束.
33             {
34                 listAllFiles(file,val+1);  //首先从这里边标记一下+多少个
35             }
36         }
37     }
38 
39     private static String getSpace(int val)
40     {
41         String line = "-|"; 
42         for(int i=0; i<val; i++)
43         {
44             line+="-";
45         }
46         return line;
47     }
48 }

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

 1 package com.javami.kudy.CodeAM;
 2 import java.io.File;
 3 public class DeleteDirTest {
 4     /*
 5      * 删除一个目录
 6      * (注意: 首先要把里面的文件删除才可以删除一个目录)
 7      * delete(删除抽象路径名表示的目录或者文件)
 8      * 思路: 
 9      * 首先判断如果是否是目录(递归,利用listFiles是一个抽象的文件路径),如果不是目录.就直接删除.
10      */
11     public static void main(String[]args)
12     {
13         File f = new File("F:/复件 复件 a"); 
14         deleteDir(f);
15     }
16 
17     private static void deleteDir(File f)
18     {
19         if(f.isDirectory()) //判断是否是一个目录  //递归完是会出来的
20         {
21             File [] files = f.listFiles(); //如果是目录,递归/找里面的目录执行重复一个过程
22             for(File file : files)  //   a / b / cc    a / b
23             {
24                 deleteDir(file); //递归最终都是会走出来的
25             }
26         }
27         f.delete(); //我不管你是目录还是什么.都给我删除
28     }
29     }

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

  1 package com.javami.kudy.CodeAM;
  2 
  3 import java.io.BufferedReader;
  4 import java.io.BufferedWriter;
  5 import java.io.File;
  6 import java.io.FileWriter;
  7 import java.io.IOException;
  8 import java.io.InputStreamReader;
  9 import java.util.ArrayList;
 10 public class javaFileList {
 11     private static int val;
 12 
 13 
 14     /*
 15      * 指定一个目录,把java文件写入到一个文本里面去.  
 16      * 必须要利用过滤器功能去实现
 17      * 要实现一个规范化
 18      * 
 19      * 总结: 注意流的写法,如果写流的,必须要在外面正确创建,才可以正确关闭流.
 20      * 要不然刷新不了 - - !懂了..有收获了...
 21      */
 22     public static void main(String[]args)
 23     {
 24         ArrayList<File> al = new ArrayList<File>();
 25         BufferedReader br = null;
 26         BufferedWriter bw = null;
 27         int val = 0;
 28         try
 29         {
 30             br = new BufferedReader(new InputStreamReader(System.in));
 31             bw = new BufferedWriter(new FileWriter("src/369.txt"));
 32             javaArrList(getDir(br),al,val);
 33             listFilePath(al,bw);
 34         }
 35         catch(IOException e)
 36         {
 37             e.printStackTrace();
 38         }
 39         finally
 40         {
 41             try
 42             {
 43                 CloseUtil.close(br, bw);
 44             }
 45             catch(IOException e)
 46             {
 47                 e.printStackTrace();
 48             }
 49         }
 50         
 51     }
 52     
 53 
 54     /*
 55      * 1.树形结构
 56      */
 57     private static String getSpack(int val) {
 58         String spack = "-|";
 59         for(int i=0 ;i<val; i++)
 60         {
 61             spack+="-";
 62         }
 63         return spack;
 64     }
 65     
 66     /*
 67      * 2.请用户输入一个路径
 68      */
 69     private static File getDir(BufferedReader br) throws IOException
 70     {
 71                     
 72         String dir = null;
 73         System.out.println("请输入一个目录:");
 74         while(true)
 75         {
 76             dir = br.readLine(); //读取
 77             /*
 78              * 判断它是否是一个目录, 判断这个文件夹是否存在
 79             */
 80             File file = new File(dir); //封装一个路径
 81             if(!file.exists())
 82             {
 83                 System.out.println("该文件不存在,请重新输入");
 84                 continue;
 85             }
 86             if(!file.isAbsolute())
 87             {
 88                 System.out.println("不是一个目录,请重新输入:");
 89                 continue;
 90             }
 91             break;
 92         }
 93         return new File(dir);
 94     }
 95     
 96     /*
 97      *第三: 把递归到的java文件保存到集合里面
 98      */
 99     private static void javaArrList(File dir, ArrayList<File> al,int val)
100     {
101         File[] files = dir.listFiles();
102         if(files ==null)
103             return ;        
104         for(File file : files)
105         {
106             if(file.isDirectory()) //如果是一个目录.咱们要递归它
107                 javaArrList(file, al,val+1);
108             else if(file.getName().endsWith(".java"))
109             {
110                 al.add(file);
111             }//如果里面的目录名是以java为结尾的  就把它放到集合里面去
112         }
113         
114     }
115     /*
116      * 第四.把集合写入到一个文件里面
117      */
118     private static void listFilePath(ArrayList<File> al,BufferedWriter bw)  throws IOException{ 
119         
120         for(File f : al)
121         {
122              bw.write(getSpack(val)+f.getAbsolutePath());
123              bw.newLine();
124             // bw.flush();
125         }
126     }
127 
128 
129 }

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

 1 package com.javami.kudy.CodeAM;
 2 import java.io.BufferedReader;
 3 import java.io.File;
 4 import java.io.IOException;
 5 import java.io.InputStreamReader;
 6 public class DeleteDirTest {
 7     public static void main(String[]args)
 8     {
 9         /*
10          * 请输入一个目录,把目录里面的内容删除
11          * (空文件才可以删除目录)
12          */
13         BufferedReader br = null;
14         try
15         {
16             br = 
17                 new BufferedReader(new InputStreamReader(System.in));
18             deleteDir(getDir(br)); //删除一个目录
19         }catch(IOException e)
20         {
21             e.printStackTrace();
22         }
23         finally
24         {
25             try
26             {
27                 br.close();
28             }catch(IOException e)
29             {
30                 e.printStackTrace();
31             }
32         }
33     }
34 
35     /*
36      * 1.生成一个目录
37      */
38     private static File getDir(BufferedReader br)throws IOException {
39         String dir = null;
40         System.out.println("请输入一个目录:");
41         while(true)
42         {
43             dir = br.readLine();
44             File file = new File(dir);
45             if(!file.exists()){//判断该文件是否存在
46                 System.out.println("该文件不存在,请重新输入:");
47                 continue;
48             }
49             if(!file.isDirectory()){
50                 System.out.println("该目录不存在.请重新输入:");
51                 continue;
52             }
53             break;
54         }
55         System.out.println("目录已经成功创建");
56         return new File(dir);
57     }
58     /*
59      * 2.删除一个目录
60      */
61     private static void deleteDir(File dir) {    
62         if(dir.isDirectory())  //首先判断是否是目录
63         {
64             File[] files = dir.listFiles();  //把目录放到数组里面去
65             for(File file : files) //遍历里面 的内容
66             {
67                 deleteDir(file); //如果是目录就递归  ,递归完毕最终会返回到跟目录
68             }
69         }
70         dir.delete(); //这一步每次递归都会执行删除一次..
71 
72         
73     }
74     }

5.拷贝一个目录:

  1 package com.javami.kudy.CodeAM;
  2 import java.io.BufferedInputStream;
  3 import java.io.BufferedOutputStream;
  4 import java.io.File;
  5 import java.io.FileInputStream;
  6 import java.io.FileOutputStream;
  7 import java.io.IOException;
  8 public class CopyDir {
  9     public static void main(String[]args)
 10     {
 11         /*
 12          * 拷贝一个目录
 13          * 1.首先要判断是否是标准文件或者是一个目录
 14          * 如果是    在目标目录下创建一个同名的目录
 15          *         遍历目录,递归,将目录下的所有文件拷贝至新创建的目录
 16          * 如果是标准文件,在目标目录下创建同名文件,通过IO流来进行拷贝.
 17          */
 18         File a = new File("F:/a");
 19         File b = new File("F:/b");
 20         try
 21         {
 22             copyDir(a, b);
 23         }catch(IOException e)
 24         {
 25             e.printStackTrace();
 26         }
 27     }
 28 
 29     private static void copyDir(File a, File b)throws IOException {
 30         if(a.isDirectory())  //判断是否是一个目录
 31         {
 32             //如果是目录,封装新目录的路径
 33             File newDir = new File(b,a.getName());
 34             //创建一个新目录
 35             newDir.mkdir();
 36             File[] files = a.listFiles(); //里面的路径
 37             for(File file : files)
 38             {
 39                 copyDir(file, newDir);
 40             }
 41         }else //这里面的只有文件
 42         {
 43             File newFile = new File(b,a.getName()); //如果没有这个文件.以下语句会创建一个空文件
 44             newFile.createNewFile(); //如果没有这个路径,则创建的意思.名字以上
 45             //把a目录下面的文件写入到b目录下面来
 46             copyFile(a,newFile);  //a里面代表的是一个文件  newFile也是代表一个文件(等待写入数据的)
 47         }
 48     }
 49     
 50     /*
 51      * 把a里面的文件复制到f里面去
 52      * 
 53      */
 54     private static void copyFile(File a, File f) throws IOException
 55     {
 56         BufferedInputStream bis = null;
 57         BufferedOutputStream bos = null;
 58         try
 59         {
 60             //其实a里面封装的假设是: f:a/1.txt 注意类型的关系(file文件可以直接仍进去.)
 61             //不能写成"a"这样就是放了一个a路径进去啦
 62             //
 63             bis =
 64                 new BufferedInputStream(new FileInputStream(a));//代表是a是一个文件
 65             bos = 
 66                 new BufferedOutputStream(new FileOutputStream(f)); //代表是一个同名的a文件,只不过是空的
 67             int ch;
 68             while((ch=bis.read())!=-1)
 69             {
 70                 bos.write(ch);
 71             }
 72         }finally
 73         {
 74             try
 75             {
 76                 if(bis!=null)
 77                     bis.close();
 78             }
 79             finally
 80             {
 81                 if(bos!=null)
 82                     bos.close();
 83             }
 84         }
 85     }
 86     
 87 }
 88 遍历指定目录下的所有java文件,拷贝到F盘下指定的一个目录下.    如果是为java结尾的文件.咱们要把它的名字更改成jdk
 89 
 90 package com.javami.kudy.CodeAM;
 91 import java.io.BufferedReader;
 92 import java.io.BufferedWriter;
 93 import java.io.File;
 94 import java.io.FileReader;
 95 import java.io.FileWriter;
 96 import java.io.IOException;
 97 import java.io.InputStreamReader;
 98 public class JavaFileCopy {
 99     public static void main(String[]args)
100     {
101         try
102         {
103             listJAVAFile(getDir());
104         }
105         catch(IOException e)
106         {
107             e.printStackTrace();
108         }
109     }
110     
111 
112     /*
113      * 1.获取到一个目录
114      */
115     private static File getDir()throws IOException
116     {
117         BufferedReader br = 
118                     new BufferedReader(new InputStreamReader(System.in));
119         String dir = null;
120         System.out.println("请输入一个目录:");
121         while(true)
122         {
123             dir = br.readLine();
124             File file = new File(dir); //封装一个这个路径
125             if(!file.exists())
126             {
127                 System.out.println("该文件不存在!请重新输入:");
128                 continue;
129             }
130             if(!file.isDirectory())
131             {
132                 System.out.println("该目录不存在,请重新输入:");
133                 continue;
134             }
135             break;
136         }
137         return new File(dir);
138     }

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

  1 package com.javami.kudy.CodeAM;
  2 import java.io.BufferedReader;
  3 import java.io.BufferedWriter;
  4 import java.io.File;
  5 import java.io.FileReader;
  6 import java.io.FileWriter;
  7 import java.io.IOException;
  8 import java.io.InputStreamReader;
  9 public class JavaFileCopy {
 10     public static void main(String[]args)
 11     {
 12         try
 13         {
 14             listJAVAFile(getDir());
 15         }
 16         catch(IOException e)
 17         {
 18             e.printStackTrace();
 19         }
 20     }
 21     
 22 
 23     /*
 24      * 1.获取到一个目录
 25      */
 26     private static File getDir()throws IOException
 27     {
 28         BufferedReader br = 
 29                     new BufferedReader(new InputStreamReader(System.in));
 30         String dir = null;
 31         System.out.println("请输入一个目录:");
 32         while(true)
 33         {
 34             dir = br.readLine();
 35             File file = new File(dir); //封装一个这个路径
 36             if(!file.exists())
 37             {
 38                 System.out.println("该文件不存在!请重新输入:");
 39                 continue;
 40             }
 41             if(!file.isDirectory())
 42             {
 43                 System.out.println("该目录不存在,请重新输入:");
 44                 continue;
 45             }
 46             break;
 47         }
 48         return new File(dir);
 49     }
 50     /*
 51      * 遍历所有目录下的java文件.
 52      */
 53     private static void listJAVAFile(File dir)throws IOException
 54     {
 55         File[] files = dir.listFiles();
 56         
 57         for(File file : files)
 58         {
 59             //如果是目录,就递归.
 60             if(file.isDirectory()) //判断是否是目录
 61             {
 62                 listJAVAFile(file);
 63             }
 64             //如果是文件.并且是java为结尾的文件.获取文件名,替换文件名,创建新文件
 65             else if(file.getName().endsWith(".java")); //获取这个文件名
 66             {
 67                 //获取到一个文件名 
 68                 String fileName = file.getName();
 69                 //把文件名修改成jdk 
 70                 String newFileName = fileName.replaceAll(".java$", ".jdk");
 71                 //从 f:/dj目录下创建文件
 72                 File newFile = new File("f:/dj",newFileName);  //XX.jdk
 73                 newFile.createNewFile(); //如果这个路径不存在.存在一个与之同名的文件  //**.jdk结果
 74                 copyfile(file,newFile);
 75                 //file:是一个java文件  而newFile文件是一个为jdk为结果的文件
 76             }
 77         }
 78     }
 79 
 80 
 81     private static void copyfile(File file, File newFile)throws IOException
 82     {
 83         BufferedReader br = null;
 84         BufferedWriter bw = null;
 85         try
 86         {
 87             br = new BufferedReader(new FileReader(file));//file代表的是一个java的路径
 88             bw = new BufferedWriter(new FileWriter(newFile));//是一个jdk的file文件的复制品
 89             String line = null;
 90             while((line=br.readLine())!=null)
 91             {
 92                 bw.write(line);
 93                 bw.newLine();
 94             }
 95         }finally
 96         {
 97             try
 98             {
 99                 CloseUtil.close(br, bw);
100             }catch(IOException e)
101             {
102                 e.printStackTrace();
103             }
104         }
105     }
106 }

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

 1 package com.javami.kudy.CodeAM;
 2 
 3 import java.io.File;
 4 
 5 public class Test {
 6     public static void main(String[]args)
 7     {
 8         /*
 9          * 简单的递归
10          */
11         File file = new File("F:/a");
12         listArr(file);
13 
14     }
15     public static void listArr(File file)
16     {
17         File[]files = file.listFiles();
18         for(File f : files)
19         {
20             //判断是否是一个目录
21             if(f.isDirectory())
22             {
23                 listArr(f);//注意递归
24             }
25             System.out.println(f.getAbsolutePath()); //如果不是目录.就输出
26         }
27     }
28 }

转载于:https://www.cnblogs.com/woxin/archive/2012/08/11/2634092.html