java IO经典练习题

Java IO流经典练习题

 http://blog.csdn.net/wenzhi20102321/article/details/52738970

本文对javaIO流的13道经典的练习题做解答，里面有详细的思路解析，做题时最好养成先写思路在编程的习惯。

 

一．练习的题目

（一） 在电脑D盘下创建一个文件为HelloWorld.txt文件，判断他是文件还是目录，在创建一个目
录IOTest,之后将HelloWorld.txt移动到IOTest目录下去；之后遍历IOTest这个目录下的文
件

（二） 递归实现输入任意目录，列出文件以及文件夹，效果看图

（三） 递归实现列出当前工程下所有.java文件

（四）从磁盘读取一个文件到内存中，再打印到控制台

（五） 在程序中写一个"HelloJavaWorld你好世界"输出到操作系统文件Hello.txt文件中

（六） 拷贝一张图片，从一个目录到另外一个目录下(PS:是拷贝是不是移动)

（七） 统计一个文件calcCharNum.txt（见附件）中字母'A'和'a'出现的总次数

（八）统计一个文件calcCharNum.txt（见附件）中各个字母出现次数：

A(8),B(16),C(10)...,a(12),b(10),c(3)....，括号内代表字符出现次数;

（九）统计一个文件calcCharNum2.txt（见附件）中各个字母出现次数：
A(8),B(16),C(10)...,a(12),b(10),c(3)....中(5),国(6)，括号内代表字符出现次数;

（十） 使用随机文件流类RandomAccessFile将一个文本文件倒置读出。

（十一） 编写一个Java应用程序，可以实现Dos中的type命令，并加上行号。

即将文本文件在控制台上显示出来，并在每一行的前面加上行号。

（十二）输入两个文件夹名称，将A文件夹内容全部拷贝到B文件夹，要求使用多线程来操作。

（十三）查看D盘中所有的文件和文件夹名称，并且使用名称升序降序，文件夹在前和文件夹在
后，文件大小排序等。 

二．详细的解题过程

 

（一）第一题

[plain]  view plain  copy  print ?

1. package com.xykj.lesson1;  
2.   
3. import java.io.File;  
4. import java.io.IOException;  
5.   
6.   
7. public class Test1 {  
8.     /**  
9.      * 1. 在电脑D盘下创建一个文件为HelloWorld.txt文件，  
10.      * 判断他是文件还是目录，再创建一个目录IOTest,  
11.      * 之后将HelloWorld.txt移动到IOTest目录下去；  
12.      * 之后遍历IOTest这个目录下的文件  
13.      *   
14.      * 程序分析：  
15.      * 1、文件创建使用File的createNewFile()方法  
16.      * 2、判断是文件用isFile(),判断是目录用isDirectory  
17.      * 3、创建目录用：mkdirs()方法  
18.      * 4、移动文件用：renameTo  
19.      * 5、遍历目录用：list（）方法获得存放文件的数组，foreach遍历的方法把文件打印出来  
20.      * */  
21.     public static void main(String[] args) {  
22.          //在电脑D盘下创建一个文件为HelloWorld.txt文件  
23.         File file=new File("D:","HelloWorld.txt");  
24.           
25.         //创建文件，返回一个布尔值  
26.         boolean isCreate;  
27.         try {  
28.             isCreate = file.createNewFile();  
29.             if (isCreate) {  
30.                 System.out.println("创建文件成功！");  
31.             }else {  
32.                 System.out.println("创建文件失败！文件已经存在");  
33.             }  
34.         } catch (IOException e) {  
35.             System.out.println("创建文件失败！");  
36.         }  
37.           
38.         // 判断他是文件还是目录，  
39.         if (file.isFile()) {  
40.             System.out.println("这是一个文件");  
41.         } else {  
42.             System.out.println("这是一个目录");  
43.         }  
44.           
45.         //再创建一个目录IOTest  
46.         File file2=new File("D:/IOTest");  
47.         file2.mkdirs();  
48.           
49.         //HelloWorld.txt移动到IOTest目录下去?失败？》  
50.         if (file.renameTo(file2)) {  
51.             System.out.println("文件移动成功！");  
52.         } else {  
53.             System.out.println("文件移动失败");  
54.         }  
55.           
56.         //遍历IOTest目录下的文件  
57.         String[] arr=file2.list();  
58.         for (String string : arr) {  
59.             System.out.println(string);  
60.         }  
61.     }  
62. }  

 

