这道程序实现的目标是“将一个目录下的所有txt类型的文本文件中的内容合并到若干个新的文本文件中，当第一个新产生的文件中存储的内容大道1M时，剩下的内容存储到第二个新的文件中，依次往下，新产生的文本文件的名字依次是1.txt,2.txt......”
下面是我编写的代码：
import java.io.*;
import java.util.*;
public class StreamTest {

        /**
         * @param args
         */
        public static void main(String[] args)throws Exception {
                // TODO Auto-generated method stub
     getFile("e:\\lihexiao");
        }
        public static void getFile(String str) throws Exception
        {
                //定义一个Vector集合，只能往里添加InputStream类型的对象
                Vector<InputStream> v=new Vector<InputStream>();
                int i=1;
                File f=new File(str);
                //定义一个缓存数组，大小为1024字节
                byte[] by=new byte[1024];
                FileInputStream fis=null;
                FileOutputStream fos=null;
                //获取此文件目录下所有的txt文件
                String[] fileNames=f.list(new FilenameFilter()
                {
                        public boolean accept(File f,String name)
                        {
                                if(name.endsWith(".txt"))
                                        return true;
                                else
                                        return false;
                        }
                        });
                        for(String fileName:fileNames)        
                        {
                                //建立读取流对象
                                fis=new FileInputStream(str+"\\"+fileName);
                                //将所有的读取流对象添加到Vector集合中
                                v.add(fis);
                        }
                Enumeration<InputStream> e=v.elements();
                //定义序列流，将多个流对象合并成一个流
                SequenceInputStream se=new SequenceInputStream(e);
                int len=0;
                while((len=se.read(by))!=-1)
                {
                        //将序列流中的数据读取到多个文件中，每个文件大小为1024字节
                        fos=new FileOutputStream(str+"\\"+(i++)+".txt");
                        fos.write(by,0,len);
                        
                }
                fis.close();
                fos.close();

        }
}

最后生成的几个文件为什么不正确呢，按照我的程序得到的结果是，如果lihexiao目录下的txt文件大于1M的话会自动分隔，如果小于1M的话会自动把这个不到1M的文件内容存入到一个in的文件中，我的程序的错误在哪里？求指点啊

设置一个临时文件就可以了，不知道还有没有其他的方式，感觉临时文件比较麻烦

最后文件生成是什么样子的

头大了

兄弟这个题目3人搞了4 5个小时楞是没搞出来啊    高手在那里  

李贺晓 发表于 2013-1-17 14:19
设置一个临时文件就可以了，不知道还有没有其他的方式，感觉临时文件比较麻烦 ...

最后捉摸了半天，这个方法是最简单的了 苍天啊 来点高手来解答问题吧

1. import java.io.File;
   
2. import java.io.FileInputStream;
   
3. import java.io.FileOutputStream;
   
4. import java.io.FilenameFilter;
   
5. import java.io.InputStream;
   
6. import java.io.SequenceInputStream;
   
7. import java.util.Enumeration;
   
8. import java.util.Vector;
   
9. 
   
10. public class StreamTest {
    
11.         public static void main(String[] args) throws Exception {
    
12.                 Vector<InputStream> vector = new Vector<>();
    
13.                 File dir = new File("E:\\nihao");
    
14.                 File[] files = dir.listFiles(new FilenameFilter() {
    
15.                         public boolean accept(File dir, String name) {
    
16.                                 return name.endsWith(".txt");
    
17.                         }
    
18.                 });
    
19.                 for (File file : files) {
    
20.                         vector.add(new FileInputStream(file));
    
21.                 }
    
22.                
    
23.                 Enumeration<InputStream> enumeration = vector.elements();
    
24.                 SequenceInputStream stream = new SequenceInputStream(enumeration);
    
25.                 FileOutputStream fos = null;
    
26.                 int i = 1;
    
27.                 int len = -1;
    
28.                 int total = 0;
    
29.                 byte[] buf = new byte[20];
    
30.                 while ((len = stream.read(buf, total, buf.length - total)) != -1) {
    
31.                         total += len;
    
32.                         if (total == buf.length) {
    
33.                                 fos = new FileOutputStream("E:\\nihao\\" + i++ + ".txt");
    
34.                                 fos.write(buf, 0, total);
    
35.                                 total = 0;
    
36.                         }
    
37.                 }
    
38.                 // 读完的最后一次可能不足buf.length个字节。需要单独处理
    
39.                 fos = new FileOutputStream("E:\\nihao\\" + i + ".txt");
    
40.                 fos.write(buf, 0, total);
    
41.         }
    
42. }

