看了老毕的基础教程后，想对文件合并分割器的代码进行一些改进，想增加一个文件切割后删除源文件、文件合并后，删除原来的所有碎片文件的功能，切割后，删除源文件没什么问题，但是，合并后，删除原来的碎片文件，properties文件总是删不掉，并且，如果切割的文件过大，比如我用1.25G的文件测试，在合并时，碎片文件也会有一部分删不掉的，我的内存是3G的(win7-32位的只能识别到这了)，在合并时，文件似乎一次性全部加载到了内存，在删除时，内存到了2.6G就出问题了，部分碎片文件删不掉，properties文件是每次都删不掉，这事什么情况，请教！
我把代码贴上来，以下是我的代码，我换上老毕的代码测试合并后删除原来的碎片文件，properties文件也删不掉，不知为何，流已经关闭了，没有打开properties文件，也没有与之相关的程序，就是说该文件在我看来没被引用到，怎么就删不掉了：

--文件合并类

1. 
   
2. import java.io.File;
   
3. import java.io.FileInputStream;
   
4. import java.io.FileNotFoundException;
   
5. import java.io.FileOutputStream;
   
6. import java.io.IOException;
   
7. import java.io.SequenceInputStream;
   
8. import java.util.ArrayList;
   
9. import java.util.Collections;
   
10. import java.util.Enumeration;
    
11. import java.util.List;
    
12. import java.util.Properties;
    
13. 
    
14. public class MergeFile {
    
15. 
    
16.         //定义配置文件后缀名
    
17.         private static final String PROPERTIES_SUFFIX = ".properties";
    
18.         //定义碎片文件后缀名
    
19.         private static final String PART_SUFFIX = ".part";
    
20.         //取缓冲区:1M
    
21.         private static final int BUFFERED_SIZE = 1048576;
    
22.         
    
23.         /**
    
24.          * 根据文件路径读取properties配置文件，并合并指定路径下的文件
    
25.          * @param filepath 要合并的的碎片文件的目录
    
26.          * @param fileMerged 碎片文件合并后文件的存放目录
    
27.          * @throws IOException
    
28.          * */
    
29.         public static void fileMerge(File filepath, File fileMerged) throws IOException {
    
30.                 //检测碎片文件目录是否正确
    
31.                 if(filepath==null || !filepath.isDirectory()){
    
32.                         throw new RuntimeException("提供的碎片文件目录不是一个目录!");
    
33.                 }
    
34.                
    
35.                 //检测碎片文件合并后的存放目录是否正确
    
36.                 if(!fileMerged.isDirectory()){
    
37.                         boolean flag = fileMerged.mkdirs();
    
38.                         if(!flag)
    
39.                                 throw new RuntimeException("创建文件存放路径失败，请提供正确的文件存放路径！");
    
40.                 }
    
41.                
    
42.                 //获取properties配置文件
    
43.                 File[] propFiles = getFilesBySuffix(filepath, PROPERTIES_SUFFIX);
    
44.                 if(propFiles.length != 1){
    
45.                         throw new RuntimeException(filepath.getPath()+"下，后缀为.properties的文件不存在或数量不唯一");
    
46.                 }
    
47.                 Properties prop = getPropObject(propFiles[0]);
    
48.                 //从配置文件中读取碎片文件数量
    
49.                 String count = prop.getProperty("count");
    
50.                 String fileName = prop.getProperty("filename");
    
51.                 if(count==null){
    
52.                         throw new RuntimeException("配置文件中的信息有误：count属性对应的值为空");
    
53.                 }
    
54.                
    
55.                 //获取被分割的文件碎片
    
56.                 File[] partFiles = getFilesBySuffix(filepath,PART_SUFFIX);
    
57.                
    
58.                 List<FileInputStream> flist = new ArrayList<FileInputStream>();
    
59.                 if(Integer.parseInt(count) != partFiles.length)
    
60.                         throw new RuntimeException("配置文件中的count属性的值与实际part文件数量不相符");
    
61.                
    
62.                 //将文件碎片添加到一个集合中
    
63.                 for(File f : partFiles){
    
64.                         flist.add(new FileInputStream(f));
    
65.                 }
    
66.                
    
67.                 //将文件集合转化为序列流
    
68.                 SequenceInputStream sis = fileList2SeqInputStream(flist);
    
69.                
    
70.                 //合并文件
    
71.                 write2Disk(sis, fileMerged, fileName);
    
72.                
    
73.                 //关闭序列流
    
74.                 sis.close();
    
75.                
    
76.                 //清除碎片文件
    
77.                 clearDebrisFiles(filepath);
    
78.         }
    
79.         
    
80.         //清除碎片文件
    
81.         private static void clearDebrisFiles(File filepath) {
    
82.                 File[] file = filepath.listFiles();
    
83.                 for(File f : file){
    
84.                         boolean flag = f.delete();
    
85.                         if(!flag)
    
86.                                 throw new RuntimeException(filepath.getPath()+"下，"+f.getName()+"删除失败！");
    
87.                 }
    
88.         }
    
89. 
    
90.         //将文件集合转化为序列流
    
91.         private static SequenceInputStream fileList2SeqInputStream(
    
92.                         List<FileInputStream> flist) {
    
93.                 Enumeration<FileInputStream> enumList = Collections.enumeration(flist);
    
94.                 SequenceInputStream sis = new SequenceInputStream(enumList);
    
95.                 return sis;
    
96.         }
    
97.         
    
98.         //根据文件后缀获取文件
    
99.         private static File[] getFilesBySuffix(File filepath, String suffix) {
    
100.                 File[] propFiles = filepath.listFiles(new FilterBySuffix(suffix));
     
101.                 return propFiles;
     
102.         }
     
103.         
     
104.         //获取碎片文件数量
     
105.         private static Properties getPropObject(File propFiles) throws IOException,
     
106.                         FileNotFoundException {
     
107.                 //获取properties配置文件中的信息
     
108.                 Properties prop = new Properties();
     
109.                 prop.load(new FileInputStream(propFiles));
     
110.                 return prop;
     
111.         }
     
112.         
     
113.         //合并文件
     
114.         private static void write2Disk(SequenceInputStream sis, File fileMerged, String filename) throws IOException {
     
115.                 FileOutputStream out = new FileOutputStream(new File(fileMerged, filename));
     
116.                 byte[] buf = new byte[BUFFERED_SIZE];
     
117.                 int len = 0;
     
118.                 while((len=sis.read(buf))!=-1){
     
119.                         out.write(buf, 0, len);
     
120.                 }
     
121.                 out.close();
     
122.         }
     
123.         
     
124. }