//上面移动文件要指明文件路径和文件名

上面的file.renameTo(file2）改为：

file.renameTo(file2.getPath + "/" + file.getName());

就不会有错了。

（二）第二题

 

1.先建一个FileUtile工具类

 

 

[plain]  view plain  copy  print ?

1. package com.xykj.lesson2;  
2.   
3. import java.io.File;  
4. import java.util.ArrayList;  
5. import java.util.List;  
6.     /**  
7.      * 这是一个获取目录下所有文件夹内的所有文件的封装类  
8.      * 当然前提是你要传进来一个正确路径的文件夹  
9.      * */  
10. public class FileUtils {  
11.       
12.     //获取文件夹下所有的文件  
13.     public static List<file> getAllFiles(String dir){  
14.           
15.         //创建一个集合存放遍历到的File  
16.         List< File >files=new ArrayList<file>();  
17.           
18.         File file=new File(dir);  
19.         //文件夹必须存在                并且要是文件夹  
20.         if (file.exists()&&file.isDirectory()) {  
21.             //重点！    这里要本身一直遍历  
22.             longErgodic(file,files);//把遍历得到的东西存放在files里面  
23.         }  
24.         return files;  
25.     }  
26.       
27.     //重点理解，这是一个递归方法，会不断来回调用本身，但是所有获得的数据都会存放在集合files里面  
28.     private static void longErgodic(File file, List<file> files) {  
29.           
30.         //.listFiles()方法的使用  
31.         //把文件夹的所有文件（包括文件和文件名）都放在一个文件类的数组里面   
32.         File[] fillArr=file.listFiles();  
33.           
34.         //如果是一个空的文件夹  
35.          if (fillArr==null) {  
36.              //后面的不执行，直接返回  
37.             return;  
38.         }  
39.            
40.         //如果文件夹有内容,遍历里面的所有文件（包括文件夹和文件），都添加到集合里面  
41.          for (File file2 : fillArr) {  
42.                
43.              //如果只是想要里面的文件或者文件夹或者某些固定格式的文件可以判断下再添加  
44.              files.add(file2);  
45.                
46.              //添加到集合后，在来判断是否是文件夹，再遍历里面的所有文件  
47.              //方法的递归  
48.              longErgodic(file2, files);  
49.         }  
50.     }  
51. }  
52. </file></file></file>  

 

2.再建一个主方法调用类

[plain]  view plain  copy  print ?

1. package com.xykj.lesson2;  
2.   
3. import java.io.File;  
4. import java.util.List;  
5.   
6. public class Test2 {  
7.     /**  
8.      * 递归实现输入任意目录，列出文件以及文件夹  
9.      *   
10.      * 设计：在FileUtils类里面实现了逻辑操作，在另一边调用就可以了  
11.      * */  
12.     public static void main(String[] args) {  
13.          //比如输入D盘  
14.         List<file>list=FileUtils.getAllFiles("D:");  
15.         //输出所有的文件和文件夹的名字  
16.         for (File file : list) {  
17.             System.out.println(file);  
18.         }  
19.   
20.     }  
21.   
22. }  
23. </file>  

（三）第三题

[plain]  view plain  copy  print ?

1. package com.xykj.lesson3;  
2.   
3. import java.io.File;  
4. import java.util.List;  
5.   
6. import com.xykj.lesson2.FileUtils;  
7.   
8. public class Test3 {  
9.     /**  
10.      * 递归实现列出当前工程下所有.java文件  
11.      * 还是要题目2的遍历文件的工具类来获取所有的文件，再过滤.java文件就可以了  
12.      * 当前目录的地址：输入.就可以获取  
13.      * */  
14.     public static void main(String[] args) {  
15.          //输入.  获取当前文件的 所有文件  
16.         List<file>list=FileUtils.getAllFiles(".");  
17.         //输出.java后缀的文件的名字  
18.         for (File file : list) {  
19.             if (file.toString().endsWith(".java")) {  
20.                 System.out.println(file.getName());  
21.             }  
22.         }  
23.   
24.     }  
25.   
26. }  
27. </file>  

（四）第四题

 

 

[plain]  view plain  copy  print ?

1. package com.xykj.lesson4;  
2.   
3. import java.io.File;  
4. import java.io.FileInputStream;  
5.   
6. public class Tset4 {  
7.     /**  
8.      * 从磁盘读取一个文件到内存中，再打印到控制台  
9.      *   
10.      * 程序设计：  
11.      * 1、读取文件用到FileinputSteam   
12.      * 2、把读取的内容不断加入到StringBuffer，  
13.      * 3、再把StringBuffer打印出来就可以  
14.      * */  
15.     public static void main(String[] args) {  
16.   
17.         // 读取D:\notePad\aa.txt里面的内容  
18.         File file = new File("D:\\notePad\\aa.txt");  
19.         try {  
20.             // 创建读取流即输入流  
21.             FileInputStream fis = new FileInputStream(file);  
22.             int len = 0;  
23.             byte[] buf = new byte[1024];  
24.             StringBuffer sb = new StringBuffer();  
25.             // 把读取的数据添加到StringBuffer里面  
26.             while ((len = fis.read(buf)) != -1) {  
27.                 sb.append(new String(buf, 0, len));  
28.             }  
29.             // 把StringBuffer里面的内容打印出来  
30.             System.out.println(sb);  
31.             fis.close();  
32.         } catch (Exception e) {  
33.             e.printStackTrace();  
34.         }  
35.     }  
36. }  

 

（五）第五题

 

 

[plain]  view plain  copy  print ?

1. package com.xykj.lesson5;  
2.   
3. import java.io.File;  
4. import java.io.FileOutputStream;  
5.   
6. public class Test5 {  
7.     /**  
8.      * 在程序中写一个"HelloJavaWorld你好世界"输出到操作系统文件Hello.txt文件中  
9.      *   
10.      * 程序分析：文件写入，要用到输出流FileOutputStream  
11.      * */  
12.     public static void main(String[] args) {  
13.         // 向文件D:/Hello.txt，写入内容  
14.         File file = new File("D:/Hello.txt");  
15.         try {  
16.             // 创建输出流  
17.             FileOutputStream fos = new FileOutputStream(file);  
18.             //把String类型的字符串转化为byte数组的数据保存在输出流中  
19.             fos.write("HelloJavaWorld你好世界".getBytes());  
20.             fos.flush();//刷新输出流  
21.             fos.close();//关闭输出流  
22.         } catch (Exception e) {  
23.             e.printStackTrace();  
24.         }  
25.     }  
26. }  

 

 

（六）第六题

 

 

[plain]  view plain  copy  print ?

1. package com.xykj.lesson6;  
2.   
3. import java.io.File;  
4. import java.io.FileInputStream;  
5. import java.io.FileOutputStream;  
6.   
7. public class Test6 {  
8.     /**  
9.      * 拷贝一张图片，从一个目录到另外一个目录下(PS:是拷贝是不是移动)  
10.      *   
11.      * 程序设计思路：  
12.      *  这题不能使用renameTo，   
13.      *  解题步骤：  
14.      * 1、在目的地址创建一个图片文件  
15.      * 2、读取源地址文件的字节流  
16.      * 3、把读取到的字节流写入到目的地址的文件里面   
17.      * 4、刷新输出流，并关闭就可以了  
18.      *   
19.      * @throws Exception  
20.      * */  
21.     public static void main(String[] args) {  
22.         // 本题示范把D盘下的mm.jpg复制到D盘java文件夹里面  
23.         // 源文件地址  
24.         File fileFrom = new File("D:/mm.jpg");  
25.         // 目的文件地址  
26.         File fileTo = new File("D:/java/mm.jpg");  
27.   
28.         // 1、创建目的文件地址  
29.         try {  
30.             if (!fileTo.createNewFile()) {  
31.                 System.out.println("创建文件失败！");  
32.             }  
33.             // 2、读取源地址文件的字节流  
34.             FileInputStream fis = new FileInputStream(fileFrom);  
35.             FileOutputStream fos = new FileOutputStream(fileTo);  
36.             int len = 0;  
37.             byte[] buf = new byte[1024];  
38.             while ((len = fis.read(buf)) != -1) {  
39.                 // 3、把读取到的字节流写入到目的地址的文件里面  
40.                 fos.write(buf, 0, len);  
41.             }  
42.             // 刷新下输出流  
43.             fos.flush();  
44.             // 关闭输入流和输出流  
45.             fis.close();  
46.             fos.close();  
47.             System.out.println("文件复制成功！");  
48.         } catch (Exception e) {  
49.             e.printStackTrace();  
50.         }  
51.     }  
52.   
53. }  

 

 

（七）第七题

 

 

[plain]  view plain  copy  print ?

1. package com.xykj.lesson7;  
2.   
3. import java.io.File;  
4. import java.io.FileInputStream;  
5.   
6. public class Test7 {  
7.     /**  
8.      * 统计一个文件calcCharNum.txt（见附件）中字母'A'和'a'出现的总次数  
9.      *   
10.      * 程序分析：  
11.      * 读取文件用FileInputStream  
12.      * 一次只读一个字节(一个字母就是一个字节)，当字节内容和A或a相等时，相应的数量加1  
13.      * */  
14.     public static void main(String[] args) {  
15.         try {  
16.             //添加文件路径  
17.             File file = new File("D:/java/calcCharNum.txt");  
18.             //创建文件读取流  
19.             FileInputStream fis = new FileInputStream(file);  
20.             int numA = 0;//字母A的数量  
21.             int numa = 0;//字母a的数量  
22.             int len = 0;//每次读取的字节数量  
23.             while ((len=fis.read())!= -1) {  
24.                 //统计字母a的数量  
25.                 if (new String((char)len+"").equals("a")) {  
26.                     numa++;  
27.                 }  
28.                 //统计字母A的数量  
29.                 if (new String((char)len+"").equals("A")) {  
30.                     numA++;  
31.                 }  
32.             }  
33.             //打印出文件内字母的数量  
34.             System.out.println("a的数量是："+numa);  
35.             System.out.println("A的数量是："+numA);  
36.             System.out.println("a和A出现的总次数："+(numA+numa));  
37.             fis.close();//关闭输入流  
38.         } catch (Exception e) {  
39.             e.printStackTrace();  
40.         }  
41.   
42.     }  
43.   
44. }  

（八）第八题

 

[plain]  view plain  copy  print ?

1. package com.xykj.lesson8;  
2.   
3. import java.io.File;  
4. import java.io.FileInputStream;  
5. import java.util.HashMap;  
6. import java.util.Iterator;  
7. import java.util.Map.Entry;  
8.   
9. public class Test8 {  
10.     /**  
11.      * 统计一个文件calcCharNum.txt（见附件）中各个字母出现次数：  
12.      * A(8),B(16),C(10)...,a(12),b(10),c(3)....，括号内代表字符出现次数;  
13.      *  
14.      * 程序分析：  
15.      * 1.这里没中文字符，依然可以只用字节流来读取文件  
16.      * 2.不能保存相同的主键值，可以使用HashMap：key-value来实现  
17.      * 3.先获得该key的value，如果存在key的话value的值加1   
18.      * */  
19.     public static void main(String[] args) {  
20.   
21.         // 文件路径  
22.         File file = new File("D:/java/calcCharNum.txt");  
23.         try {  
24.   
25.             // 创建读取文件的输入流  
26.             FileInputStream fis = new FileInputStream(file);  
27.             // 创建集合HashMap类存放要保存的key-value  
28.             HashMap<string, integer=""> map = new HashMap<>();  
29.   
30.             // 读取文件  
31.             int len = 0;// 每次读取的文件长度  
32.             int count = 0;  
33.             while ((len = fis.read()) != -1) {  
34.                 // 每次获取到的字母  
35.                 char c = (char) len;  
36.                 //这里使用try catch是因为 map.get(c + "")，第一次get不到东西会出现空指针  
37.                 try {  
38.                     // 通过每次的key值获取它的value值，  
39.                     // 但是在它的key值没有时或报空指针错误，所以要try catch处理  
40.                     // 当她有key值，就可以获取到相应的value值  
41.                     count = map.get(c + "");  
42.                 } catch (Exception e) {// 什么都不用输出  
43.                 }  
44.                 // 如果有它的key值对应的value值要加1  
45.                 map.put(c + "", count + 1);  
46.             }  
47.             fis.close();  
48.               
49.             // 读完后把结果打印出来  
50.             //迭代器的使用  
51.             Iterator<entry<string, integer="">> iterator = map.entrySet().iterator();  
52.             while (iterator.hasNext()) {  
53.                 Entry<string, integer=""> entry = iterator.next();  
54.                 System.out.print(entry.getKey() + "(" + entry.getValue()+ ") \t");  
55.             }  
56.         } catch (Exception e) {  
57.             e.printStackTrace();  
58.         }  
59.     }  
60. }  
61. </string,></entry<string,></string,>  

 

其实本题也可以直接用字符流来读取的。

（九）第九题

 

 

[plain]  view plain  copy  print ?

1. package com.xykj.lesson9;  
2.   
3. import java.io.File;  
4. import java.io.FileNotFoundException;  
5. import java.io.FileReader;  
6. import java.io.FileWriter;  
7. import java.util.HashMap;  
8. import java.util.Iterator;  
9. import java.util.Map.Entry;  
10.   
11. public class Test9 {  
12.     /**  
13.      * 统计一个文件calcCharNum2.txt（见附件）中各个字母出现次数：  
14.      * A(8),B(16),C(10)...,a(12),b(10),c(3)....中(5),国(6)，  
15.      * 括号内代表字符出现次数;  
16.      *   
17.      * 程序分析：  
18.      * 1.这出现中文字符，依然只能用字符流来读取文件  
19.      * 2.不能保存相同的主键值，可以使用HashMap：key-value来实现  
20.      * 3.先获得该key的value，如果存在key的话value的值加1   
21.      * */  
22.     public static void main(String[] args) {  
23.         // 文件路径  
24.         File file = new File("D:/java/calcCharNum2.txt");  
25.         // 创建集合HashMap类存放要保存的key-value  
26.         HashMap<string, integer=""> map = new HashMap<>();  
27.   
28.         try {  
29.   
30.             // 创建字符流  
31.             FileReader fr = new FileReader(file);  
32.             // 每次读取的字符长度  
33.             int len = 0;  
34.             int count=0;//出现该字符的次数  
35.             while ((len = fr.read()) != -1) {  
36.                 // 获取对应的字符  
37.                 char c = (char) len;  
38.                 try {  
39.                     // 通过每次的key值获取它的value值，  
40.                     // 但是在它的key值没有时或报空指针错误，所以要try catch处理  
41.                     // 当她有key值，就可以获取到相应的value值  
42.                     count = map.get(c + "");  
43.                 } catch (Exception e) {// 什么都不用输出  
44.                 }  
45.                 // 如果有它的key值对应的value值要加1  
46.                 map.put(c + "", count + 1);  
47.             }  
48.               
49.             // 读完后把结果打印出来  
50.             Iterator<entry<string, integer="">> iterator = map.entrySet().iterator();  
51.               
52.             //迭代器的使用  
53.             while (iterator.hasNext()) {                  
54.                 Entry<string, integer=""> entry = iterator.next();  
55.                 System.out.print(entry.getKey() + "(" + entry.getValue()+ ") \t");  
56.             }  
57.         } catch (Exception e) {  
58.             e.printStackTrace();  
59.         }  
60.   
61.     }  
62.   
63. }  
64. </string,></entry<string,></string,>  

（十）第十题

 

[plain]  view plain  copy  print ?

1. package com.xykj.lesson10;  
2.   
3. import java.io.File;  
4. import java.io.RandomAccessFile;  
5.   
6. public class Test10 {  
7.     /**  
8.      * 使用随机文件流类RandomAccessFile将一个文本文件倒置读出。  
9.      *   
10.      * 程序分析：  
11.      *  RandomAccessFile的seek方法能把读取文件的光标移动到具体的位置  
12.      * 但是还是有地点值得注意的是一个字母或数字是占用一个字节的， 一个汉字是占用两个字节的  
13.      * */  
14.     public static void main(String[] args) {  
15.         // 要读取的文件的地址  
16.         File file = new File("D:/java/calcCharNum2.txt");  
17.         try {  
18.             RandomAccessFile raf = new RandomAccessFile(file, "r");  
19.             long length = raf.length();  
20.             StringBuffer sb = new StringBuffer();  
21.             while (length > 0) {  
22.                 length--;  
23.                 raf.seek(length);  
24.                 int c = (char) raf.readByte();  
25.                 // 如果asc码<=255,>=0,则判断是个英文字符,添加到字符串中.  
26.                 if (c >= 0 && c <= 255) {  
27.                     sb.append((char) c);  
28.                 } else {  
29.                     // 如果不在asc码范围内,则判断是个汉字字符  
30.                     // 汉字字符是占2个字节的,所以length再退一个字节  
31.                     length--;  
32.                     raf.seek(length);  
33.                     byte[] cc = new byte[2];  
34.                     // cc被复制为文件中连续的两个字节  
35.                     raf.readFully(cc);  
36.                     sb.append(new String(cc));  
37.                 }  
38.             }  
39.             System.out.println(sb);  
40.             raf.close();  
41.         } catch (Exception e) {  
42.             e.printStackTrace();  
43.         }  
44.     }  
45.   
46. }  

（十一）第十一题

 

[plain]  view plain  copy  print ?

1. package com.xykj.lesson1;  
2.   
3. import java.io.File;  
4. import java.io.IOException;  
5.   
6.   
7. public class Test1 {  
8.     /**  
9.      * 1. 在电脑D盘下创建一个文件为HelloWorld.txt文件，  
10.      * 判断他是文件还是目录，再创建一个目录IOTest,  
11.      * 之后将HelloWorld.txt移动到IOTest目录下去；  
12.      * 之后遍历IOTest这个目录下的文件  
13.      *   
14.      * 程序分析：  
15.      * 1、文件创建使用File的createNewFile()方法  
16.      * 2、判断是文件用isFile(),判断是目录用isDirectory  
17.      * 3、创建目录用：mkdirs()方法  
18.      * 4、移动文件用：renameTo  
19.      * 5、遍历目录用：list（）方法获得存放文件的数组，foreach遍历的方法把文件打印出来  
20.      * */  
21.     public static void main(String[] args) {  
22.          //在电脑D盘下创建一个文件为HelloWorld.txt文件  
23.         File file=new File("D:","HelloWorld.txt");  
24.           
25.         //创建文件，返回一个布尔值  
26.         boolean isCreate;  
27.         try {  
28.             isCreate = file.createNewFile();  
29.             if (isCreate) {  
30.                 System.out.println("创建文件成功！");  
31.             }else {  
32.                 System.out.println("创建文件失败！文件已经存在");  
33.             }  
34.         } catch (IOException e) {  
35.             System.out.println("创建文件失败！");  
36.         }  
37.           
38.         // 判断他是文件还是目录，  
39.         if (file.isFile()) {  
40.             System.out.println("这是一个文件");  
41.         } else {  
42.             System.out.println("这是一个目录");  
43.         }  
44.           
45.         //再创建一个目录IOTest  
46.         File file2=new File("D:/IOTest");  
47.         file2.mkdirs();  
48.           
49.         //HelloWorld.txt移动到IOTest目录下去?失败？》  
50.         if (file.renameTo(file2)) {  
51.             System.out.println("文件移动成功！");  
52.         } else {  
53.             System.out.println("文件移动失败");  
54.         }  
55.           
56.         //遍历IOTest目录下的文件  
57.         String[] arr=file2.list();  
58.         for (String string : arr) {  
59.             System.out.println(string);  
60.         }  
61.     }  
62. }  

 

（十二）第十二题

 

[plain]  view plain  copy  print ?

1. package com.xykj.lesson12;  
2. import java.io.File;  
3. import java.io.FileInputStream;  
4. import java.io.FileOutputStream;  
5. import java.io.IOException;  
6. import java.util.List;  
7. import java.util.Scanner;  
8. import java.util.concurrent.ExecutorService;  
9. import java.util.concurrent.Executors;  
10.   
11. import com.xykj.lesson2.FileUtils;  
12.   
13.   
14. public class Test12 {  
15.     /*  
16.      * 输入两个文件夹名称，将A文件夹内容全部拷贝到B文件夹，要求使用多线程来操作。  
17.      *   
18.      * 程序分析：  
19.      * 1.拷贝文件里面的东西，要分析的东西还是蛮多的，要先建文件夹再拷贝里面的东西，而且要一层层的来搞  
20.      * 2.这里也需要文件遍历工具，直接调用第二题的工具类，不再重写  
21.      * 3.多线程的使用，可以直接在方法里面直接新建线程  
22.      * 4.对整个文件夹进行复制 文件夹分隔符可以用\\或/，其他的都是不对的  
23.      * 所有其中还对输入的分割符进行了替换  
24.      * 这题看起来比较长，分开看其实也不长  
25.      * */  
26.     public static void main(String[] args) {  
27.         Scanner scanner=new Scanner(System.in);  
28.         System.out.println("要复制的文件夹：");  
29.         String fromDir = scanner.next();// 接收输入  
30.         System.out.println("要复制到哪里去：");  
31.         String toDir = scanner.next();// 接收输入  
32.   
33.         // 把输入的地址转化为File类型  
34.         File fromFile = new File(fromDir);  
35.         File toFile = new File(toDir);  
36.           
37.         //新建线程  
38.         new Thread(){  
39.             //里面做实际操作  
40.             public void run() {  
41.                 // 判断如果要复制的是文件，直接复制就可以了  
42.                 if (fromFile.isFile()) {  
43.                     System.out.println("复制单个文件");  
44.                     copy(fromFile, toFile);  
45.                 } else {  
46.                     // 要复制文件夹  
47.                     // 要防止一种无法进行的复制：比如说，要把复制的文件复制到自己的子文件夹里面  
48.                     // 举个例子：把D:/java/jsp文件夹复制到D:/java/jsp/js文件夹里面，  
49.                     // 这会导致子文件不断增加的同时，而父文件也要不断增加，的一个死循环  
50.                     // 如果反过来，就没事，相当于只是简单的覆盖而已  
51.                     // 具体实现就是看：目的地地址包含复制的文件夹地址，就不允许操作  
52.                     if (toDir.replace("/", "\\").toLowerCase()  
53.                             .startsWith(fromDir.replace("/", "\\").toLowerCase())) {  
54.                         return;  
55.                     }  
56.   
57.                     // 复制文件（包括文件和文件夹）操作  
58.   
59.                     // 先获取所有的文件（包括文件和文件夹）  
60.                     List<file> list = FileUtils.getAllFiles(fromDir);  
61.   
62.                     // 创建一个线程池，加快复制的速度  
63.                     ExecutorService threadPool = Executors.newFixedThreadPool(20);  
64.   
65.                     // 需要对每一个文件的路径进行处理  
66.                     for (File file : list) {  
67.                         // 复制文件名  
68.                         String name = file.getAbsolutePath();  
69.                         // 把原来的文件路径换成新的文件路径  
70.                         String toName = name.replace(fromFile.getParent(), toDir + "/");  
71.                         System.out.println(name + "变成了" + toName);  
72.                         // 如果是文件夹，直接创建  
73.                         if (file.isDirectory()) {  
74.                             new File(toName).mkdirs();  
75.                         } else {  
76.                             // 如果是文件,在线程里面复制  
77.                             threadPool.execute(new Runnable() {  
78.                                 @Override  
79.                                 public void run() {  
80.                                     File copyFile = new File(toName);  
81.                                     // 先要有父文件夹  
82.                                     copyFile.getParentFile().mkdirs();  
83.   
84.                                     // 开始复制文件  
85.                                     copy(file, copyFile);  
86.                                 }  
87.                             });  
88.                         }  
89.                     }  
90.   
91.                 }  
92.                 scanner.close();  
93.             };  
94.               
95.         }.start();//开始线程  
96.     }  
97.       
98.     //复制文件的操作  
99.     public static void copy(File fromFile, File toFile) {  
100.         // 定义一个输入流  
101.         FileInputStream fis = null;  
102.         // 定义一个输出流  
103.         FileOutputStream fos = null;  
104.   
105.         try {  
106.             // 把复制地址的File，封装后赋值给输入流对象  
107.             fis = new FileInputStream(fromFile);  
108.             // 把目的地的File，封装后复制给输出流的对象  
109.             fos = new FileOutputStream(toFile);  
110.             // 创建一个容量，  
111.             byte[] buf = new byte[1024];  
112.             // 每次读取/写入的字节长度  
113.             int len = 0;  
114.             // 边读边写  
115.             while ((len = fis.read(buf)) != -1) {// 判断是否还能读到数据  
116.                 // 把输入放到输出流里面  
117.                 fos.write(buf, 0, len);  
118.             }  
119.         } catch (Exception e) {  
120.             e.printStackTrace();  
121.         } finally {  
122.             try {  
123.                 // 关闭输入流和输出流  
124.                 fis.close();  
125.                 fos.close();  
126.             } catch (IOException e) {  
127.                 e.printStackTrace();  
128.             }  
129.   
130.         }  
131.     }  
132.   
133. }  
134. </file>  

 

（十三）第十三题

  

[plain]  view plain  copy  print ?

1. package com.xykj.lesson13;  
2.   
3. import java.io.File;  
4. import java.util.Collections;  
5. import java.util.Comparator;  
6. import java.util.List;  
7.   
8. import com.xykj.lesson2.FileUtils;  
9.   
10. public class Test13 {  
11.     /**  
12.      * 查看D盘中所有的文件和文件夹名称，并且使用名称升序降序，  
13.      * 文件夹在前和文件夹在后，文件大小排序等。  
14.      *   
15.      * 程序分析:  
16.      * 1.查找文件和文件夹，需要例题二里遍历文件的工具类（这里直接调用，不在重写）  
17.      * 2.排序需要用到list集合里面的Collections工具类类的sort方法  
18.      * 3.这里有三重排序：首先是要按是否是文件夹来排序，然后按名称来排序，最后按大小来排序  
19.      *   其实这里还是会有问题的，按照某一个排序还没事，但是三个都排序就不一定有效！  
20.        实际应用中也是只按一种排序就可以了的  
21.      * */  
22.     public static void main(String[] args) {  
23.          List<file> list =FileUtils.getAllFiles("D:");  
24.            
25.          //按文件夹先显示的顺序：  
26.          Collections.sort(list, new Comparator<file>() {  
27.             @Override  
28.             public int compare(File o1, File o2) {  
29.                 return (o2.isDirectory()?1:-1)-(o1.isDirectory()?1:-1);  
30.             }  
31.         });  
32.           
33.          //按文件名称显示的顺序：  
34.          Collections.sort(list, new Comparator<file>() {  
35.                 @Override  
36.                 public int compare(File o1, File o2) {  
37.                     return (o1.getName()).compareTo(o2.getName());  
38.                 }  
39.             });  
40.            
41.          //按文件名称显示的顺序：  
42.          Collections.sort(list, new Comparator<file>() {  
43.                 @Override  
44.                 public int compare(File o1, File o2) {  
45.                     return (int)(o1.length()-o2.length());  
46.                 }  
47.             });  
48.               
49.          //遍历集合的文件  
50.          for (File file : list) {  
51.          //打印排序后的文件或文件夹  
52.          System.out.println(file.getName());  
53.         }  
54.     }  
55. }  
56. </file></file></file></file>