复制代码

1. import java.io.*;
   
2. import java.util.*;
   
3. 
   
4. public class StreamTest {
   
5. 
   
6.         /**
   
7.          * @param args
   
8.          */
   
9.         public static void main(String[] args) throws Exception
   
10.         {               
    
11.                 getFile("W:\\javawork\\bxd\\day25");
    
12.         }
    
13. 
    
14.         public static void getFile(String str) throws Exception
    
15.         {               
    
16.                 Vector<InputStream> v = new Vector<InputStream>();               
    
17.                 File f = new File(str);               
    
18.                 FileInputStream fis = null;
    
19.                 FileOutputStream fos = null;
    
20. 
    
21.                 // 获取此文件目录下所有的txt文件
    
22.                 String[] fileNames = f.list(new FilenameFilter()
    
23.                         {
    
24.                         public boolean accept(File f, String name)
    
25.                         {
    
26.                                 return name.endsWith(".java");
    
27. 
    
28.                         }
    
29.                 });               
    
30. 
    
31.                 for (String fileName : fileNames)
    
32.                 {                       
    
33.                         fis = new FileInputStream(str + "\\" + fileName);                       
    
34.                         v.add(fis);                       
    
35.                 }
    
36.        
    
37.                 Enumeration<InputStream> e = v.elements();               
    
38.                 SequenceInputStream se = new SequenceInputStream(e);
    
39.                 byte[] by = new byte[450];
    
40.                 int len = 0;               
    
41.        
    
42.                 //以上部分都一样，下边的与楼主不同不同。
    
43.                 int num = 0;//记录读取的所有文件的总长
    
44.                 int num1 = 0;//记录当前操作文件已写入的字符长度。
    
45.                 int pos = 0;//当前操作文件需要写入的字符长度。       
    
46.                 int i = 1;//文件标题自增计数器
    
47.                                
    
48.                 fos=new FileOutputStream((str+"\\"+(i++)+".txt"));
    
49.                
    
50.                 while ((len = se.read(by)) != -1)
    
51.                 {
    
52.                         System.out.println("len="+len);                       
    
53.                         num=num+len;                       
    
54.                         while(len>0)
    
55.                         {
    
56.                                
    
57.                                 pos = by.length-num1;
    
58.                                 if(len<pos)
    
59.                                 {
    
60.                                         fos.write(by,0,len);        //写入后，写入计数器增加，len清空                               
    
61.                                         num1+=len;
    
62.                                         len=0;                                       
    
63.                                 }
    
64.                                 else//len>=pos的情况。
    
65.                                 {
    
66.                                         fos.write(by,0,pos);//写入后，写入计数器归零，len减去写入的长度。       
    
67.                                         num1 = 0;
    
68.                                         len -= pos;
    
69.                                         System.out.println("pos="+pos+" num1="+num1+" i="+i);
    
70.                                         fos.close();
    
71.                                         fos=new FileOutputStream((str+"\\"+(i++)+".txt"));
    
72.                                        
    
73.                                 }
    
74.                         }
    
75.                          
    
76.                 }
    
77.                 fis.close();
    
78.                 fos.close();
    
79. 
    
80.         }
    
81. }

复制代码

{:soso_e113:}

舒远 发表于 2013-1-18 10:28

刚有重新思考了下这个代码：发现了一下问题
1.在往Vector中添加过程中，应该增加个判断过程，应该可能一个文件夹的名字也已“.txt”结尾的，如果有这样的文件夹，下边的操作会出现空指针异常。
2.在while循环中，新建一个FileOutputStream后，没有将之前的资源关闭，整个代码结束时，序列流也应该关闭资源。
3.whil循环外边的新建写入流过程中，前边应该加个if（pos！=0）判断一下，否则如果while结束后，可能会创建一个空文件。