Java-利用递归复制文件夹

第一种：
参考：https://blog.csdn.net/seebetpro/article/details/50365999

测试类:

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.util.Scanner;
 
public class Test {
 
	private String inputPath= "H:/C++/input/";//定义要复制的源路径
	private String outputPath="H:/C++/output";//定义目标路径
	public static void main(String[] args) {
		Test test = new Test();
		Copy copy = new Copy(test.inputPath, test.outputPath);
		
	}
 
}

Copy类:

import java.awt.List;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.time.chrono.IsoChronology;
import java.util.Scanner;
 
public class Copy {
 
	private String inputPath;
	private String outputPath;
 
	public Copy(String inputPath, String outputPath) {
		super();
		this.inputPath = inputPath;
		this.outputPath = outputPath;
 
		isCopy(inputPath, outputPath);
 
	}
 
	/**
	 * 是否复制
	 * @param PathInput
	 * @param PathOutput
	 */
	
	public void isCopy(String PathInput, String PathOutput) {
 
		File inputFile = new File(PathInput);//使用局部变量
		File outputFile = new File(PathOutput);//使用局部变量
		if (inputFile.isDirectory()) {
			//每次进入一个新的源文件夹都在目标文件夹中建立相应的文件夹
			outputFile = new File(outputFile.getPath() + File.separator
					+ inputFile.getName());
			
 
			outputFile.mkdirs();
 
			String[] fileArray = inputFile.list();
 
			for (int i = 0; i < fileArray.length; i++) {
 
				System.out.println("========>" + fileArray[i]);
 
			}
 
			for (int i = 0; i < fileArray.length; i++) {
				isCopy(inputFile.getPath() + File.separator + fileArray[i],
						outputFile.getPath());
			}
		} else {
			File tempOutputFile = new File(outputFile.getPath()
					+ File.separator + inputFile.getName());
			try {
				tempOutputFile.createNewFile();
			} catch (IOException e) {
				e.printStackTrace();
			}
			doCopy(inputFile, tempOutputFile);
			System.out.println("inputFile路径:" + inputFile.getPath());
			System.out.println("outputFile路径:" + outputFile.getPath());
		}
	}
	/**
	 * 文件的复制
	 * @param inputFile
	 * @param outputFile
	 */
	public void doCopy(File inputFile, File outputFile) {
		try {
			int byteread = 0;
			InputStream inputStream = new FileInputStream(inputFile);
			FileOutputStream fileOutputStream = new FileOutputStream(outputFile);
			byte[] buffer = new byte[1024];
			while ((byteread = inputStream.read(buffer)) != -1) {
				
				fileOutputStream.write(buffer, 0, byteread);
			}
			inputStream.close();
			fileOutputStream.close();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

第二种：
参考：java递归复制文件及文件夹

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.File;
import java.io.InputStream;
import java.io.OutputStream;
public class copy {
    public static void main(String[] args) throws IOException {
        
        File s = new File("../Test");
        File t = new File("../yang");
        copyFolder(s,t);
    }
    /**
     * 复制一个目录及其子目录、文件到另外一个目录
     * @param src
     * @param dest
     * @throws IOException
     */  
    static void copyFolder(File src, File dest) throws IOException {  
        if (src.isDirectory()) {  
            if (!dest.exists()) {  
                dest.mkdir();  
            }  
            String files[] = src.list();  
            for (String file : files) {  
                File srcFile = new File(src, file);  
                File destFile = new File(dest, file);  
                // 递归复制  
                copyFolder(srcFile, destFile);  
            }  
        } else {  
            InputStream in = new FileInputStream(src);  
            OutputStream out = new FileOutputStream(dest);  
      
            byte[] buffer = new byte[1024];  
      
            int length;  
              
            while ((length = in.read(buffer)) > 0) {  
                out.write(buffer, 0, length);  
            }  
            in.close();  
            out.close();  
        }  
    }  
}

第三种：
这篇文章主要介绍了Java使用递归复制文件夹及文件夹,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
递归调用copyDir方法实现，查询源文件目录使用字节输入流写入字节数组，如果目标文件目录没有就创建目录，如果迭代出是文件夹使用字节输出流对拷文件，直至源文件目录没有内容。

参考;Java使用递归复制文件夹及文件夹

递归调用copyDir方法实现，查询源文件目录使用字节输入流写入字节数组，如果目标文件目录没有就创建目录，如果迭代出是文件夹使用字节输出流对拷文件，直至源文件目录没有内容。

/**
   * 复制文件夹
   * @param srcDir 源文件目录
   * @param destDir 目标文件目录
   */
  public static void copyDir(String srcDir, String destDir) {
    if (srcRoot == null) srcRoot = srcDir;
    //源文件夹
    File srcFile = new File(srcDir);
    //目标文件夹
    File destFile = new File(destDir);
    //判断srcFile有效性
    if (srcFile == null || !srcFile.exists())
      return;
    //创建目标文件夹
    if (!destFile.exists())
      destFile.mkdirs();
    //判断是否是文件
    if (srcFile.isFile()) {
      //源文件的绝对路径
      String absPath = srcFile.getAbsolutePath();
      //取出上级目录
      String parentDir = new File(srcRoot).getParent();
      //拷贝文件
      copyFile(srcFile.getAbsolutePath(), destDir);
 
    } else {  //如果是目录
      File[] children = srcFile.listFiles();
      if (children != null) {
        for (File f : children) {
          copyDir(f.getAbsolutePath(), destDir);
        }
      }
    }
  }
  }

/**
   * 复制文件夹
   *
   * @param path  路径
   * @param destDir 目录
   */
  public static void copyFile(String path, String destDir) {
 
    FileInputStream fis = null;
    FileOutputStream fos = null;
    try {
       /*
        准备目录
        取出相对的路径
        创建目标文件所在的文件目录
       */
      String tmp = path.substring(srcRoot.length());
      String folder = new File(destDir, tmp).getParentFile().getAbsolutePath();
      File destFolder = new File(folder);
      destFolder.mkdirs();
      System.out.println(folder);      //创建文件输入流
      fis = new FileInputStream(path);
      //定义新路径
      //创建文件 输出流
      fos = new FileOutputStream(new File(destFolder,new File(path).getName()));
      //创建字节数组进行流对拷
      byte[] buf = new byte[1024];
      int len = 0;
      while ((len = fis.read(buf)) != -1) {
        fos.write(buf, 0, len);
      }
    } catch (IOException ex) {
      ex.printStackTrace();
    } finally {
      try {
        fis.close();
        fos.close();
      } catch (IOException e) {
        e.printStackTrace();
      }
    }
  }