public class rr {

         public static void main(String[] args) {
               
                 File file = new File("E:\\workspace");
                 List  data = new ArrayList();
                 data=showDir(file,data); //我把想要的java文件存在集合里面了， 现在data集合里面装的是文件，我怎么用流把集合里面装的文件复制到我的其它盘的xx文件夹下啊？
                  
                 
                 for (Object ff : data) {
                        
                  
                        
                }
                  
                  
        }
         
         public static List  showDir(File f,List data){
                 
                 File[] fi =f.listFiles();
                 for(int i=0;i<fi.length;i++){
                  if(fi.isDirectory()){
                          
                            showDir(fi,data);
                           
                  }else{
                          
                           if(fi.getName().endsWith(".java")){
                                   
                                  // System.out.println(fi.getName());
                                   
                                   data.add(fi.getName());
                           }
                           
                  }         
                  
                 }
                 return data;
         }
                  
}

哪位大侠帮帮忙啊， 琢磨2小时了。。。 {:soso_e118:}

这个是我写的一个拷贝某文件夹中的.java文件到另个文件夹中，拷贝后要保持原文件夹的目录。

楼主可以参考参考。

1. 
   
2. /**
   
3. *         拷贝某文件夹中的.java文件到另个文件夹中，拷贝后要保持源文件夹的目录。
   
4. *         思路：
   
5. *                 1)定义拷贝文件的函数，接收两个文件参数（源和目标）
   
6. *                 2)对源目录进行判断，不存在，抛异常,如果存在，先判断是否是文件，如果是则调用复制文件的功能
   
7. *                        
   
8. *                 3)如果是是目录，调用  File.listFiles()方法将文件存储进数组
   
9. *                 4)遍历数组，判断文件，如果是目录，获取该文件名，在目的处创建一个，并在次掉用copyDir()的功能
   
10. *                 5)如果是.java文件，调用copyFile()的功能对文件进行复制
    
11. *         
    
12. * 代码实现如下                       
    
13. */
    
14. 
    
15. import java.io.*;
    
16. import java.util.*;
    
17. 
    
