序列流_SequenceInputStream类

序列流：

SequenceInputStream 表示其他输入流的逻辑串联。对多个流进行合并。它从输入流的有序集合开始，并从第一个输入流开始读取，直到到达文

件末尾，接着从第二个输入流读取，依次类推，直到到达包含的最后一个输入流的文件末尾为止。

Demo1：利用序列流合并文件

package com.cn.sequenceInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.SequenceInputStream;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Vector;
/**
* Author：Liu Zhiyong
* Version：Version_1
* Date：2016年7月30日20:59:06
* Desc：
字节流：
输入字节流：
----------------| InputStream  所有输入字节流的基类， 抽象类
---------------------| FileInputStream 读取文件数据的输入字节流
---------------------| BufferedInputStream 缓冲输入字符流 ，该类出现的目的，是为了提高读取文件的效率，这个类其实只不过是在内部维护一个8Kb的字节数组而已。
 输出字节流：
----------------| OutputStream 所有输出字节流的基类，抽象类
---------------------| FileOutputStream 向文件输出数据的输出字节流
---------------------| BufferedOutputStream 缓冲输出字节流，该类出现的目的，是为了提高向文件写数据的效率。这个类也只不过是在内部维护了一个8Kb的字节数组而已。
字符流： 字符流 = 字节流 + 编码（解码）
输入字符流：
----------------| Reader 所有输入字符流的基类，抽象类
---------------------| FileReader 读取文件数据的输入字符流
---------------------| BufferedReader 缓冲输入字符流。该类出现的目的是为了提高读取文件数据的效率与拓展FileReader的功能（readLine()）。这个类的内部也只不过是在内部维护了一个8Kb的字符数组而已。
----------------| Writer 所有输出字符流的基类，抽象类
---------------------| FileWriter 向文件输出数据的输出字符流
---------------------| BufferedWriter 缓冲输出字符流，该类出现的目的，是为了提高向文件写数据的效率与拓展FileWriter的功能（newLine()）。
序列流：
  SequenceInputStream 表示其他输入流的逻辑串联。对多个流进行合并。它从输入流的有序集合开始，并从第一个输入流开始读取，直到到达文件末尾，接着从第二个输入流读取，依次类推，直到到达包含的最后一个输入流的文件末尾为止。
*/
public class Demo1 {
  public static void main(String[] args) throws IOException {
//    merge1();
//    merge2();
    merge3();
  }
  
  public static void merge1() throws IOException{
    //找到目标文件
    File inFile1 = new File("f:/a.txt");
    File inFile2 = new File("f:/b.txt");
    File outFile = new File("f:/c.txt");
    //建立数据通道
    FileInputStream fileInputStream1 = new FileInputStream(inFile1);
    FileInputStream fileInputStream2 = new FileInputStream(inFile2);
    
    FileOutputStream fileOutputStream = new FileOutputStream(outFile);
    
    //把输入流存储到集合中再从集合中读取出来
    ArrayList<FileInputStream> list = new ArrayList<FileInputStream>();
    list.add(fileInputStream1);
    list.add(fileInputStream2);
    
    for(FileInputStream fileInputStream : list){
      //准备一个缓冲数组
      byte[] buf = new byte[1024];
      int length = 0;
      while((length = fileInputStream.read(buf)) != -1){
        fileOutputStream.write(buf, 0, length);
      }
      //关闭资源
      fileInputStream.close();
    }
    
    //关闭资源
    fileOutputStream.close(); 
  }
  
  /**
   * SequenceInputStream(InputStream s1, InputStream s2) 
      通过记住这两个参数来初始化新创建的 SequenceInputStream（将按顺序读取这两个参数，先读取 s1，然后读取 s2），
      以提供从此 SequenceInputStream 读取的字节。
   * @throws IOException
   */
  public static void merge2() throws IOException{
    //找到目标文件
    File inFile1 = new File("f:/a.txt");
    File inFile2 = new File("f:/b.txt");
    File outFile = new File("f:/c.txt");
    //建立数据通道
    FileInputStream fileInputStream1 = new FileInputStream(inFile1);
    FileInputStream fileInputStream2 = new FileInputStream(inFile2);
    FileOutputStream fileOutputStream = new FileOutputStream(outFile);
    
    SequenceInputStream sequenceInputStream = new SequenceInputStream(fileInputStream1, fileInputStream2);
    
    int length = 0;
    byte[] buf = new byte[1024];
    while((length = sequenceInputStream.read(buf)) != -1){
      fileOutputStream.write(buf, 0, length);
    }
    
    //关闭资源
    sequenceInputStream.close();
    fileOutputStream.close();
  } 
  
