Java的的简单线程复制文件工具类FileUtil2.0

相对于版本1.0,多了很多方法，

比如，获取文件的后缀名，或修改后缀名和一些文件的简单操作。

文件复制到文件，文件复制到路径，路径下文件复制到新路径下，

代码如下，请享用：

  1 package cn.util;
  2 
  3 import java.io.*;
  4 
  5 /**
  6  * 线程的方式实现文件的复制。
  7  文件的复制需要四个参数：1，路径或文件）,2路径或文件，3,是否覆盖，4，是否追加，
  8 多文件复制还需要加时间参数（毫秒）.
  9  * 以及File类实例的简单创建，
 10  * 
 11  * @version 2
 12  * @author JXLYS
 13  */
 14 public class FileUtil extends Thread {
 15 
 16     static class FileUtilHelp {//辅助类
 17 
 18         private static FileUtil[] farr = new FileUtil[5];// 线程数量(java默认线程最多10)
 19 
 20         // 创建文件并复制
 21         private static void createFileAndCopy(File f1, File f2, boolean override, boolean append) {
 22             if (!f2.exists()) {
 23                 createFile(f2, override);
 24             } else {
 25                 if (!override)
 26                     return;
 27                 else {
 28                     append = false;// 覆盖必然不会追加
 29                 }
 30             }
 31             FileUtilHelp.createThread(f1, f2, append);
 32         }
 33 
 34         private static void createCopy(InputStream is, OutputStream os) {
 35             int i = 0;
 36             for (FileUtil f : farr) {
 37                 if (f == null || !f.isAlive()) {
 38                     farr[i] = new FileUtil();
 39                     farr[i].setInputStreamAndOutputStream(is, os);
 40                     farr[i].start();
 41                 }
 42                 i++;
 43             }
 44         }
 45 
 46         // 创建路径
 47         private static void createMkdirs(String path) {
 48             File f = new File(path);
 49             if (!f.exists()) {
 50                 f.mkdirs();
 51             }
 52         }
 53 
 54         // 开始线程
 55         private static void createThread(File f1, File f2, boolean append) {
 56             int i = 0;
 57             for (FileUtil f : farr) {
 58                 if (f == null || !f.isAlive()) {
 59                     farr[i] = new FileUtil();
 60                     farr[i].copyThread(f1, f2, append);
 61                     farr[i].start();
 62                 }
 63                 i++;
 64             }
 65         }
 66 
 67     }
 68 
 69     /**
 70      * 复制文件1到文件2(可以创建路径)
 71      * 
 72      * @param f1
 73      *            文件对象
 74      * @param f2
 75      *            文件对象
 76      * @param override
 77      *            是否覆盖
 78      * @param append
 79      *            是否追加文件内容
 80      */
 81     public static void copyFile(File f1, File f2, boolean override, boolean append) {
 82         if (exists(f1)) {
 83             FileUtilHelp.createMkdirs(parent(f2));
 84             FileUtilHelp.createFileAndCopy(f1, f2, override, append);
 85         }
 86     }
 87 
 88     /**
 89      * 复制文件1到文件2(可以创建路径)
 90      * 
 91      * @param fileName
 92      *            文件1
 93      * @param fileName2
 94      *            文件2
 95      * @param override
 96      *            是否覆盖
 97      */
 98     public static void copyFile(String fileName, String fileName2, boolean override, boolean append) {
 99         copyFile(newFile(fileName), newFile(fileName), override, append);
100     }
101 
102     /**
103      * 复制文件到指定路径(可创建路径)
104      * 
105      * @param f1
106      *            文件
107      * @param f2
108      *            文件夹
109      * @param override
110      *            是否覆盖
111      * @param append
112      *            是否追加
113      * @return
114      */
115     public static void copyFileToPath(File f1, File f2, boolean override, boolean append) {
116         copyFile(f1, newFile(f2.getAbsolutePath(), f1.getName()), override, append);
117     }
118 
119     /**
120      * 根据流来复制。
121      * 
122      * @param is
123      *            输入流
124      * @param os
125      *            输出流
126      */
127     public static void copyFile(InputStream is, OutputStream os) {
128         FileUtilHelp.createCopy(is, os);
129     }
130 
131     /**
132      * 复制文件到指定路径(可创建路径)
133      * 
134      * @param fileName
135      *            文件名
136      * @param path
137      *            路径
138      * @param override
139      *            覆盖
140      * @param append
141      *            是否追加
142      */
143     public static void copyFileToPath(String fileName, String path, boolean override, boolean append) {
144         copyFileToPath(newFile(fileName), newFile(path), override, append);
145     }
146 
147     /**
148      * 复制指定路径下所有文件到指定路径(建议大文件不要太多)
149      * 
150      * @param f1
151      *            文件对象
152      * @param f2
153      *            文件对象
154      * @param override
155      *            是否覆盖
156      * @param append
157      *            是否追加
158      * @param time
159      *            复制每个文件的间隔
160      */
161     public static void copyPathToPath(File f1, File f2, boolean override, boolean append, long time) {
162         if (exists(f1) && isDirectory(f1)) {
163             File[] farr = f1.listFiles();
164             for (File f : farr) {
165                 try {
166                     Thread.sleep(time);// 一次性复制超过5个，线程支持不住，慢点也不影响性能。
167                 } catch (InterruptedException e) {
168                     e.printStackTrace();
169                 }
170                 copyFileToPath(f, f2, override, append);
171             }
172         }
173     }
174 
175     /**
176      * 复制指定路径下所有文件到指定路径(大文件需要更多时间。)
177      * 
178      * @param path1
179      *            路径
180      * @param path2
181      *            路径
182      * @param override
183      *            是否覆盖
184      * @param append
185      *            是否追加
186      * @param time
187      *            复制每个文件的间隔
188      */
189     public static void copyPathToPath(String path1, String path2, boolean override, boolean append, long time) {
190         copyPathToPath(newFile(path1), newFile(parent(newFile(path1)), path2), override, append, time);
191     }
192 
193     /**
194      * 创建目录
195      * 
196      * @param f
197      */
198     public static void createDire(File f) {
199         FileUtilHelp.createMkdirs(f.getAbsolutePath());
200     }
201 
202     /**
203      * 根据路径创建目录
204      * 
205      * @param path
206      */
207     public static void createDire(String path) {
208         createDire(newFile(path));
209     }
210 
211     /**
212      * 不覆盖的创建文件
213      * 
214      * @param f
215      */
216     public static void createFile(File f) {
217         createFile(f, false);
218     }
219 
220     /**
221      * 创建文件
222      * 
223      * @param f
224      *            文件对象
225      * @param override
226      *            是否覆盖
227      */
228     public static void createFile(File f, boolean override) {
229         FileUtilHelp.createMkdirs(parent(f));
230         if (override) {
231             f.delete();
232         }
233         if (!exists(f)) {
234             try {
235                 f.createNewFile();
236             } catch (IOException e) {
237                 e.printStackTrace();
238             }
239         }
240     }
241 
242     /**
243      * 不覆盖的创建文件
244      * 
245      * @param f
246      */
247     public static void createFile(String fileName) {
248         createFile(fileName, false);
249     }
250 
251     /**
252      * 创建文件
253      * 
254      * @param fileName
255      *            创建文件
256      * @param override
257      *            是否覆盖
258      */
259     public static void createFile(String fileName, boolean override) {
260         createFile(newFile(fileName), override);
261     }
262 
263     /**
264      * 检测文件对象是否存在
265      * 
266      * @param f
267      */
268     public static boolean exists(File f) {
269         return f.exists() ? true : false;
270     }
271 
272     /**
273      * 检测路径是否存在
274      * 
275      * @param f
276      */
277     public static boolean exists(String fileName) {
278         return exists(new File(fileName));
279     }
280 
281     /**
282      * 检测文件对象是否目录
283      * 
284      * @param f
285      */
286     public static boolean isDirectory(File f) {
287         return f.isDirectory();
288     }
289 
290     /**
291      * 检测路径是否目录
292      * 
293      * @param f
294      */
295     public static boolean isDirectory(String fileName) {
296         return isDirectory(newFile(fileName));
297     }
298 
299     /**
300      * 检测文件对象是否文件
301      * 
302      * @param f
303      */
304     public static boolean isFile(File f) {
305         return f.isFile();
306     }
307 
308     /**
309      * 获取文件的后缀名
310      * 
311      * @param fileName
312      * @return
313      */
314     public static String suffixName(String fileName) {
315         return suffixName(newFile(fileName));
316     }
317 
318     /**
319      * 获取不带后缀名的文件名字符串
320      * 
321      * @param fileName
322      * @return
323      */
324     public static String getNoSuffixName(String fileName) {
325         return getNoSuffixName(newFile(fileName));
326     }
327 
328     /**
329      * 获取不带后缀名的文件名字符串
330      * 
331      * @param f
332      * @return
333      */
334     public static String getNoSuffixName(File f) {
335         return f.getName().substring(0, f.getName().lastIndexOf("."));
336     }
337 
338     /**
339      * 重命名
340      * 
341      * @param fileName1
342      *            路径
343      * @param fileName2
344      *            路径
345      */
346     public static void rename(String fileName1, String fileName2) {
347         rename(newFile(fileName1), newFile(fileName2));
348     }
349 
350     /**
351      * 重命名
352      * 
353      * @param f1
354      * @param f2
355      */
356     public static void rename(File f1, File f2) {
357         f1.renameTo(f2);
358     }
359 
360     /**
361      * 修改指定路径的文件后缀名。
362      * 
363      * @param fileName
364      *            路径
365      * @param suffix
366      *            后缀名
367      */
368     public static void replaceSuffixName(String fileName, String suffix) {
369         replaceSuffixName(newFile(fileName), suffix);
370     }
371 
372     /**
373      * 修改文件后缀名
374      * 
375      * @param file
376      *            对象，
377      * @param suffix
378      *            后缀
379      */
380     public static void replaceSuffixName(File file, String suffix) {
381         StringBuilder name = new StringBuilder();
382         name.append(getNoSuffixName(file));
383         name.append(".");
384         name.append(suffix);
385         rename(file, newFile(parent(file), name.toString()));
386     }
387 
388     /**
389      * 获取文件的后缀名
390      * 
391      * @param f
392      * @return
393      */
394     public static String suffixName(File f) {
395         String[] sarr = f.getName().split("\\.");
396         return sarr.length > 1 ? sarr[sarr.length - 1] : null;
397     }
398 
399     /**
400      * 检测路径是否文件
401      * 
402      * @param f
403      */
404     public static boolean isFile(String fileName) {
405         return isFile(newFile(fileName));
406     }
407 
408     /**
409      * 根据路径创建文件对象，
410      * 
411      * @param fileName
412      * @return
413      */
414     public static File newFile(String fileName) {
415         return new File(fileName);
416     }
417 
418     /**
419      * 创建路径和文件名创建文件对象
420      * 
421      * @param path
422      *            路径
423      * @param fileName
424      *            文件名字
425      * @return
426      */
427     public static File newFile(String path, String fileName) {
428         return new File(path, fileName);
429     }
430 
431     /**
432      * 返回对象的父目录
433      * 
434      * @param f
435      * @return
436      */
437     public static String parent(File f) {
438         String str = f.getName();
439         String abso = f.getAbsolutePath();
440         return abso.substring(0, abso.length() - str.length());
441     }
442 
443     /**
444      * 根据文件和样式获取文件大小的字符串
445      * 
446      * @param file
447      *            根据文件路径
448      * @param size
449      *            文件大小样式(KB或MB或GB)
450      * @return
451      */
452     public static String size(File file, String size) {
453         long len = file.length();
454         double d = 0;
455         StringBuilder sb = new StringBuilder();
456         switch (size) {
457         case "k":
458         case "K":
459         case "kb":
460         case "Kb":
461         case "KB":
462         case "kB":
463             d = 1.0 * len / 1024;
464             sb.append(String.format("%.3f", d));
465             sb.append("MB");
466             break;
467         case "m":
468         case "M":
469         case "mb":
470         case "MB":
471         case "mB":
472         case "Mb":
473             d = 1.0 * len / 1024 / 1024;
474             sb.append(String.format("%.3f", d));
475             sb.append("MB");
476             break;
477         case "g":
478         case "G":
479         case "gb":
480         case "GB":
481         case "Gb":
482         case "gB":
483             d = 1.0 * len / 1024 / 1024 / 1024;
484             sb.append(String.format("%.3f", d));
485             sb.append("GB");
486             break;
487         default:
488             sb.append(len);
489             sb.append("B");
490         }
491         return sb.toString();
492     }
493 
494     /**
495      * 根据路径和样式获取文件大小的字符串
496      * 
497      * @param fileName
498      *            根据文件路径
499      * @param size
500      *            文件大小样式(KB或MB或GB)
501      * @return
502      */
503     public static String size(String fileName, String size) {
504         return size(newFile(fileName), size);
505     }
506 
507     private InputStream is;
508     private OutputStream os;
509 
510     private FileUtil() {
511     }
512 
513     private void setInputStreamAndOutputStream(InputStream is, OutputStream os) {
514         this.is = is;
515         this.os = os;
516     }
517 
518     private void copyThread(File f1, File f2, boolean append) {
519         try {
520             is = new FileInputStream(f1);
521         } catch (FileNotFoundException e1) {
522             e1.printStackTrace();
523         }
524         try {
525             os = new FileOutputStream(f2, append);
526         } catch (FileNotFoundException e) {
527             e.printStackTrace();
528         }
529     }
530 
531     public void run() {
532         BufferedInputStream bis = null;
533         BufferedOutputStream bos = null;
534         try {
535             bis = new BufferedInputStream(is);
536             bos = new BufferedOutputStream(os);
537             byte[] barr = new byte[1024];
538             int len = 0;
539             while ((len = bis.read(barr)) != -1) {
540                 bos.write(barr, 0, len);
541             }
542         } catch (IOException e) {
543             e.printStackTrace();
544         } finally {
545             if (bis != null)
546                 try {
547                     bis.close();
548                 } catch (IOException e) {
549                     e.printStackTrace();
550                 }
551             if (bos != null)
552                 try {
553                     bos.close();
554                 } catch (IOException e) {
555                     e.printStackTrace();
556                 }
557         }
558     }
559 }

 

组合并且封装了File的一些方法，文件路径就是File对象。

上边都是字符流，至于线程开启字符流的的运算，加油，你可以的。

转载于:https://www.cnblogs.com/jxlys/p/8098092.html