18. public class CopyFile {
    
19.         private static final int BUFFER_SIZE = 1024 * 1024;
    
20. 
    
21.         public static void main(String[] args) throws IOException {
    
22. 
    
23.                 File fromPath = new File("c:\\program files\\java");                         // 从这个目录
    
24. 
    
25.                 File toPath = new File("D:\\");                                                        // 复制到这个目录
    
26. 
    
27.                 copyDir(fromPath, toPath);                                                           // 开始复制
    
28.         }
    
29. 
    
30.         /**
    
31.         * 定义功能，对目录进行拷贝
    
32.         * @param fromPath
    
33.         * @param toPath
    
34.         * @throws IOException
    
35.         */
    
36.         private static void copyDir(File fromPath, File toPath) throws IOException {
    
37. 
    
38.                 //对给定的目录进行判断,不存在，则抛出异常
    
39.                 if (!fromPath.exists()) {
    
40.                         throw new RuntimeException("目录不存，请重新输入!");
    
41.                 }
    
42.                 else if (fromPath.isFile()) {
    
43.                         copyFiles(fromPath, toPath);
    
44.                 } else {
    
45.                         File[] files = fromPath.listFiles();            // 将目录中的文件存储进数组
    
46.                         for (File file : files) {                               // 对数组进行遍历
    
47.                                 // 对文件进行判断，如果是文件，则继续调用copyDir方法，递归
    
48.                                 if (file.isDirectory()) {               
    
49.                                         //获取文件的的绝对路径，和文件名，并封装
    
50.                                         File dir = new File((toPath.getAbsolutePath() + "\\" + fromPath.getName()));
    
51.                                         System.out.println(dir.getAbsolutePath());
    
52.                                         dir.mkdirs();                               // 在目的地创建文件夹
    
53.                                         copyDir(file, dir);                        // 对目录进行递归，深度遍历
    
54.                                 } else if (file.getName().endsWith(".java")){
    
55.                                         copyFiles(file, toPath);               // 调用复制文件的功能
    
56.                                 }
    
57.                         }
    
58.                 }
    
59.         }
    
60. 
    
61.         /**
    
62.         * 定义复制文件的功能
    
63.         * @param sFile
    
64.         * @param pFile
    
65.         * @throws IOException
    
66.         */
    
67.         private static void copyFiles(File sFile, File pFile) throws IOException {
    
68. 
    
69.                 FileInputStream fis = null;
    
70.                 FileOutputStream fos = null;
    
71.                 File fromFile = sFile.getAbsoluteFile();
    
72. 
    
73.                 // 创建集合，对文件的父目录进行切割，并存储进集合
    
74.                 List<String> list = Arrays.asList(sFile.getParent().split("\\\\"));
    
75. 
    
76.                 // 获取文件的直接父目录的字符串
    
77.                 String str = list.get(list.size() - 1);
    
78. 
    
79.                 // 获取目标的绝对路径，和文件的父目录，并在目的地创建文件夹
    
80.                 new File(pFile.getAbsoluteFile() + "\\" + str).mkdirs();
    
81. 
    
82.                 // 获取文件上传的目的地
    
83.                 String newfileName = pFile.toString() + "\\" + str;
    
84. 
    
85.                 // 获取文件名
    
86.                 String fileName = fromFile.getName();
    
87. 
    
88.                 // 创建流关联文件，并写入目的地
    
89.                 fis = new FileInputStream(fromFile);
    
90.                 fos = new FileOutputStream(newfileName + "\\" + fileName);
    
91. 
    
92.                 byte[] buf = new byte[BUFFER_SIZE];
    
93.                 int len = 0;
    
94.                 while ((len = fis.read(buf)) != -1) {
    
95.                         fos.write(buf, 0, len);
    
96.                 }
    
97. 
    
98.                 //关流
    
99.                 fis.close();
    
100.                 fos.close();
     
101.         }
     
102. }

复制代码

韦念欣 发表于 2012-6-27 23:13
这个是我写的一个拷贝某文件夹中的.java文件到另个文件夹中，拷贝后要保持原文件夹的目录。

楼主可以参考 ...

/**
*         拷贝某文件夹中的.java文件到另个文件夹中，拷贝后要保持源文件夹的目录。
*         思路：
*                 1)定义拷贝文件的函数，接收两个文件参数（源和目标）
*                 2)对源目录进行判断，不存在，抛异常,如果存在，先判断是否是文件，如果是则调用复制文件的功能
*                        
*                 3)如果是是目录，调用  File.listFiles()方法将文件存储进数组
*                 4)遍历数组，判断文件，如果是目录，获取该文件名，在目的处创建一个，并在次掉用copyDir()的功能
*                 5)如果是.java文件，调用copyFile()的功能对文件进行复制
*         
* 代码实现如下                       
*/

import java.io.*;
import java.util.*;

public class CopyFile {
        private static final int BUFFER_SIZE = 1024 * 1024;

        public static void main(String[] args) throws IOException {

                File fromPath = new File("c:\\program files\\java");                         // 从这个目录

                File toPath = new File("D:\\");                                                        // 复制到这个目录

                copyDir(fromPath, toPath);                                                           // 开始复制
        }

