如何使用java代码移动文件夹及文件呢?

实现思路:
    1.复制文件及文件夹
	2.删除源文件及文件夹
	采用以上方式,即可实现文件夹及文件的移动操作

package com.java265;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.channels.FileChannel;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
 
public class fileUtill {
 
	public static void main(String[] args) {
		 File source = new File("D:/file");  
		 File dest = new File("D:/file1"); 
        for (int i = 0; i < 5; i++) {
            copy(source, dest);
        }
        File srcFile2 = new File("D:/file");
        File srcFile3 = new File("D:/file/copy1");
        File srcFile4 = new File("D:/file/copy2");
        File dstDir2 = new File("D:/file");
        move(srcFile2, dstDir2);
        move(srcFile3, dstDir2);
        move(srcFile4, dstDir2);
        delete(srcFile2);
 
		 
		
	}
	//------------------------------1-----------------------------------------
	//移动指定文件
	private static void moveTotherFolders(String resource,String target,String pathName){
	    String startPath = resource + File.separator + pathName;
	    String endPath = target + File.separator;
	    try {
	        File startFile = new File(startPath);
	        File tmpFile = new File(endPath);//获取文件夹路径
	        if(!tmpfile.exists()){//判断文件夹是否创建，没有创建则创建新文件夹
	            tmpFile.mkdirs();
	        }
	        System.out.println(endPath + startFile.getName());
	        if (startFile.renameTo(new File(endPath + startFile.getName()))) {
	            System.out.println("File is moved successful!");
	           
	        } else {
	            System.out.println("File is failed to move!");
	            
	        }
	    } catch (Exception e) {
	        
	    }
	}
	
	
	//------------------------------------------2----------------------------
	 // 删除某个目录及目录下的所有子目录和文件 
	  public static boolean deleteDir(File Folders) { 
	    // 如果是文件夹 
	    if (Folders.isDirectory()) { 
	      // 则读出该文件夹下的的所有文件 
	      String[] children = Folders.list(); 
	      // 递归删除目录中的子目录下 
	      for (int i = 0; i < children.length; i++) { 
	          
	        boolean isDelete = deleteDir(new File(Folders, children[i])); 
	        // 如果删完了，没东西删，isDelete==false的时候，则跳出此时递归 
	        if (!isDelete) { 
	          return false; 
	        } 
	      } 
	    } 
	    // 读到的是一个文件或者是一个空目录，则可以直接删除 
	    return Folders.delete(); 
	  } 
	 
	  /**
	   * 复制某个目录及目录下的所有子目录和文件到新文件夹 
	   * @param resource  源目录
	   * @param target    目标目录
	   */
	  public static void copyFolder(String resource, String target) { 
	    try { 
	      // 如果文件夹不存在，则建立新文件夹 
	      (new File(target)).mkdirs(); 
	      // 读取整个文件夹的内容到file字符串数组，下面设置一个游标i，不停地向下移开始读这个数组 
	      File filelist = new File(resource); 
	      String[] file = filelist.list(); 
	      // 要注意，这个temp仅仅是一个临时文件指针 
	      // 整个程序并没有创建临时文件 
	      File temp = null; 
	      for (int i = 0; i < file.length; i++) { 
	        // 如果oldPath以路径分隔符/或者\结尾，那么则oldPath/文件名就可以了 
	        // 否则要自己oldPath后面补个路径分隔符再加文件名 
	        // 谁知道你传递过来的参数是f:/a还是f:/a/啊？ 
	        if (resource.endsWith(File.separator)) { 
	          temp = new File(resource + file[i]); 
	        } else { 
	          temp = new File(resource + File.separator + file[i]); 
	        } 
	 
	        // 当游标遇到文件 
	        if (temp.isFile()) { 
	          FileInputStream input = new FileInputStream(temp); 
	          // 复制并且改名 
	          FileOutputStream output = new FileOutputStream(target 
	              + "/" + "rename_" + (temp.getName()).toString()); 
	          byte[] bufferarray = new byte[1024 * 64]; 
	          int prereadlength; 
	          while ((prereadlength = input.read(bufferarray)) != -1) { 
	            output.write(bufferarray, 0, prereadlength); 
	          } 
	          output.flush(); 
	          output.close(); 
	          input.close(); 
	        } 
	        // 当游标遇到文件夹 
	        if (temp.isDirectory()) { 
	          copyFolder(resource + "/" + file[i], target + "/" + file[i]); 
	        } 
	      } 
	    } catch (Exception e) { 
	      System.out.println("复制整个文件夹内容操作出错"); 
	    } 
	  } 
	 
	  public static void moveFolder(String oldPath, String newPath) { 
	    // 先复制文件 
	    copyFolder(oldPath, newPath); 
	    // 则删除源文件，以免复制的时候错乱 
	    deleteDir(new File(oldPath)); 
	  } 
	
