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

　　这个工具类，用线程的方式实现文件的复制，效果勉强还算可以。功能不够完善。

　　根据两个路径字符串(文件路径或文件夹路径),实现文件的复制，具体用的方法，注释还算清楚。

package cn.util;

import java.io.*;

/**
 * 线程的方式实现文件的复制(内部类不能实现继承和实现，匿名内部类又不能新增方法)。
 * 
 * @version 1
 * @author JXLYS
 */
public class FileUtil extends Thread {

    static class FileUtilHelp {
        private static FileUtil[] farr = new FileUtil[5];// 线程数量(java默认线程最多10)

        public static void createThread(File f1, File f2) {
            int i = 0;
            for (FileUtil f : farr) {
                if (f == null || !f.isAlive()) {
                    farr[i] = new FileUtil().copyThread(f1, f2);
                    farr[i].start();
                }
                i++;
            }
        }

    }

    private FileUtil() {
    }

    // 创建路径
    private static void createMkdirs(String path) {

        File f = new File(path);
        if (!f.exists()) {
            f.mkdirs();
        }
    }

    /**
     * 复制文件到指定路径(可创建路径)
     * 
     * @param fileName
     *            文件名
     * @param path
     *            路径
     * @param override
     *            覆盖
     * @return
     */
    public static boolean copyFileToPath(String fileName, String path, boolean override) {
        File f1 = new File(fileName);
        if (f1.exists()) {
            createMkdirs(path);
            createFileAndCopy(f1, new File(path, f1.getName()), override);
            return true;
        }
        return false;
    }

    /**
     * 复制指定路径下所有文件到指定路径(建议大文件不要太多)
     * 
     * @param path1
     *            路径1
     * @param path2
     *            路径2
     * @return
     */
    public static boolean copyPathToPath(String path1, String path2, boolean override) {
        File f1 = new File(path1);
        if (f1.exists() && f1.isDirectory()) {
            createMkdirs(path2);
            File[] farr = f1.listFiles();
            for (File f : farr) {
                try {
                    Thread.sleep(10);// 一次性复制超过5个，五个线程顶不住，不想让主线程等待则可以删除这等待。
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                copyFileToPath(f.getAbsolutePath(), path2, override);
            }
            return true;
        }
        return false;
    }

    // 创建文件并复制
    private static void createFileAndCopy(File f1, File f2, boolean b) {

        if (!f2.exists()) {
            try {
                f2.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        } else {
            if (!b)
                return;
        }
        FileUtilHelp.createThread(f1, f2);
    }

    /**
     * 复制文件1到文件2(可以创建路径)
     * 
     * @param fileName
     *            文件1
     * @param fileName2
     *            文件2
     * @param override
     *            是否覆盖
     * @return
     */
    public static boolean copyFile(String fileName, String fileName2, boolean override) {
        File f1 = new File(fileName);
        if (f1.exists()) {
            File f2 = new File(fileName2);
            createMkdirs(f2.getParent());
            createFileAndCopy(f1, f2, override);
            return true;
        }
        return false;
    }

    public static void main(String[] args) {
        FileUtil.copyPathToPath("./1", "./2", true);
    }

    private File f1;
    private File f2;

    public FileUtil copyThread(File f1, File f2) {
        this.f1 = f1;
        this.f2 = f2;
        return this;
    }

    public void run() {
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            bis = new BufferedInputStream(new FileInputStream(f1));
            bos = new BufferedOutputStream(new FileOutputStream(f2));
            byte[] barr = new byte[1024];
            int len = 0;
            while ((len = bis.read(barr)) != -1) {
                bos.write(barr, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (bis != null)
                try {
                    bis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            if (bos != null)
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
        }
    }
}

不能在构造方法里抛出异常，好难受。