        /**
        * 定义功能，对目录进行拷贝
        * @param fromPath
        * @param toPath
        * @throws IOException
        */
        private static void copyDir(File fromPath, File toPath) throws IOException {

                //对给定的目录进行判断,不存在，则抛出异常
                if (!fromPath.exists()) {
                        throw new RuntimeException("目录不存，请重新输入!");
                }
                else if (fromPath.isFile()) {
                        copyFiles(fromPath, toPath);
                } else {
                        File[] files = fromPath.listFiles();            // 将目录中的文件存储进数组
                        for (File file : files) {                               // 对数组进行遍历
                                // 对文件进行判断，如果是文件，则继续调用copyDir方法，递归
                                if (file.isDirectory()) {               
                                        //获取文件的的绝对路径，和文件名，并封装

      //这为什么要获取绝对路径+“\\”+文件名啊啥意思，不太明白。。。。。。。。。。。。。。                                  File dir = new File((toPath.getAbsolutePath() + "\\" + fromPath.getName()));

                                        System.out.println(dir.getAbsolutePath());
                                        dir.mkdirs();                               // 在目的地创建文件夹
                                        copyDir(file, dir);                        // 对目录进行递归，深度遍历
                                } else if (file.getName().endsWith(".java")){
                                        copyFiles(file, toPath);               // 调用复制文件的功能
                                }
                        }
                }
        }

        /**
        * 定义复制文件的功能
        * @param sFile
        * @param pFile
        * @throws IOException
        */
        private static void copyFiles(File sFile, File pFile) throws IOException {

                FileInputStream fis = null;
                FileOutputStream fos = null;
                File fromFile = sFile.getAbsoluteFile(); //还有这。。。。

                // 创建集合，对文件的父目录进行切割，并存储进集合
                List<String> list = Arrays.asList(sFile.getParent().split("\\\\")); //这为什么要切割。。。:L

                // 获取文件的直接父目录的字符串
                String str = list.get(list.size() - 1);

                // 获取目标的绝对路径，和文件的父目录，并在目的地创建文件夹
                new File(pFile.getAbsoluteFile() + "\\" + str).mkdirs();  //这个也要解释下。。。

                // 获取文件上传的目的地
                String newfileName = pFile.toString() + "\\" + str;

                // 获取文件名
                String fileName = fromFile.getName();

                // 创建流关联文件，并写入目的地
                fis = new FileInputStream(fromFile);
                fos = new FileOutputStream(newfileName + "\\" + fileName);

                byte[] buf = new byte[BUFFER_SIZE];
                int len = 0;
                while ((len = fis.read(buf)) != -1) {
                        fos.write(buf, 0, len);
                }

                //关流
                fis.close();
                fos.close();
        }
}

好复杂啊。。。。。  枉哥们耐心，详解。    哥们在此谢过。。。:handshake

LZ，没有这么复杂吧！！！创建一个字符输出流，即复制到哪里，创建一个字符输入流，创建一个缓冲数组。就欧拉！！！
下面贴上本人的代码：
import java.io.*;
public class CopyFile {
        public static void main(String args[]){
                try {
                        FileReader reader = new FileReader("D:\\dish.txt");
                        FileWriter writer = new FileWriter("D:\\dish_copy.txt");
                        char []buf = new char[1024];
                        int num=0;
                        while((num=reader.read(buf))!=-1){
                                //只写入有效的内容，从1到num个字符,避免浪费
                                writer.write(buf,1,num);
                                writer.flush();
                        }
                        reader.close();
                        writer.close();
                } catch (FileNotFoundException e) {
                        e.printStackTrace();
                }catch(IOException e){
                       
                }
        }
}

这是测试题目吧，楼主到这里找答案来啦？真聪明{:soso_e120:}
上面的代码也是我刚写完的，深夜2：08分回贴，够感人吧。
版主，我是多么热爱我们的坛子啊，给分吧！！！

想的美，他把Java的文件路径都扔集合里了，不是拷贝文件夹那么省事的；
import java.io.*;
import java.util.*;
class rr {

         public static void main(String[] args) throws IOException{
               
                 File file = new File("D:\\JDK6.0\\java201206");
                 List<String>  data = new ArrayList<String>();
                 data=showDir(file,data);
                 fileCopy("E:\\copy",data);        
               
        }
         
