这道题的题目在代码里有，鄙人做法如下：

1. import java.io.File;
   
2. import java.io.FileInputStream;
   
3. import java.io.FileOutputStream;
   
4. import java.io.IOException;
   
5. 
   
6. /*9、 编写一个程序，将d:\java 目录下的所有.java 文件
   
7. * 复制到d:\jad 目录下，
   
8. * 并将原来文件的扩展名从.java 改为.jad。
   
9. */
   
10. public class Test9 {
    
11.         public static void main(String[] args) throws IOException {
    
12.                 //指定目标文件
    
13.                 File srcFile=new File("d:\\java");
    
14.                 //指定目的路径
    
15.                 File destFile = new File("d:\\jad");
    
16.                
    
17.                 File[] files = srcFile.listFiles();
    
18.                 for(File f:files){
    
19.                         if(f.isFile()){
    
20.                                 String name = f.getName();
    
21.                                 if(name.endsWith(".java")){
    
22.                                         //创建输入流。并关联目标文件
    
23.                                         FileInputStream fis = new FileInputStream(f);
    
24.                                         //创建输出流，关联输出目录
    
25.                                         FileOutputStream fos = new FileOutputStream(new File(destFile,name));
    
26.                                         //调用缓冲数组，为了提高效率，使用1024*1024的数组
    
27.                                         byte[] byt=new byte[1024*1024];
    
28.                                         //定义一个变量接受数组数据
    
29.                                         int len=0;
    
30.                                         while((len=fis.read(byt))!=-1){
    
31.                                                 fos.write(byt, 0, len);
    
32.                                         }
    
33.                                         //抽取文件名后缀名的角标
    
34.                                         int lastIndexOf = name.lastIndexOf(".java");
    
35.                                         //抽取文件名中非后缀名的子字符串
    
36.                                         String substring = name.substring(0, lastIndexOf);
    
37.                                         //将子字符串和.jad组合成新文件名
    
38.                                         String newname = substring.concat(".jad");
    
39.                                         //以新文件名在源目录创建新空白文件
    
40.                                         File file2 = new File(srcFile,newname);
    
41.                                         fis=new FileInputStream(f);
    
42.                                         fos=new FileOutputStream(file2);
    
43.                                         while((len=fis.read(byt))!=-1){
    
44.                                                 fos.write(byt, 0, len);
    
45.                                         }
    
46.                                         //删除源目录里的java文件
    
47. //                                        System.out.println(f.delete());
    
48.                                         f.delete();
    
49.                                         //关闭流！
    
50.                                         fis.close();
    
51.                                         fos.close();
    
52.                                 }
    
53.                         }
    
54.                 }
    
55.                
    
56.         }
    
57. }

复制代码

我的已经做到拷贝java文件已经生成jad文件，但是在这后一步“f.delete();”的时候无法删除原目录里的java文件，而且原目录里jad文件已经生成了，验证的时候打印  System.out.println(f.delete()); 也是false！这个题已经困惑我许久了，真心求高手解惑！

王晓明 发表于 2013-1-25 12:00
很好，很强大！呵呵，今早我经过一哥们的解惑，也解决了，和你说的一样！就是两个流的关闭问题，十分感谢 ...

;P昨天晚上没在看帖子不是。。。还好吧

杨世平 发表于 2013-1-25 10:44
代码写错了,建议封装下吧,我测试了了下代码发现了问题..

在for循环下 if(f.isFile()){}这个后面,还有你这 ...

很好，很强大！呵呵，今早我经过一哥们的解惑，也解决了，和你说的一样！就是两个流的关闭问题，十分感谢你的帮助，你要是昨晚就回答我了，那是最好了！哈哈，谢谢哥们了，你的水平很强大！看了你的解惑，思路很清晰，很有想法！现在问题已解决，代码也重新封装了，心情舒服多了！

梁俊 发表于 2013-1-25 09:01
关闭流也不行，我试了，去掉与流有关的操作才可以delete，也不知道到底为什么 ...

