自己写个Java的文件操作类，实现新建、复制、剪切、删除、重命名等操作

       测试一下自己的文件操作水平如何。Java核心技术卷Ⅱ没看完，暂时不处理压缩文件。代码如下：

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.nio.file.Files;

import javax.swing.JOptionPane;

public class MainClass
{
    public static void main(String[] args)
    {
        // 一组测试。在当前环境下打印了“true”。
        boolean flag = HippoFileTools.cutFile("F:\\E.txt", "e:\\babc.txt");
        System.out.println(flag);
    }
}

/**
 * 文件操作类——HippoFileTools
 * 提供新建文件夹、删除文件夹、新建文件、删除文件、重命名文件、复制文件和剪切文件等功能。
 * @author 赵利昂
 * @version 20180228
 */
class HippoFileTools
{
    /**
     * 创建一个文件夹。如果是子文件夹，则连同父级目录一块儿新建。
     * @param directoryPath 新文件夹的目录
     * @param autoRename 是否在有重名文件夹的情况下自动修改新文件夹名称
     * @return true 如果新建成功；false 如果文件夹已存在、不允许被创建、非法命名或其他原因导致创建失败
     */
    public static boolean createFolder(String directoryPath, boolean autoRename)
    {
        String finalName = directoryPath;
        File folder = new File(directoryPath);
        if(folder.exists())
        {
            if(autoRename)
            {
                if(finalName.endsWith("/") || finalName.endsWith("\\"))
                    finalName = finalName.substring(0, finalName.length() - 1) + "_new";
                else
                    finalName += "_new";
                folder = new File(finalName);
            }
            else
                return false;
        }
        
        folder.mkdirs();
        
        return folder.exists() && folder.isDirectory();
    }

    /**
     * 删除一个文件夹。如果是子文件夹，则询问是否连同父级目录一块儿删除。
     * 层级删除使用递归，效率略低。
     * @param directoryPath 文件夹的目录
     * @param inquiry 删除前是否询问
     * @return true 如果删除成功；false 如果由于文件夹不存在、不允许访问或其他原因导致删除失败
     */
    public static boolean deleteFolder(String directoryPath, boolean inquiry)
    {
        File folder = new File(directoryPath);
        String[] tempList = folder.list();
        boolean readyToDelete = false;
        
        if(inquiry)
        {
            int choice = JOptionPane.showConfirmDialog(null, "Are you sure to delete?\n" + directoryPath, "Confirmation required",
                    JOptionPane.YES_NO_CANCEL_OPTION);
            if(choice == JOptionPane.YES_OPTION)
                readyToDelete = true;
            else
                return false;
        }
        else
            readyToDelete = true;
        
        if(readyToDelete)
        {
            File current = null;
            for(int i = 0; i < tempList.length; i++)
            {
                if(directoryPath.endsWith(File.separator))
                    current = new File(directoryPath + tempList[i]);
                else
                    current = new File(directoryPath + File.separator + tempList[i]);
                if(current.isFile())
                    current.delete();
                if(current.isDirectory())
                {
                    deleteFolder(directoryPath + "/" + tempList[i], false);
                    new File(directoryPath + "/" + tempList[i]).delete();
                }
            }
            folder.delete();
        }

        if(!folder.exists())
            return true;
        
        return false;
    }
    
    /**
     * 创建一个文件。如果需要包含此文件的文件夹不存在则也自动新建。
     * @param filePath 新文件的目录
     * @param contents 新文件的内容
     * @param autoRename 是否在有重名文件的情况下自动修改新文件名称
     * @return true 如果创建文件成功；false 如果由于当前环境只读或其他原因导致创建文件失败
     */
    public static boolean createFile(String filePath, String contents, boolean autoRename)
    {
        String finalName = filePath;
        File file = new File(filePath);
        if(file.exists())
        {
            if(autoRename)
            {
                finalName = filePath.substring(0, filePath.lastIndexOf('.')) + "_new" + filePath.substring(filePath.lastIndexOf('.'));
                file = new File(finalName);
            }
            else
                return false;
        }
        
        try(FileWriter writer = new FileWriter(finalName))
        {
            writer.write(contents);
        }
        catch(Exception e)
        {
            e.printStackTrace();
            return false;
        }
        
        return true;
    }
    