复制代码

谢谢，找到地方了，原来从properties文件中获取碎片文件数量的方法是这样的：

1. //获取碎片文件数量
   
2.         private static Properties getPropObject(File propFiles) throws IOException,
   
3.                         FileNotFoundException {
   
4.                 //获取properties配置文件中的信息
   
5.                 Properties prop = new Properties();
   
6.                 prop.load(new FileInputStream(propFiles));
   
7.                 return prop;
   
8.         }

复制代码

在这个方法里，new FileInputStream(propFiles)在操作完毕后没有关闭读取数据的流，所以删不掉properties文件，改成如下代码就行了

1. //获取碎片文件数量
   
2.         private static Properties getPropObject(File propFiles) throws IOException,
   
3.                         FileNotFoundException {
   
4.                 FileInputStream fis = new FileInputStream(propFiles);
   
5.                 //获取properties配置文件中的信息
   
6.                 Properties prop = new Properties();
   
7.                 prop.load(fis);
   
8.                 fis.close();
   
9.                 return prop;
   
10.         }

复制代码

你都代码量太多了,不好看懂啊,再说了注释太少了!
properties文件删不掉一定是有另一个对象在引用着它,具体是什么我也看不出!有两个解决办法:
1,是找出引用对象,并释放掉.
2,是强制进行垃圾回收,System.gc()  不过这个方法不一定有效,因为垃圾回收机制是独立的线程,系统不一定立即执行.