批量文件的操作

 先讲下，因为现在有关布局控件什么的文章已经很多了，基本都能在网上找到

解决方法，从今以后，小马会写一些自己在实际开发过程中用到过的方法及碰到的问

题，小马所犯错误之处会用注释标出，以便提醒朋友们不要犯小马这样低级的错误，

今天讲下批量文件的操作及单个文件的操作，不多废话，直接看代码：

1. /** 
2.  * @Title: DeleteFile.java 
3.  * @Description: 文件、文件夹操作类 
4.  * @author MZH 
5.  * @version 1.0  一般自己的工具辅助类，我个人习惯加版本号，得考虑到后期维护，方便标记 
6.  */ 
7. public class FileUtils{ 
8.  
9.      
10.     /** 
11.      * 一般情况下，小马希望大家养成好习惯，构造方法，一般留个空的，方便扩展 
12.      */ 
13.     public FileUtils(){ 
14.          
15.     } 
16.      
17.      
18.     /** 
19.      * 删除文件 
20.      * @param file 
21.      * @return 
22.      */ 
23.     public boolean deleteFile(File file) { 
24.         boolean result = false; 
25.         if (file != null) { 
26.             try { 
27.                 File file2 = file; 
28.                 file2.delete(); 
29.                 result = true; 
30.             } catch (Exception e) { 
31.                 e.printStackTrace(); 
32.                 result = false; 
33.             } 
34.         } 
35.         return result; 
36.     } 
37.  
38.     /** 
39.      *  删除文件夹 
40.      * @param folder   
41.      * @return 
42.      * 因为涉及到一个文件夹下有文件也有文件夹的情况，所以写个函数，以后直拿来用 
43.      */ 
44.     public boolean deleteFolder(File folder) { 
45.         boolean result = false; 
46.         try { 
47.             //取得文件下所有信息：包括文件及文件夹名称 
48.             String childs[] = folder.list(); 
49.   //小马的错误：是字符串数组，没习惯判断length大小，希望朋友们不要忘了判断长度，养成好的习惯 
50.             if (childs == null || childs.length <= 0) {   
51.                 if (folder.delete()) { 
52.                     result = true; 
53.                 } 
54.             } else { 
55.                 for (int i = 0; i < childs.length; i++) { 
56.                     String childName = childs[i]; 
57.                     String childPath = folder.getPath() + File.separator 
58.                             + childName; 
59.                     File filePath = new File(childPath); 
60. //小马的错误：只判断是否存在，未判断是文件还是文件夹，这样会漏掉一大
61. //部分文件的操作，所以isFile一定要加 
62.                     if (filePath.exists() && filePath.isFile()) {
63.                         if (filePath.delete()) { 
64.                             result = true; 
65.                         } else { 
66.                             result = false; 
67.                             break; 
68.                         } 
69.                         //如果是文件夹的操作，此及写递归删除，调用自己 
70.                     } else if (filePath.exists() && filePath.isDirectory()) { 
71.                         if (deleteFolder(filePath)) { 
72.                             result = true; 
73.                         } else { 
74.                             result = false; 
75.                             break; 
76.                         } 
77.                     } 
78.                 } 
79.                 folder.delete(); 
80.             } 
81.         } catch (Exception e) { 
82.             e.printStackTrace(); 
83.             result = false; 
84.         } 
85.         return result; 
86.     } 
87.  
88.     /** 
89.      * 实现清空所有Temp文件 
90.      *  
91.      * @return 是否删除成功 
92.      */ 
93.     private boolean deleteTempFiles() { 
94.         //ApplicationData myApp = new ApplicationData();   
95. //这一步是小马犯的错误，因为继承Application的类是可以这样new对象，
96. //但不建议直接new，多分内存，而且还是全局的，浪费 
97.          
98.         //此处直接写getApplication会报错，因为需要上下文件，
99. //所以这时小马说的扩展构造方法就有用了，可以在new本类对象时会了Context对象哦，吼吼 
100.         //ApplicationData myApp = (ApplicationData)getApplication(); 
101.          
102.         FileUtils df = new FileUtils(); 
103.         File file = null; 
104.         if (Environment.getExternalStorageState().equals( 
105.                 Environment.MEDIA_MOUNTED)) { 
106.             //因为类似临时文件，一般都在最开始创建，最后删除，
107. //所以小马把建议类似操作放在Application里面操作，取值操作都方便 
108.             file = new File(TEMP); //TEMP为临时文件存放的文件夹路径 
109.         } 
110.         return df.deleteFolder(file); 
111.     } 
112.  
113.      
114.     /** 
115.      * 保存时将临时文件夹下所有文件移至目标文件夹下 
116.      * @param oldLocation  源文件夹 
117.      * @param newLocation  目标文件夹 
118.      * @throws IOException  异常 
119.      * @throws NoSpaceIOException  磁盘空间不足 小马自定义的异常类，可以跳过 
120.      */ 
121.     public void moveFile(File oldLocation, File newLocation) 
122.             throws IOException, NoSpaceIOException { 
123.         boolean isMkdirs = false; 
124.         File file = new File(newLocation.getPath()+File.separator+"此处拼接文件名"); 
125.         if(!file.exists()){ 
126.             isMkdirs = file.mkdirs(); 
127.             if(isMkdirs){ 
128.                 String childs[] = oldLocation.list(); 
129.                 if(oldLocation != null && oldLocation.exists()){ 
130.                     for(int i=0;i<childs.length;i++){ 
131.                         String childName = childs[i]; 
132.                         String childPath = oldLocation.getPath()+File.separator+childName; 
133.                         File filePath = new File(childPath); 
134.                         if(filePath.exists() && filePath.isFile()){ 
135.                             FileInputStream fis = null; 
136.                             FileOutputStream fos = null; 
137.                             try { 
138.                                 fis = new FileInputStream(filePath); 
139.                                 //下面这句中的false是用来判断是否是append追加状态，
140. //不懂的朋友们可以直接访问：http://developer.android.com/reference/java/io/File.html 
141.                                 //来查看相关方法参数的具体涵义，吼吼 
142.                                 fos = new FileOutputStream(new File(file.getPath()+File.separator+childName),false); 
143.                                  
144.                                 byte[] buff = new byte[8192]; 
145.                                 int readIn ; 
146.                                 //此处注意下：read方法中的参数如果不写的话，会读不到文件内容，
147. //报异常,小马犯过的低级错误,希望你不要犯啦 
148.                                 while((readIn = fis.read(buff,0,buff.length))!= -1){ 
149.                                     fos.write(buff,0,readIn); 
150.                                 } 
151.                                 fos.flush(); 
152.                             } catch (Exception e) { 
153.                                 e.printStackTrace(); 
154.                                 /*if (android.os.Environment.getExternalStorageState().equals( 
155.                                         android.os.Environment.MEDIA_MOUNTED)) { 
156.                                     // 如果有sdcard,磁盘空间是否满了 
157.                                     Log.d(TAG, "DMUtils>>>sdcard is ok!"); 
158.                                     // No space left on device 
159.                                     if (ex.getMessage() != null 
160.                                             && ex.getMessage().indexOf( 
161.                                                     "No space left on device") != -1) { 
162.                                         // 磁盘空间满 
163.                                         throw new NoSpaceIOException(ex.getMessage()); 
164.                                     } 
165.                                 } else { 
166.                                     // 文件保存失败应该检查sd卡 
167.                                     Log.d(TAG, "DMUtils>>>sdcard is error!state: " 
168.                                             + android.os.Environment.getExternalStorageState()); 
169.                                 } 
170.                                 throw new IOException(ex.getMessage() 
171.                                         + " IOException when transferring " 
172.                                         + oldLocation.getPath() + " to " 
173.                                         + newLocation.getPath());*/ 
174.                             }finally{ 
175.                                 //大伙应该很熟悉了吧？小马一朋友犯过的错误，未关闭流，
176. //导致生成的文件本来是KB的却成了MB的文件，所以一定注意打开什么就关闭什么 
177.                                 try { 
178.                                     if(fis!=null){ 
179.                                         fos.close(); 
180.                                     } 
181.                                     if(fos!=null){ 
182.                                         fos.close(); 
183.                                     } 
184.                                 } catch (Exception e2) { 
185.                                     e2.printStackTrace(); 
186.                                 } 
187.                             } 
188.                         } 
189.                         /* 
190.                          * 因为此处小马用的是一个文件夹下的文件操作，并不包含子文件夹，
191. * 所以：如果有朋友要用子文件夹操作的话可激活此处递归处理哦 
192.                          */ 
193.                         /*else if(filePath.exists() && filePath.isDirectory()){ 
194.                             try { 
195.                                 moveFile(filePath,new File("此处路径从全局文件中取就OK了")); 
196.                             } catch (Exception e) { 
197.                                 e.printStackTrace(); 
198.                             } 
199.                         }*/ 
200.                     } 
201.                 }    
202.             } 
203.         } 
204.     } 
205.      
206. } 

上面代码中的方法，朋友们可以直接使用，但小马多嘴讲下：不要直接把代码COPY到你使用的工程中，因为那样本就没经过思考，以后碰到类似的问题也就不会解决了，小马很菜，这些代码如果我自己写不出来，就用个笨的方法，一边看一边想，再不行就照抄一边，眼过十遍不如手过一遍听过吧？想通了也就最好了，不会的时候再反过来看下就可以了，所以尽量不使用COPY的方式哦，吼吼。。O_O

      本文转自华华世界 51CTO博客，原文链接：http://blog.51cto.com/mzh3344258/741315，如需转载请自行联系原作者