还是流的关闭问题，我使用了两次流，就得关闭两次，5楼的兄弟解决的很好！

arno942 发表于 2013-1-24 23:15
是这样的效果吗？  希望对你有点帮助，如果还有哪里不是很清楚，可以问我 ...

谔谔。貌似你没考虑到这种情况，假如文件全名是Demo1.java.java呢？这种命名也是可以的！
还有，是要求先复制，然后对源文件进行改名的，不是先改名吧！

胡勇敏 发表于 2013-1-24 22:28
首先第一点，哥们你的问题是 这么多代码全写在main函数中，这种做法是很烂的，会影响程序的执行效率，也会 ...

嗯嗯，谢谢，问题已解决！主要是流的关闭问题！我使用了两次流，就得关两次！

胡勇敏 发表于 2013-1-25 10:33
你怎么写的代码贴出来看下。

还是少关流了，现在对了

代码写错了,建议封装下吧,我测试了了下代码发现了问题..

在for循环下 if(f.isFile()){}这个后面,还有你这句其实不用加的,你前面的File[] files = srcFile.listFiles();取的已经是文件夹下的所有文档了....你还继续判断是不是文档?

                if (f.exists()) {
                System.out.println(f.getAbsoluteFile());
                if (!f.delete()) {
                    System.out.println("请关闭使用该文件的所有进程或者流！！");
                } else {
                    System.out.println(f.getName()+" 成功被删除！");
                }
            }
在这里输出的语句时
d:\java\ProductDAO.jad
ProductDAO.jad 成功被删除！
d:\java\ProductDAO.java
请关闭使用该文件的所有进程或者流！！

这说明你的f值在变,先变成.jad......
你现在的代码不好修改,我建议你封装下,写个类,3个方法,复制,改成.jad,还有个删除文件的方法..这样就不会出现关闭流的问题


刚刚才想到问题所在,你分别应了输入和输出流2次所以你要关闭2次....你应该在复制的关闭一次,变成.jad时关闭一次..原因就是你的流没关干净..如果你不想封装的话代码如下
package dao;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import javax.xml.registry.DeleteException;

/*9、 编写一个程序，将d:\java 目录下的所有.java 文件
* 复制到d:\jad 目录下，
* 并将原来文件的扩展名从.java 改为.jad。
*/
public class Test9 {
public static void main(String[] args) throws Exception {

  //指定目标文件
  File srcFile=new File("d:\\java");
  //指定目的路径
  File destFile = new File("d:\\jad");
  
  File[] files = srcFile.listFiles();
  for(File f:files){
   
    //System.out.println(f);
    String name = f.getName();
    if(name.endsWith(".java")){
     //创建输入流。并关联目标文件
     FileInputStream fis = new FileInputStream(f);
     //创建输出流，关联输出目录
     FileOutputStream fos = new FileOutputStream(new File(destFile,name));
     //调用缓冲数组，为了提高效率，使用1024*1024的数组
     byte[] byt=new byte[1024*1024];
     //定义一个变量接受数组数据
     int len=0;
     while((len=fis.read(byt))!=-1){
      fos.write(byt, 0, len);
     }
//关闭流！  在这里再加次关闭流就好了
     fis.close();
     fos.close();
     //抽取文件名后缀名的角标
     int lastIndexOf = name.lastIndexOf(".java");
     //抽取文件名中非后缀名的子字符串
     String substring = name.substring(0, lastIndexOf);
     //将子字符串和.jad组合成新文件名
     String newname = substring.concat(".jad");
     //以新文件名在源目录创建新空白文件
     File file2 = new File(srcFile,newname);
     fis=new FileInputStream(f);
     fos=new FileOutputStream(file2);
     while((len=fis.read(byt))!=-1){
      fos.write(byt, 0, len);
     }
     
     //关闭流！
     
     fis.close();
     fos.close();
     
    }
    //删除源目录里的java文件
   if (f.exists()) {
                System.out.println(f.getAbsoluteFile());
                if (!f.delete()) {
                    System.out.println("请关闭使用该文件的所有进程或者流！！");
                } else {
                    System.out.println(f.getName()+" 成功被删除！");
                }
               
            }
  }
  
  
}
}

