碼上快樂

相關內容    簡體    繁體

Java IO流經典練習題（mark用）

本文轉載自   查看原文   2018-08-17 14:27   4721    JDK/ 通用實踐/ 開發經驗/ java經驗集錦/ 設計模式

一．練習的題目


（一） 在電腦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>  

 

 

 

 

以上是這些題目的詳細的解題過程，當然很多題目的解決方法不是固定的，

但是對於基本的解題方式還是要了解的。對於知識點的掌握的話，

文件的基本操作，讀取文件的基本方法，和寫文件的基本方法都是要掌握的，

還有字節流的讀取和字符流的讀取方式和用處也要會區分。


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 Java IO流經典練習題 Java從入門到實戰之（11）IO流經典練習題 java經典練習題 Java經典練習題_Day05 Java經典練習題_Day03 Python入門經典練習題 《Java練習題》Java進階練習題（一） 《Java練習題》Java進階練習題（三） 《Java練習題》Java進階練習題（五） java acm練習題
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM