109.Java序列流

序列流

也称为合并流。

1. SequenceInputStream

序列流，对多个流进行合并。

SequenceInputStream 表示其他输入流的逻辑串联。它从输入流的有序集合开始，并从第一个输入流开始读取，直到到达文件末尾，接着从第二个输入流读取，依次类推，直到到达包含的最后一个输入流的文件末尾为止。

注意:

构造函数
SequenceInputStream(InputStream s1, InputStream s2)
SequenceInputStream(InputStream s1, InputStream s2)

合并两个流

使用构造函数SequenceInputStream(InputStream s1, InputStream s2)

private static void testSequenceInputStream() throws IOException {
        FileInputStream fis1 = new FileInputStream("c:\a.txt");
        FileInputStream fis2 = new FileInputStream("c:\b.txt");

        SequenceInputStream s1 = new SequenceInputStream(fis1, fis2);
        int len = 0;
        byte[] byt = new byte[1024];

        FileOutputStream fos = new FileOutputStream("c:\z.txt");

        while ((len = s1.read(byt)) != -1) {
            fos.write(byt, 0, len);
        }
        s1.close();
    }

合并多个流:

public static void testSequenceInputStream() throws Exception {
        InputStream in1 = new FileInputStream("c:/a.txt");
        InputStream in2 = new FileInputStream("c:/b.txt");
        InputStream in3 = new FileInputStream("c:/c.txt");

        LinkedHashSet<InputStream> set = new LinkedHashSet<InputStream>();
        set.add(in1);
        set.add(in2);
        set.add(in3);
        final Iterator<InputStream> iter = set.iterator();

        SequenceInputStream sin = new SequenceInputStream(
                new Enumeration<InputStream>() {
                    @Override
                    public boolean hasMoreElements() {
                        return iter.hasNext();
                    }

                    @Override
                    public InputStream nextElement() {
                        return iter.next();
                    }
                });

        FileOutputStream out = new FileOutputStream("c:/z.txt");

        for (int b = -1; (b = sin.read()) != -1;) {
            out.write(b);
        }
        sin.close();
        out.close();
    }

案例:将map3歌曲文件进行切割拷贝,并合并.

public class Demo2 {
    public static void main(String[] args) throws IOException {
        
        split(new File("c:\a.mp3"), 10, new File("c:\"));
        System.out.println("切割完毕");

        LinkedHashSet<InputStream> hs = new LinkedHashSet<InputStream>();    
        hs.add(new FileInputStream(new File("c:\part.1.mp3")));
        hs.add(new FileInputStream(new File("c:\part.2.mp3")));
        hs.add(new FileInputStream(new File("c:\part.3.mp3")));
        hs.add(new FileInputStream(new File("c:\part.4.mp3")));
        merage(hs, new File("c:\merage.mp3"));
        System.out.println("合并完毕");
    }

    private static void merage(LinkedHashSet<InputStream> hs, File dest)
            throws IOException {

        final Iterator<InputStream> it = hs.iterator();
        FileOutputStream fos = new FileOutputStream(dest);
        SequenceInputStream seq = new SequenceInputStream(
                new Enumeration<InputStream>() {

                    @Override
                    public boolean hasMoreElements() {

                        return it.hasNext();
                    }

                    @Override
                    public InputStream nextElement() {
                        return it.next();
                    }
                });
        byte[] byt = new byte[1024 * 1024];
        int len = 0;
        while ((len = seq.read(byt)) != -1) {
            fos.write(byt, 0, len);
        }
        seq.close();
        fos.close();
    }

    // 1. 切割文件
    /*
     * 切割文件,切割份数, 切割后保存路径
     */
    private static void split(File src, int count, File dir) throws IOException {
        FileInputStream fis = new FileInputStream(src);
        FileOutputStream fos = null;
        byte[] byt = new byte[1024 * 1024];
        int len = 0;
        for (int i = 1; i <= count; i++) {
            len = fis.read(byt);
            if (len != -1) {
                fos = new FileOutputStream(dir + "part." + i + ".mp3");
                fos.write(byt, 0, len);
            }

            // fos.close();

        }
        fis.close();

    }
}