  /** SequenceInputStream(Enumeration<? extends InputStream> e) 
                           通过记住参数来初始化新创建的 SequenceInputStream，
                           该参数必须是生成运行时类型为 InputStream 对象的 Enumeration 型参数。*/
  public static void merge3() throws IOException{
    //找到目标文件
    File inFile1 = new File("f:/a.txt");
    File inFile2 = new File("f:/b.txt");
    File inFile3 = new File("f:/c.txt");
    File outFile = new File("f:/d.txt");
    //建立数据通道
    FileInputStream fileInputStream1 = new FileInputStream(inFile1);
    FileInputStream fileInputStream2 = new FileInputStream(inFile2);
    FileInputStream fileInputStream3 = new FileInputStream(inFile3);
    FileOutputStream fileOutputStream = new FileOutputStream(outFile);
    Vector<InputStream> vector = new Vector<InputStream>();
    vector.add(fileInputStream1);
    vector.add(fileInputStream2);
    vector.add(fileInputStream3);
    Enumeration<InputStream> elements = vector.elements();
    
    SequenceInputStream sequenceInputStream = new SequenceInputStream(elements);
    
    int length = 0;
    byte[] buf = new byte[1024];
    while((length = sequenceInputStream.read(buf)) != -1){
      fileOutputStream.write(buf, 0, length);
    }
    
    //关闭资源
    sequenceInputStream.close();
    fileOutputStream.close();
  }
}

package com.cn.sequenceInputStream;
import java.awt.List;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.SequenceInputStream;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Vector;
/**
* Author：Liu Zhiyong
* Version：Version_1
* Date：2016年7月31日09:35:57
* Desc：
需求：把一首4.371M的mp3先切成5份，然后再把这些文件合并起来。
*/
public class Demo2 {
  public static void main(String[] args) throws IOException {
    //先切割文件
//    cutFile1();
    cutFile2();
    //合并数据
//    mergeFile1();
    mergeFile2();
  }
  
  /**
   * 切割文件  方式1
   * @throws IOException
   */
  public static void cutFile1() throws IOException{
    //找到目标文件
    File srcFile = new File("f:/饿狼传说.mp3");
    //方式1
    File destFile1 = new File("f:/饿狼传说1.mp3");
    File destFile2 = new File("f:/饿狼传说2.mp3");
    File destFile3 = new File("f:/饿狼传说3.mp3");
    File destFile4 = new File("f:/饿狼传说4.mp3");
    File destFile5 = new File("f:/饿狼传说5.mp3");
    //建立数据通道
    FileInputStream fileInputStream = new FileInputStream(srcFile);
    FileOutputStream fileOutputStream1 = new FileOutputStream(destFile1);
    FileOutputStream fileOutputStream2 = new FileOutputStream(destFile2);
    FileOutputStream fileOutputStream3 = new FileOutputStream(destFile3);
    FileOutputStream fileOutputStream4 = new FileOutputStream(destFile4);
    FileOutputStream fileOutputStream5 = new FileOutputStream(destFile5);
    ArrayList<FileOutputStream> list = new ArrayList<FileOutputStream>();
    list.add(fileOutputStream1);
    list.add(fileOutputStream2);
    list.add(fileOutputStream3);
    list.add(fileOutputStream4);
    list.add(fileOutputStream5);
    //建立1M大小缓冲数组
    byte[] buf = new byte[1024*1024];
    int length = 0;
    int i = 0;
    
    while((length = fileInputStream.read(buf)) != -1){
      list.get(i).write(buf, 0, length);
      i++;
    }
      
    
    fileOutputStream4.close();
    fileOutputStream3.close();
    fileOutputStream2.close();
    fileOutputStream1.close();
    fileInputStream.close();
  }
  /**
   * 切割文件  方式2
   * @throws IOException
   */
  public static void cutFile2() throws IOException{
    //找到目标文件
    File srcFile = new File("f:/饿狼传说.mp3");
    File dir = new File("f:/cut_merge_music");
    //建立数据通道
    FileInputStream fileInputStream = new FileInputStream(srcFile);
    //建立1M大小缓冲数组
    byte[] buf = new byte[1024*1024];
    int length = 0;
    
    for(int i=1; (length = fileInputStream.read(buf)) != -1; i++ ){
      FileOutputStream fileOutputStream = new FileOutputStream(new File(dir, "part"+i+".mp3"));
      fileOutputStream.write(buf, 0, length);
      fileOutputStream.close(); //关闭资源
    }
    
    fileInputStream.close();
  }
  
