Java笔记4 ： 自己封装的文件和文件夹操作工具类，包括新建、复制、剪切、重命名、删除

学了一下Java的IO，到安卓中也可以使用，所以封装一个工具类，方便文件操作，写了一上午了，目测基本没有bug了。。

首先是需要的几个private方法：

 1         /**

 2      * 检查指定文件或目录的父目录是否存在，不存在则创建

 3      * @param path 文件或目录的路径

 4      */

 5     private static void readyParentDir(String path) {

 6         File parent = new File(new File(path).getParent());

 7         if(!parent.exists() || !parent.isDirectory()) {

 8             createNewDirs(path);

 9         }

10     }

readyParentDir

 

 1         /**

 2      * 深度优先删除文件或文件夹

 3      * @param src 待删除的文件或文件夹

 4      * @return 删除成功返回true，否则返回false

 5      */

 6     private static boolean delete(File src) {

 7         File[] files = src.listFiles();

 8         if(files != null) {

 9             for(File file : files) {

10                 if(file.isDirectory()) {

11                     delete(file);

12                 } else {

13                     file.delete();

14                 }

15             }

16         }

17         return src.delete();

18     }

delete

 

 1         /**

 2      * 字节流实现的复制文件

 3      * @param source 源

 4      * @param target 目标

 5      * @return 复制成功返回true，否则返回false

 6      */

 7     private static boolean copyFile(String source, String target) {

 8         BufferedInputStream src = null;

 9         BufferedOutputStream tar = null;

10         try {

11             FileInputStream in = new FileInputStream(source);

12             FileOutputStream out = new FileOutputStream(target);

13             src = new BufferedInputStream(in);

14             tar = new BufferedOutputStream(out);

15             int len = 0;

16             byte[] buf = new byte[1024];

17             while((len = src.read(buf)) != -1) {

18                 tar.write(buf, 0, len);

19             }

20             tar.flush();

21             return true;

22         } catch (IOException e) {

23             e.printStackTrace();

24             return false;

25         } finally {

26             try {

27                 src.close();

28                 tar.close();

29             } catch (IOException e) {

30                 e.printStackTrace();

31             }

32         }

33     }

copyFile

 

 1         /**

 2      * 深度优先复制目录

 3      * @param source 源

 4      * @param target 目标

 5      * @return 复制成功返回true，否则返回false

 6      */

 7     private static boolean copyDir(String source, String target) {

 8         File src = new File(source);

 9         String tar = target + "\\" + src.getName();

10         createNewDirs(tar);

11         File[] files = src.listFiles();

12         boolean result = true;

13         if(files != null) {

14             for(File file : files) {

15                 if(file.isFile()) {

16                     if(!copyFile(file.getPath(), tar + "\\" + file.getName())) {

17                         result = false;

18                     }

19                 } else if (file.isDirectory()) {

20                     if(!copyDir(file.getPath(), tar)) {

21                         result = false;

22                     }

23                 }

24             }

25         }

26         return result;

27     }

copyDir

 

然后是public方法，非线程安全的

新建文件：

 1         /**

 2      * 新建文件

 3      * @param path 路径，例："d:\\hello.txt"

 4      * @return 建立成功返回true，否则返回false

 5      */

 6     public static boolean createNewFile(String path) {

 7         File file = new File(path);

 8         try {

 9             return file.createNewFile();

10         } catch (IOException e) {

11             e.printStackTrace();

12             return false;

13         }

14     }

createNewFile

新建文件夹：

1     /**

2      * 新建文件夹，可以一次建多级

3      * @param path 路径，例："d:\\Test\\bin"

4      * @return 建立成功返回true，否则返回false

5      */

6     public static boolean createNewDirs(String path) {

7         File file = new File(path);

8         return file.mkdirs();

9     }

createNewDirs

复制文件或文件夹：

 1     /**

 2      * 复制文件或文件夹

 3      * @param source 源，可以是文件或文件夹

 4      * @param target 目标，是复制到的路径，即复制后的父目录

 5      * @return 复制成功返回true，否则返回false

 6      */

 7     public static boolean copyTo(String source, String target) {

 8         File file_src = new File(source);

 9         readyParentDir(target);

10         if(file_src.isFile()) {

11             return copyFile(source, target);

12         } else if (file_src.isDirectory()) {

13             return copyDir(source, target);

14         }

15         return false;

16     }

copyTo

重命名文件或文件夹：

 1     /**

 2      * 重命名文件或文件夹

 3      * @param oldName 旧名称

 4      * @param newName 新名称

 5      * @return 重命名成功返回true，否则返回false

 6      */

 7     public static boolean rename(String oldName, String newName) {

 8         File file_old = new File(oldName);

 9         File file_new = new File(newName);

10         readyParentDir(newName);

11         return file_old.renameTo(file_new);

12     }

rename

剪切文件或文件夹：

 1     /**

 2      * 剪切文件或文件夹

 3      * @param source 源路径

 4      * @param target 目标路径

 5      * @return 剪切成功返回true，否则返回false

 6      */

 7     public static boolean cutTo(String source, String target) {

 8         if(!rename(source, target)) {

 9             return copyTo(source, target);

10         }

11         return true;

12     }

cutTo

删除文件或文件夹：

1     /**

2      * 删除文件或文件夹

3      * @param path 待删除的文件或文件夹路径

4      * @return 删除成功返回true，否则返回false

5      */

6     public static boolean delete(String path) {

7         return delete(new File(path));

8     }

delete