这是毕老师第20天中的视频，枚举中的部分我不明白怎么把迭代器里的数据一个一个取出来的的，我一直认为枚举方法中只取了一次，不知道哪个地方理解错 了


,
大家注意了，我i的问题是枚举里的Enumeration的nextElement 续调用才返回一系列的连续元素，我不明白的地方就是怎么实现了hasMoreElements() 和nextElement方法了的连续调用，大家不要笼统的说这是枚举，取出所有元素的，我不理解的是枚举里的东西。求解决，谢谢

package com.wenfengkeji.io;

import java.io.*;
import java.util.*;
public class  FileSplit
{
        public static void main(String[] args) throws IOException
        {
                uniteFile();
//                fileSplit();
        }
        public static void uniteFile() throws IOException
        {
                ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();
                int partSize = 4;
                for(int i = 1; i <= partSize; i++)
                {
                        al.add(new FileInputStream("d:/test/" + i + ".part"));
                }
                final Iterator it = al.iterator();
                Enumeration en = new MyEnumeration(it);
                SequenceInputStream sis = new SequenceInputStream(en);
                byte[] buf = new byte[1024 * 1024];
                int len = -1;
                FileOutputStream fos = new FileOutputStream("d:/test/0.mp3");
                while((len = sis.read(buf))!=-1)
                {
                        fos.write(buf, 0, len);
                }
                sis.close();
                fos.close();
        }
        public static class MyEnumeration<E> implements Enumeration<Object>
        {
                private Iterator<E> it;
                public MyEnumeration(Iterator<E> it)
                {
                        this.it = it;
                }
                @Override
                public boolean hasMoreElements() {
                        return it.hasNext();
                }

                @Override
                public Object nextElement() {
                        return it.next();
                }
               
        }
//相当于就是自己实现了Enumeration接口，然后根据Iterator把数据迭代出来
        public static void fileSplit()
        {
                FileInputStream fis = null;
                FileOutputStream fos = null;
                try
                {
                        fis = new FileInputStream("d:/test/亲爱的小孩.mp3");
                        byte[] buf = new byte[1024 * 1024];
                        int len = -1;
                        int count = 1;
                        while((len = fis.read(buf))!=-1)
                        {
                                fos = new FileOutputStream("d:/test/" + count + ".part");
                                fos.write(buf,0,len);
                                fos.close();
                                count++;
                        }
                }
                catch (IOException e)
                {
                        throw new RuntimeException(e);
                }finally
                {
                        try
                        {
                                if(fos != null)
                                {
                                        fos.close();
                                }
                        }
                        catch (IOException e)
                        {
                                throw new RuntimeException(e);
                        }finally
                        {
                                try
                                {
                                        if(fis != null)
                                        {
                                                fis.close();
                                        }
                                }
                                catch (IOException e)
                                {
                                        throw new RuntimeException(e);
                                }
                        }
                }
        }
}

呃。。。楼上这。。。好让人眼晕啊。。。呵呵
毕老师的这个例子是合并流。
  for(int x=1; x<=3; x++)
  {
   al.add(new FileInputStream("c:\\splitfiles\\"+x+".part"));
  }
这个for循环就将三个文件全部遍历出来，并添加到了上面定义好的ArrayList集合中，而集合有迭代的方法取出其中的元素，
所以final Iterator<FileInputStream> it = al.iterator();
而下面的这个枚举就是取出元素
  Enumeration<FileInputStream> en = new Enumeration<FileInputStream>()
  {
      public boolean hasMoreElements() // 这里是枚举的方法，判断是否有下一个枚举元素
      {
          return it.hasNext(); // 这里是集合迭代方法判断是否有下一个元素
      }
     public FileInputStream nextElement() //这里是枚举的方法，取出下一个枚举元素
     {
         return it.next(); // 这里是集合迭代的方法取出集合中的下一个元素
      }
  };

将三个part流对象取出后，再通过SequenceInputStream(Enumeration en);来将三个流对象合并为一个流对象就可以了。
SequenceInputStream sis = new SequenceInputStream(en);

孔肖 发表于 2012-9-28 14:54
呃。。。楼上这。。。好让人眼晕啊。。。呵呵
毕老师的这个例子是合并流。
  for(int x=1; x ...

我是不明白怎么把迭代器里的数据一个一个取出来的的，我一直认为枚举方法中只取了一次，不知道哪个地方理解错 了

夏晓彤 发表于 2012-9-28 15:09
我是不明白怎么把迭代器里的数据一个一个取出来的的，我一直认为枚举方法中只取了一次，不知道哪个地方理 ...

1. for(int x=1; x<=3; x++)
   
2. {
   
3. al.add(new FileInputStream("c:\\splitfiles\\"+x+".part"));
   
4. }
   
5. 这个for循环就将三个文件全部遍历出来，并添加到了上面定义好的ArrayList集合中，而集合有迭代的方法取出其中的元素，
   
6. 所以final Iterator<FileInputStream> it = al.iterator();
   
7. 而下面的这个枚举就是取出元素
   
8. Enumeration<FileInputStream> en = new Enumeration<FileInputStream>()
   
9. {
   
10. public boolean hasMoreElements()
    
11. {
    
12. return it.hasNext();
    
13. }
    
14. public FileInputStream nextElement()
    
15. {
    
16. return it.next();
    
17. }
    
18. };
    
19. 
    
20. <FONT color=red>//注意这个类SequenceInputStream，这个类将按顺序读取由该枚举生成的输入流，以提供从此 SequenceInputStream读取的字节。
    
21. //在用尽枚举中的每个输入流之后，将通过调用该流的 close方法将其关闭。
    
22. </FONT>SequenceInputStream sis = new SequenceInputStream(en);
    

复制代码

谭立文 发表于 2012-9-28 14:43
package com.wenfengkeji.io;

import java.io.*;

这已经给你写的够清楚了啊，不明白，就好好看看基础。

谭立文 发表于 2012-9-30 23:01
这已经给你写的够清楚了啊，不明白，就好好看看基础。

你都没搞明白我问的是什么，Enumeration的nextElement 续调用才返回一系列的连续元素，我不明白的地方就是哪些代码起到连续调用nextElement方法了，还有这些都是基础，我i也把毕老师那段视频看了很久，解决不了才来问的，你觉得自己是高手，你还需要来黑马论坛，想必你的工作已经在1w+了，

李建强 发表于 2012-9-28 21:24

我i的问题是枚举里的Enumeration的nextElement 续调用才返回一系列的连续元素，我不明白的地方就是哪些代码起到连续调用nextElement方法了，你和毕老师说的一样，这是个枚举，取出元素的，我不理解的是枚举里的东西。求解决，谢谢

夏晓彤 发表于 2012-10-1 00:53
我i的问题是枚举里的Enumeration的nextElement 续调用才返回一系列的连续元素，我不明白的地方就是哪些代 ...

MyEnumeration自己实现了Enumeration这个接口传了一个Iteraotor的接口相对于是MyEnumertaion对ArrayList中存放FileInputStream的迭代的封装，然后将en这个接口的引用传递给了SequenceInputStream,至于怎么去获取里面存放的FileInputStream,这是在new  SequenceInputStream实例的时候SequenceInputStream这个类该干的是，你可以去看看 SequenceInputStream构造方法的源代码就一目了然了。