梁俊 发表于 2013-1-25 09:01
关闭流也不行，我试了，去掉与流有关的操作才可以delete，也不知道到底为什么 ...

你怎么写的代码贴出来看下。

胡勇敏 发表于 2013-1-24 22:28
首先第一点，哥们你的问题是 这么多代码全写在main函数中，这种做法是很烂的，会影响程序的执行效率，也会 ...

关闭流也不行，我试了，去掉与流有关的操作才可以delete，也不知道到底为什么

是这样的效果吗？  希望对你有点帮助，如果还有哪里不是很清楚，可以问我

1. import java.io.BufferedReader;
   
2. import java.io.BufferedWriter;
   
3. import java.io.File;
   
4. import java.io.FileReader;
   
5. import java.io.FileWriter;
   
6. import java.io.FilenameFilter;
   
7. import java.io.IOException;
   
8. 
   
9. /*
   
10. *编写一个程序，将d:\java目录下的所有.java文件复制到d:\jad目录下，
    
11. *并将原来文件的扩展名从.java改为.jad。
    
12. */
    
13. public class Demo1 {
    
14.         public static void main(String[] args) throws Exception {
    
15.                 File file = new File("d:\\java");
    
16.                 // 判断要访问的目录是否存在 ，如果为true 出异常
    
17.                 if (!(file.exists() && file.isDirectory()))
    
18. 
    
19.                         throw new Exception("目录不存在");
    
20. 
    
21.                 File[] file2 = file.listFiles(new FilenameFilter() {
    
22. 
    
23.                         public boolean accept(File dir, String name) {
    
24. 
    
25.                                 return name.endsWith(".java");
    
26.                         }
    
27.                 });
    
28.                 File file1 = new File("d:\\jad");
    
29.                 // 判断要存的目录是否存在， 如果为true,就创建一个目录
    
30.                 if (!(file1.exists())) {
    
31.                         file1.mkdir();
    
32.                 }
    
33. 
    
34.                 for (File file3 : file2) {
    
35.                         if (file3.isFile()) {
    
36.                                 BufferedReader br = new BufferedReader(new FileReader(file3));
    
37.                                 // 到这里的文件已经都是.java文件了，得到文件名字，获取扩展名.java换成.txt
    
38.                                 String str = file3.getName().replaceAll(".java", ".txt");
    
39.                                 BufferedWriter bw = new BufferedWriter(new FileWriter(new File(
    
40.                                                 file1, str)));
    
41.                                 // 文件进行copy
    
42.                                 copy(br, bw);
    
43.                                 br.close();
    
44.                                 bw.close();
    
45.                         }
    
46.                 }
    
47. 
    
48.         }
    
49. 
    
50.         // 单个文件copy封装方法
    
51.         public static void copy(BufferedReader br, BufferedWriter bw)
    
52.                         throws IOException {
    
53. 
    
54.                 String st = null;
    
55.                 while ((st = br.readLine()) != null) {
    
56.                         bw.write(st);
    
57.                         bw.newLine();
    
58.                 }
    
59.         }
    
60. 
    
61. }

复制代码

首先第一点，哥们你的问题是 这么多代码全写在main函数中，这种做法是很烂的，会影响程序的执行效率，也会影响程序的可读性。建议将复制文件并改名的功能单独抽取封装为一个函数，将删除文件单独封装函数。第二点就是针对你提的问题，当代码执行到f.delete()时。你的输入输出流尚未关闭，文件还在被占用呢，你当然不能删除。所以你需要先关闭流在进行删除操作，才能正常的把文件删除掉。