         public static List<String>  showDir(File f,List<String> data)throws IOException{
                 
                 File[] fi =f.listFiles();
                 for(int i=0;i<fi.length;i++){
                                          if(fi[i].isDirectory())
                                                        showDir(fi[i],data);               
                                         else{  
                                              if(fi[i].getAbsolutePath().endsWith(".java"))
                                                           data.add(fi[i].getAbsolutePath());//这里用路径，用Name就可源文件搭不上关系了
                                          }         
                  
                 }
                 return data;
         }
                        
                public static void fileCopy(String index,List<String> list)throws IOException {               
                        File fileNext=new File(index);
                        if(!fileNext.exists())
                                fileNext.mkdir();
                        BufferedReader br=null;
                        BufferedWriter bw=null;
                        
                        for(String fi:list){
                                File file=new File(fi);
                                if(file.isDirectory())
                                        break;
                                bw=new BufferedWriter(new FileWriter(fileNext+"\\\\"+file.getName()));
                                br=new BufferedReader(new FileReader(fi));;
                                String s=null;
                                while((s=br.readLine())!=null){        
                                       
                                        bw.write(s);
                                        bw.newLine();
                                        bw.flush();
                                }
                                
                        }
                        bw.close();
                        br.close();
                }
        
      
}

陆强强 发表于 2012-6-28 07:14
想的美，他把Java的文件路径都扔集合里了，不是拷贝文件夹那么省事的；
import java.io.*;
import java.uti ...

   好强大！   学习了。

在java里，并不存在复制文件夹，单独的文件夹路径是无法复制的，对于复制文件夹来说只是简单的复制里边的所有文件，文件夹实际上是被创建的而不是复制过去的。

1. import java.io.File;
   
2. import java.io.FileInputStream;
   
3. import java.io.FileOutputStream;
   
4. 
   
5. 
   
6. 
   
7. public class CopyFolder
   
8. {
   
9.         public static void main(String[] args)
   
10.         {
    
11.                 //只要不是错误目录就行，文件夹结尾加不加
    
12.                 //斜杠都行，没有区别
    
13.                 Copy("C:/Program Files/office2007", "D:/");
    
14.         }
    
15.        
    
16.         public static void Copy(String srcPath, String desPath)
    
17.         {
    
18.                 File srcFile = new File(srcPath);
    
19.                 File desFile = new File(desPath);
    
20.                 if(srcFile.isDirectory())
    
21.                 {
    
22.                         //如果是文件夹的话，路径需要增加一个斜杠，
    
23.                         //用File.getpath可以避免输入的路径有斜杠
    
24.                         //和没有斜杠导致的一些问题
    
25.                         srcPath = srcFile.getPath()+File.separator;
    
26.                         desPath = desFile.getPath()+File.separator;
    
27.                        
    
28.                         System.out.println(srcPath + " -> " + desPath);
    
29.                        
    
30.                         //遍历整个文件夹下的所有文件和子文件，
    
31.                         //并通过递归调用自己实现所有文件的复制
    
32.                         String[] fileList = srcFile.list();
    
33.                         for (String fileName : fileList)
    
34.             {
    
35.                                 Copy(srcPath+fileName, desPath+fileName);
    
36.                         }
    
37.                 }
    
38.                 //如果给定的源路径是文件
    
39.                 else if(srcFile.isFile())
    
40.                 {
    
41.                         System.out.println(srcPath + " -> " + desPath);
    
42.                         CopyFile(srcPath, desPath);
    
43.                 }
    
44.                 //如果源路径不合法
    
45.                 else
    
46.                 {
    
47.                         throw new IllegalArgumentException("源文件(夹)不存在");
    
48.                 }
    
49.         }
    
50.        
    
51.         public static void CopyFile(String srcPath, String desPath)
    
52.         {
    
53.                 try
    
54.         {
    
55.                         File srcFile = new File(srcPath);
    
56.                         File desFile = new File(desPath);
    
57.                        
    
58.                         //仅当源文件为文件时才复制，目录无法创建流
    
59.                         //会抛出异常
    
60.                        
    
61.                         if(srcFile.isFile())
    
62.                         {
    
63.                                 desFile.getParentFile().mkdirs();
    
64.                                 if(!desFile.exists())  //如果不存在就创建一个新文件
    
65.                                         desFile.createNewFile();
    
66.                                 //创建文件以及该路径里不存在的目录
    
67.                                 FileInputStream fis = null;
    
68.                                 FileOutputStream fos = null;
    
69.                                 try {
    
70.                                         fis = new FileInputStream(srcFile);
    
71.                                         fos = new FileOutputStream(desFile);
    
72.                                         byte[] buffer = new byte[1024];   //定义一个 byte数组用于缓冲
    
73.                                         int len;
    
74.                                         while ((len = fis.read(buffer)) != -1)  //循环判断不是文件的最后就写入
    
75.                                                 fos.write(buffer, 0, len);
    
76.                                 } finally {  //关闭流
    
77.                                         fis.close();
    
78.                                         fos.close();
    
79.                                 }
    
80.                         }
    
81.         }
    
82.         catch (Exception e)
    
83.         {
    
84.                 e.printStackTrace();
    
85.         }
    
86.         }
    
87. }