    /**
     * 去掉某个字符串的后缀斜杠。
     * @param s 要被处理的字符串
     * @return 去掉了一切作为后缀的斜杠的字符串
     */
    private static String trimSlashes(String s)
    {
        int i = s.length() - 1;
        for(; i > 0; i--)
        {
            if(!(s.charAt(i) == '/' || s.charAt(i) == '\\'))
                break;
        }
        
        return s.substring(0, i + 1);
    }
    
    /**
     * 删除一个文件。
     * @param directoryPath 文件的目录
     * @param inquiry 删除前是否询问
     * @return true 如果删除成功；false 如果由于文件不存在、不允许访问或其他原因导致删除失败
     */
    public static boolean deleteFile(String directoryPath, boolean inquiry)
    {
        String trimmed = trimSlashes(directoryPath);
        File file = new File(trimmed);
        boolean readyToDelete = false;
        
        if((!file.exists()) || (!file.isFile()))
            return false;
        if(inquiry)
        {
            int choice = JOptionPane.showConfirmDialog(null, "Are you sure to delete?\n" + trimmed, "Confirmation required",
                    JOptionPane.YES_NO_CANCEL_OPTION);
            if(choice == JOptionPane.YES_OPTION)
                readyToDelete = true;
            else
                return false;
        }
        else
            readyToDelete = true;
        
        boolean result = false;
        if(readyToDelete)
            result = file.delete();
        
        return result;
    }
    
    /**
     * 将一个文件重命名。
     * @param directoryPath 文件的目录
     * @param newName 新的文件名（不包括路径）
     * @param inquiry 重命名前是否询问
     * @return true 如果重命名成功；false 如果由于文件正被使用、受到安全类软件保护等原因导致文件重命名失败
     */
    public static boolean renameFile(String directoryPath, String newName, boolean inquiry)
    {
        String trimmedPath = trimSlashes(directoryPath);
        String trimmedName = trimSlashes(newName);
        File file = new File(trimmedPath);
        boolean readyToRename = false;
        
        if((!file.exists()) || (!file.isFile()))
            return false;
        if(inquiry)
        {
            int choice = JOptionPane.showConfirmDialog(null, "Are you sure to rename?\n" + trimmedPath + "\n>>>  >>>\n" + trimmedName,
                    "Confirmation required", JOptionPane.YES_NO_CANCEL_OPTION);
            if(choice == JOptionPane.YES_OPTION)
                readyToRename = true;
            else
                return false;
        }
        
        boolean result = false;
        if(readyToRename)
            result = file.renameTo(new File(trimmedPath.substring(0, trimmedPath.indexOf(File.separatorChar)) + trimmedName));
        
        return result;
    }
    
    /**
     * 获得并放置一个文件的副本。
     * @param directoryPath 源文件的路径
     * @param destinyPath 副本的路径
     * @return true 如果文件复制成功；false 如果由于文件受到安全类软件保护或磁盘空间不足等原因导致文件文件复制失败
     */
    public static boolean copyFile(String directoryPath, String destinyPath)
    {
        String trimmedDir = trimSlashes(directoryPath);
        String trimmedDest = trimSlashes(destinyPath);
        File original = new File(trimmedDir);
        File copied = new File(trimmedDest);
        try
        {
            Files.copy(original.toPath(), copied.toPath());
        }
        catch (IOException e)
        {
            e.printStackTrace();
            return false;
        }
        
        return original.length() == copied.length();
    }
    
    /**
     * 获得并放置一个文件的副本，然后删除源文件。
     * @param directoryPath 源文件的路径
     * @param destinyPath 副本的路径
     * @return true 如果文件剪切成功；false 如果由于文件受到安全类软件保护或磁盘空间不足等原因导致文件文件剪切失败
     */
    public static boolean cutFile(String directoryPath, String destinyPath)
    {
        File original = new File(directoryPath);
        long length = original.length();
        File cut = new File(destinyPath);
        
        copyFile(directoryPath, destinyPath);
        deleteFile(directoryPath, false);
        
        return (!original.exists()) && cut.exists() && cut.length() == length;
    }
}