java实现文件夹增量同步复制

最新推荐文章于 2024-07-05 11:37:43 发布

跟着半仙学java

最新推荐文章于 2024-07-05 11:37:43 发布

阅读量1.1k

点赞数 2

分类专栏：基础学习文章标签： java

本文链接：https://blog.csdn.net/olengyuehun/article/details/108462454

版权

基础学习专栏收录该内容

3 篇文章 0 订阅

订阅专栏

/**
     * 复制单个文件从srcPath到desPath
     *
     * @param srcPath
     * @param desPath
     */
    public void copyFile(String srcPath, String desPath) {
        try {
            //创建输入输出流对象
            FileInputStream fis = new FileInputStream(srcPath);
            FileOutputStream fos = new FileOutputStream(desPath);
            byte datas[] = new byte[1024 * 2];  //搬运工具
            int len = 0;
            while ((len = fis.read(datas)) != -1) {// 读取数据
                fos.write(datas, 0, len);
            }
            //释放资源
            fis.close();
            fis.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 文件夹A-->B前比较出A中有而B中没有的文件路径映射
     *
     * @param fileMapA
     * @param fileMapB
     */
    public Map<String, File> compoareFileMap(Map<String, File> fileMapA, Map<String, File> fileMapB) {
        Map<String, File> fileMap = new HashMap<String, File>();
        try {
            for (String path : fileMapA.keySet()) {
                if (fileMapB.get(path) == null) {
                    fileMap.put(path, fileMapA.get(path));//(相对路径,子文件路径)
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        int i = 0;
        for (String relative: fileMap.keySet()) {
            i++;
        }
        System.out.println("一共有"+i+"个文件不同，将检查文件最后修改时间");
        return fileMap;//A中有而B中没有的文件路径映射
    }

    /**
     * 根据A中有而B中没有的文件路径映射将云映射对应的文件复制到B中去
     *
     * @param fileMap
     * @param sourcePath
     * @param desFilePath 目标文件夹
     */
    public void copyFilesByMap(Map<String, File> fileMap, String sourcePath, String desFilePath,int time) {
        try {
            File desFile = new File(desFilePath);
            if (!desFile.exists()) {
                desFile.mkdirs();
            }
            for (String srcfileRelativePath : fileMap.keySet()) {
                File srcFile = fileMap.get(srcfileRelativePath);
                File srcParentFile = srcFile.getParentFile();
                String srcParentFilePath = srcParentFile.getPath();
                String parentRelativePath = srcParentFilePath.substring(sourcePath.length(), srcParentFilePath.length());
                File desParentFile = new File(desFilePath + "\\" + parentRelativePath);
                if (!desParentFile.isDirectory()) {
                    desParentFile.mkdirs();
                }

                /**
                 * 根据文件最后修改时间判定是否需要复制
                 * */
                long srcFileTime = srcFile.lastModified();
                //System.out.println(srcFileTime);
                System.out.println((System.currentTimeMillis()-srcFileTime)/60000);
                if((System.currentTimeMillis()-srcFileTime)/60000<time){//如果文件最后修改时间不足time，则复制
                    copyFile(sourcePath + srcfileRelativePath, desFilePath + srcfileRelativePath);
                    System.out.println("复制"+sourcePath + srcfileRelativePath + "--到-->" + desFilePath + srcfileRelativePath+"完毕");
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取某文件夹中所有文件的路径映射
     *
     * @param file 子文件夹
     * @param fileMap 文件映射
     * @param sourceFilePath 总文件夹路径
     * @return fileMap
     */
    public Map<String, File> getFileMap(File file, Map<String, File> fileMap, String sourceFilePath) {
        try {
            for (int i = 0; i < file.listFiles().length; i++) {
                File childFile = file.listFiles()[i];
                if (!childFile.isDirectory()) {//子文件直接放入映射
                    String chileFilePath = childFile.getPath();//子文件路径
                    String relativePath = chileFilePath.substring(sourceFilePath.length(), chileFilePath.length());//子文件路径减去总文件路径的相对路径
                    fileMap.put(relativePath, childFile);
                } else {//子文件夹迭代
                    getFileMap(childFile, fileMap, sourceFilePath);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return fileMap;
    }

public class Test {

    public static void main(String[] args){
       FileCopyDao fileCopyDao = new FileCopyDaoImpl();
        try{
            Map<String, File> fileMap = new HashMap<String,File>();
            File file1 = new File("D:\\testspace\\thunder");
            File file2 = new File("D:\\testspace\\thunder2");
            Map<String, File> fileMap1 = fileCopyDao.getFileMap(file1,fileMap,file1.getPath());
            System.out.println("扫描"+file1+"完毕");
            fileMap = new HashMap<String,File>();
            Map<String, File> fileMap2 = fileCopyDao.getFileMap(file2,fileMap,file2.getPath());
            System.out.println("扫描"+file2+"完毕");
            Map<String,File> map = fileCopyDao.compoareFileMap(fileMap1,fileMap2);
            fileCopyDao.copyFilesByMap(map,file1.getPath(),file2.getPath(),180);//复制三个小时内新建文件
            System.out.print(1);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}