复制代码

陆强强 发表于 2012-6-28 07:14
想的美，他把Java的文件路径都扔集合里了，不是拷贝文件夹那么省事的；
import java.io.*;
import java.uti ...

没有，楼主其实是两个题目的合并：
第一题是如何将文件路径保存到集合；
第二题是如何取出集合中的路径并将文件拷贝；

其实如果只是拷贝文件夹的话，可以不用集合

多线程学的不扎实，所以没尝试

陆强强 发表于 2012-6-28 14:24
没有，楼主其实是两个题目的合并：
第一题是如何将文件路径保存到集合；
第二题是如何取出集合中的路径并 ...

多线程学的不扎实，所以没尝试

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FilenameFilter;
import java.io.IOException;
public class CopyFile {

public static void main(String[] args) throws Exception {
  // TODO Auto-generated method stub
  File fdir=new File("e:\\");//这个是要copy的文件目录
  if(!(fdir.exists()&&fdir.isDirectory()))//判断目录是否存在
   throw new Exception("不是一个目录");
  
  File[] fs=fdir.listFiles();//创建了一个File数组用来存放e盘下的所以文件和文件夹
  File fmdir=new File("d://");//这个是copy的目标地址
  if(!fmdir.exists())//这个是判断这个是否是一个目录，虽然我自己也感觉多余，但是防范未然，呵呵
   fmdir.mkdir();
  for(File s:fs){//将这个File数组进行遍历处理
   if(s.isHidden()){//我这里加了一个判断就是判断是否是一个隐藏文件，因为有些隐藏文件系统是不让我们读取到的，所以如果不加的话会报一些空指针异常，不过这个地方还可用null来判断，
                         //就是判断s是否==null，我个人比较喜欢用isHidden()这个方法，各取所好吧
    continue;
   }
   if(s.isDirectory()){//这边先要判断他是不是一个目录，因为我们要原模原样的copy过去，所以就连子目录我们也要依次遍历copy
    CopyFile.fun(s);//如果是一个目录的话我们就用static fun（File s）这个方法将子目录中的文件遍历并进行copy
   }else{//如果是一个文件的话，那我们就把他直接copy到目的地址
    FileInputStream fis=new FileInputStream(s);// 我是在这个地方创建的输入输出流然后把输入输出流传入copyFile方法中去的，你也可以把要copy的文件对象和目的地址传进去以后再创建
   
    FileOutputStream fos=new FileOutputStream(new File(fmdir,s.getName()));//创建输出流对象
    CopyFile.copy(fis, fos);//调用copyFile方法将文件进行copy操作
    fis.close();//操作完了以后不要忘记关掉输入输出流否则会造成资源浪费，你可以在方法中关闭，
    fos.close();
   }
  }
  
}
public static void copy(FileInputStream fis,FileOutputStream fos) throws IOException{//这个方法是负责文件copy的方法
  int len=0;
  byte []b=new byte[1024];//这里我用到了缓存，这样比较高效一点
  while((len=fis.read(b))!=-1){//先读取后写入
  fos.write(b, 0, len);//把缓存中的数据写入文件中
  }
}
public static void fun(File s) throws IOException{//这个方法是负责遍历子目录的
  File [] fs=s.listFiles();//同样要先创建一个File数组存放目录中的所有文件
  for(File s1:fs){//判断子目录中的文件是否还是一个目录
   if(s1.isDirectory()){//如果是，我这边采用了递归调用，也就是让他自己继续调用自己，再次遍历
    fun(s1);
   }else{//如果是一个文件，那么就要copy他到目的地址
  String s9=s1.getAbsolutePath().substring(s1.getAbsolutePath().lastIndexOf(":")+1,s1.getAbsolutePath().lastIndexOf("\\")+1);//这个是我用来获取子目录的路径的，写的有点长，原理就是获取
//文件的一个路径比如：e:\demo\123\1.java这个路径，我们只要把有用的也就是\demo\123\这块取出来，我这边有了String的lastIndexOf（）和substring（）结合来获取的
  File f1=new File("d:"+s9);//路径变了自然要创建新的文件对象
  if(!f1.exists()){//如果文件路径不存在就去创建
   f1.mkdir();
  }
//下边的代码同上边一样，创建输入输出流对象，调用copyFile方法执行文件copy操作
  FileInputStream fis=new FileInputStream(s1);
  FileOutputStream fos=new FileOutputStream(new File(f1,s1.getName()));
  CopyFile.copy(fis, fos);
  fis.close();
  fos.close();
   }
  }
}
}
快累死我了，写了这么多注释，别嫌我啰嗦就行，呵呵！代码虽然和上边的差不多，但这个绝对是我自己写的并且亲测没有任何BUG才贴上来的，希望能帮楼主解决问题，上边部分都有注释，看不懂可以问我

