/*★★★
====第三题====================================
编写一个程序，当用户输入一个目录时，
该程序能列出该目录下的所有子目录和文件，拷贝这个文件夹内容到用户指定目录下。
要求不能改变文件夹的结构，也就是不能把根文件写入一个文件夹下面。
*/
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.InputStreamReader;
import java.io.FileOutputStream;
import java.io.FileInputStream;
public class FolderFilesCopy{
        public static void main(String[]args)throws Exception{
                BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
                String s=br.readLine();
                br=new BufferedReader(new InputStreamReader(System.in));
                String s2=br.readLine();
                getFolder(s,s2);
                //List<File> list = new ArrayList<File>();       
                       
               
        }
        public static void getFolder(String s,String s2)throws Exception{
                String num="[a-zA-Z]";
               
                File[] f =new File(s).listFiles();
                BufferedInputStream bis=null;
                BufferedOutputStream bos=null;
                for(File fi:f){
                        if(fi.isDirectory())
                                getFolder(fi.getAbsolutePath(),s2);
                        bis= new BufferedInputStream(new FileInputStream(fi.getAbsolutePath()));
                        bos=new BufferedOutputStream(new FileOutputStream(fi.getAbsolutePath().replaceAll(num, s2)+fi.getName()));//这边没办法得到新的写入路径，程序停止
                        byte[] buf = new byte[1024];
                        int line=0;
                        while((line=bis.read(buf))!=-1){       
                                System.out.println(fi.getAbsoluteFile());
                                bos.write(buf,0,line);
                                bos.flush();
                        }
                       
                }
                bis.close();
                bos.close();
               
        }
}

import java.io.*;
class  CopyDir
{
public static void main(String[] args) throws Exception
{
  String fouName="e:"+File.separator+"dir";//为了实现跨平台故分隔符用了File.separator
  String desName="f:";//copy的目标地址;
  //获取源文件的文件夹的名称;并和目标地址在生成一个新的文件夹目录;
  desName=desName+File.separator+fouName.substring(fouName.lastIndexOf("\\")+1);
  showDir(fouName,desName);
}
public static void showDir(String fouName,String desName)throws Exception
{
  File fileDir=new File(fouName);
  File fileDir2=new File(desName);
  fileDir2.mkdir();//目标目录;
  File[] fileDirs=fileDir.listFiles();//用递归的方法遍历目录
  for (int x=0;x<fileDirs.length ;x++ )
  {
   if (fileDirs[x].isDirectory())//如果是一个目录,
   {
    String dirName=fileDirs[x].getAbsolutePath();//获取该目录的名称
    //截取该目录的名称
    String dirName2=dirName.substring(dirName.lastIndexOf("\\"));
    //和目标地址重组 以便在目标地址上重建一个一样的目录
    dirName2=desName+dirName2;
    showDir(fileDirs[x].getPath(),dirName2);//递归
    //子目录遍历完成后回到根目录下;
    dirName2=desName;
   }
   else//如果是一个文件
   {
    String name=fileDirs[x].getName();//获取文件名称
    FileInputStream fis=new FileInputStream(fouName+"\\"+name); //在源目录下读取文件
    FileOutputStream fos=new FileOutputStream(desName+"\\"+name);//把源文件写入目标目录
    copy(fis,fos);
   }
  }
  
}
public static void copy(FileInputStream fis,FileOutputStream fos)throws Exception
{
  byte[] buf=new byte[1024*1024*10];
  int len=0;
  while ((len=fis.read(buf))!=-1)
  {
   fos.write(buf,0,len);
  }
}
}

其实方法都差不多一定是用递归来的，你首先是要把思路理清楚。文件夹内可能嵌套很多文件夹，所以没嵌套一个文件夹就要调用一个复制文件的方法，然后把新的路径给它，具体你看我的代码，这是我做的一个android文件管理器的一部分复制文件的代码，很简单相信你一看就懂。
首先我们调用的一定是第一个方法，传入两个路径：1.需要复制的文件 2.复制到什么地方。
方法内判断如果是文件就调用pastefile（）方法，这个方法会直接复制。
如果是文件夹就调用pastedir（）方法，这个方法会去遍历文件夹下所有的文件然后再次做出判断是文件的就穿个paste（）方法去直接复制，文件夹就再次递归，createfile（）方法和creatdir方法都是配合pastefile（）和pastedir（）来使用的，这个我就不多说了。
        public void paste(File copyFile, File file) throws IOException {
                // TODO Auto-generated method stub
                if(copyFile.isFile()&&file.isDirectory())
                {
                        //如果是文件
                        pasteFile(copyFile,file);
                }
                else if(file.isDirectory())
                {
                        //如果是文件夹
                        pasteDir(copyFile,file);
                }
        }
        private void pasteDir(File copyFile, File file) throws IOException {
                // TODO Auto-generated method stub
                File newdir = creatDir(copyFile,file);
                File files[] = copyFile.listFiles();
                for(int i = 0 ; i < files.length ; i ++)
                {
                        if(files[i].isFile())
                        {
                                paste(files[i], newdir);
                        }
                        else
                        {
                                pasteDir(files[i],newdir);
                        }
                }
        }
        private File creatDir(File copyFile, File file) {
                // TODO Auto-generated method stub
                File newDir = new File(file,copyFile.getName());
                newDir.mkdir();
                return newDir;
        }
        private File createFile(File copyFile, File file) throws IOException {
                // TODO Auto-generated method stub
                File newFile = new File(file,copyFile.getName());
                newFile.createNewFile();
                return newFile;
        }
        private void pasteFile(File copyFile, File file) throws IOException {
                File newfile = createFile(copyFile,file);
                BufferedInputStream inBuff = null;
        BufferedOutputStream outBuff = null;
        try {
            // 新建文件输入流并对它进行缓冲
            inBuff = new BufferedInputStream(new FileInputStream(copyFile));

            // 新建文件输出流并对它进行缓冲
            outBuff = new BufferedOutputStream(new FileOutputStream(newfile));

            // 缓冲数组
            byte[] b = new byte[1024 * 5];
            int len;
            while ((len = inBuff.read(b)) != -1) {
                    inBuff.read(b);
                outBuff.write(b, 0, len);
            }
            // 刷新此缓冲的输出流
            outBuff.flush();
        } finally {
            // 关闭流
            if (inBuff != null)
                inBuff.close();
            if (outBuff != null)
                outBuff.close();
        }
        }