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 }
posted on 2012-08-11 22:48
、小细 阅读(168)
评论(0) 编辑 收藏