陆强强 发表于 2012-6-28 07:14
想的美，他把Java的文件路径都扔集合里了，不是拷贝文件夹那么省事的；
import java.io.*;
import java.uti ...

哇噻，好厉害，  那我要把后缀名 .java 文件复制到目标的目录，在改成后缀名.jad .  那你这个代码要怎么改呢？

晁喆 发表于 2012-6-28 13:57
在java里，并不存在复制文件夹，单独的文件夹路径是无法复制的，对于复制文件夹来说只是简单的复制里边的所 ...

:hug:     那我要把后缀名 .java 文件复制到目标的目录，在改成后缀名.jad .  那你这个代码要怎么改呢？

韦念欣 发表于 2012-6-27 23:13
这个是我写的一个拷贝某文件夹中的.java文件到另个文件夹中，拷贝后要保持原文件夹的目录。

楼主可以参考 ...

那我要把后缀名 .java 文件复制到目标的目录，在改成后缀名.jad .  那你这个代码要怎么改呢？:handshake

sunhaodi 发表于 2012-6-29 18:27
那我要把后缀名 .java 文件复制到目标的目录，在改成后缀名.jad .  那你这个代码要怎么改呢？ ...

在你把所有文件都放入，File数组中的时候，你把数组遍历下，用File.getName（）取出文件名，然后在用String的endwith（）判断是不是以.java结尾的如果是就将他保存到新的File数组中去用String的repace方法吧.java 改成 .jad

sunhaodi 发表于 2012-6-29 18:27
那我要把后缀名 .java 文件复制到目标的目录，在改成后缀名.jad .  那你这个代码要怎么改呢？ ...

bw=new BufferedWriter(new FileWriter(fileNext+"\\\\"+file.getName().replace(".java",".jad")));
这句用replace方法替换一下就好了

孙 胜 录 发表于 2012-6-28 02:06
LZ，没有这么复杂吧！！！创建一个字符输出流，即复制到哪里，创建一个字符输入流，创建一个缓冲数组。就欧 ...

哦，谢谢点评