	//----------------------------3-------------------------------------------
	    /**
	     * 移动(剪切)文件
	     *
	     * @param resource  源目录
	     * @param target    目标目录
	     * @return
	     */
	    public static boolean moveFile(File resource, File target) {
	        if (!resource.exists() || resource.isDirectory()) {
	            return false;
	        }
	        if (!target.exists()) {
	        	target.mkdirs();
	        }
	        String oldFileName = resource.getName();
	        File newFile = new File(target, oldFileName);
	        if (resource.renameTo(newFile)) {// 直接重命名绝对路径速度更快
	            return true;
	        } else {// 文件已经存在，需要自动编号复制再删除源文件
	            copyFile(resource, target);
	            resource.delete();
	        }
	        return true;
	    }
 
	    /**
	     * 移动文件或文件夹
	     * 如果目标文件夹不存在则自动创建
	     * 如果文件或文件夹已经存在则自动编号-copy n
	     * @param resource    源文件或文件夹绝对路径
	     * @param target      目标文件夹绝对路径
	     * @return 是否成功移动文件或文件夹
	     */
	    public static boolean move(File resource, File target) {
	        if (!resource.exists()) {
	            return false;
	        }
	        if (!target.exists()) {
	        	target.mkdirs();
	        }
	        if (resource.isFile()) {// 文件
	            moveFile(resource, target);
	        } else {// 文件夹
	            String oldSrcName = resource.getName();
	            int srcNumber = 0;
	            File newSrcDir = new File(target, oldSrcName);
	            while (newSrcDir.exists()) {
	                srcNumber++;
	                String newSrcName = oldSrcName + "-copy" + srcNumber;
	                newSrcDir = new File(target, newSrcName);
	            }
	            newSrcDir.mkdirs();
	            for (File srcSub : resource.listFiles()) {
	                move(srcSub, newSrcDir);// 递归移动源文件夹下子文件和文件夹
	            }
	            resource.delete();
	        }
	        return true;
	    }
	    
	    /**
	     * 复制文件
	     * 从源路径到目标文件夹路径，文件名保持一致
	     * 如果目标文件夹不存在则自动创建
	     * 如果文件已经存在则自动编号-copy n
	     * @param resource 源文件绝对路径
	     * @param target  目标文件夹绝对路径
	     * @return 是否成功复制文件
	     */
	    public static boolean copyFile(File resource, File target) {
	        if (!resource.exists() || resource.isDirectory()) {
	            return false;
	        }
	        if (!target.exists()) {
	        	target.mkdirs();
	        }
	        String oldFileName = resource.getName();
	        Pattern suffixPattern = Pattern.compile("\\.\\w+");
	        Matcher matcher = suffixPattern.matcher(oldFileName);
	        String nameBody;
	        String suffix;
	        if (matcher.find()) {
	            nameBody = oldFileName.substring(0, matcher.start());
	            suffix = oldFileName.substring(matcher.start());
	        } else {
	            nameBody = oldFileName;
	            suffix = "";
	        }
	        int fileNumber = 0;
	        File newFile = new File(target, oldFileName);
	        while (newFile.exists()) {
	            fileNumber++;
	            String newFileName = nameBody + "-copy" + fileNumber + suffix;
	            newFile = new File(target, newFileName);
	        }
	        try {
	            FileChannel fileIn = new FileInputStream(resource).getChannel();
	            FileChannel fileOut = new FileOutputStream(newFile).getChannel();
	            fileIn.transferTo(0, fileIn.size(), fileOut);
	            fileIn.close();
	            fileOut.close();
	        } catch (IOException e) {
	            return false;
	        }
	        return true;
	    }
 
	    /**
	     * 复制文件或文件夹
	     * 如果目标文件夹不存在则自动创建
	     * 如果文件或文件夹已经存在则自动编号-copy n
	     * @param resource    源文件或文件夹绝对路径
	     * @param target 目标文件夹绝对路径
	     * @return 是否成功复制文件或文件夹
	     */
	    public static boolean copy(File resource, File target) {
	        if (!resource.exists()) {
	            return false;
	        }
	        if (!target.exists()) {
	        	target.mkdirs();
	        }
	        if (resource.isFile()) {// 文件
	            copyFile(resource, target);
	        } else {// 文件夹
	            String oldSrcName = resource.getName();
	            int srcNumber = 0;
	            File newSrcDir = new File(target, oldSrcName);
	            while (newSrcDir.exists()) {
	                srcNumber++;
	                String newSrcName = oldSrcName + "-copy" + srcNumber;
	                newSrcDir = new File(target, newSrcName);
	            }
	            newSrcDir.mkdirs();
	            for (File srcSub : resource.listFiles()) {
	                copy(srcSub, newSrcDir);// 递归复制源文件夹下子文件和文件夹
	            }
	        }
	        return true;
	    }
	    
	    /**
	     * 删除文件或文件夹
	     * @param src 源文件或文件夹绝对路径
	     * @return 是否成功删除文件或文件夹
	     */
	    public static boolean delete(File src) {
	        if (!src.exists()) {
	            return false;
	        }
	        if (src.isFile()) {
	            src.delete();
	        } else {
	            for (File srcSub : src.listFiles()) {
	                delete(srcSub);// 递归删除源文件夹下子文件和文件夹
	            }
	            src.delete();
	        }
	        return true;
	    }
}