  public static void mergeFile1() throws IOException{
    //找到目标文件
    File srcFile1 = new File("f:/饿狼传说1.mp3");
    File srcFile2 = new File("f:/饿狼传说2.mp3");
    File srcFile3 = new File("f:/饿狼传说3.mp3");
    File srcFile4 = new File("f:/饿狼传说4.mp3");
    File srcFile5 = new File("f:/饿狼传说5.mp3");
    File destFile = new File("f:/饿狼传说全.mp3");
    
    //建立数据通道
    FileInputStream fileInputStream1 = new FileInputStream(srcFile1);
    FileInputStream fileInputStream2 = new FileInputStream(srcFile2);
    FileInputStream fileInputStream3 = new FileInputStream(srcFile3);
    FileInputStream fileInputStream4 = new FileInputStream(srcFile4);
    FileInputStream fileInputStream5 = new FileInputStream(srcFile5);
    FileOutputStream fileOutputStream = new FileOutputStream(destFile);
    
    Vector<FileInputStream> list = new Vector<FileInputStream>();
    list.add(fileInputStream1);
    list.add(fileInputStream2);
    list.add(fileInputStream3);
    list.add(fileInputStream4);
    list.add(fileInputStream5);
    Enumeration<FileInputStream> elements = list.elements();
    
    //建立序列流
    SequenceInputStream sequenceInputStream = new SequenceInputStream(elements);
    //建立小缓冲数组
    byte[] buf = new byte[1024];
    int length = 0;
    int i = 0;
    //写出数据
    while((length = sequenceInputStream.read(buf)) != -1){
      fileOutputStream.write(buf, 0, length);
    }
      
    //关闭资源
    sequenceInputStream.close();
    fileOutputStream.close();
  }
  
  public static void mergeFile2() throws IOException{
    //找到目标文件
    File dir = new File("f:/cut_merge_music");
    File destFile = new File("f:/cut_merge_music/饿狼传说全.mp3");
    //通过目标文件夹找到所有的MP3文件，然后把所有的MP3文件添加到vector中 
    Vector<FileInputStream> list = new Vector<FileInputStream>();
    File[] listFiles = dir.listFiles();
    for(File file : listFiles){
      if(file.getName().endsWith(".mp3")){
        list.add(new FileInputStream(file));
      }
    }
    
    //通过Vector获取迭代器
    Enumeration<FileInputStream> elements = list.elements();
    
    //建立文件 的输出通道
    FileOutputStream fileOutputStream = new FileOutputStream(destFile);
    //建立序列流
    SequenceInputStream sequenceInputStream = new SequenceInputStream(elements);
    //建立小缓冲数组
    byte[] buf = new byte[1024];
    int length = 0;
    int i = 0;
    //写出数据
    while((length = sequenceInputStream.read(buf)) != -1){
      fileOutputStream.write(buf, 0, length);
    }
      
    //关闭资源
    sequenceInputStream.close();
    fileOutputStream.close();
  }
}

序列流_SequenceInputStream类

继续阅读

关于Gradle配置的小结

Java小案例——随机数猜测随机数猜测

nginx location中斜线的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的简单使用

neo4j之cypher使用文档

GitHub连夜封杀！这份阿里 10W 字内部 Java 字面试手册到底有多强？

spark/scala关于【资源文件】加载方法概述外部文件加载方案测试资源文件打包入jar包中小结

mybatis_入门程序Mybatis入门

AOP编程_Android优雅权限框架(1)概念基础，2021金三银四前言正文大纲正文

Effective Java 8:通用程序设计

OOM三种类型

工厂模式-三种类型

【递归】高效率求2的n次幂

win10本地scala和spark安装安装scala安装spark

scala (3) Function 和 Method