6.2 字节流

1.节点流—文件操作

FileInputStream

public class FileInputStream extends InputStream
(1)FileInputStream 从文件系统中的某个文件中获得输入字节。哪些文件可用取决于主机环境。 (2)FileInputStream 用于读取诸如图像数据之类的原始字节流。

FileOutputStream

public class FileOutputStream extends OutputStream
(1)文件输出流是用于将数据写入 File 或 FileDescriptor 的输出流。
文件是否可用或能否可以被创建取决于基础平台。特别是某些平台一次只允许一个 FileOutputStream（或其他文件写入对象）打开文件进行写入。在这种情况下，如果所涉及的文件已经打开，则此类中的构造方法将失败。
(2) FileOutputStream 用于写入诸如图像数据之类的原始字节的流。

例：使用字节流复制图片

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class CopImg {
    public static void main(String[] args) throws IOException {
        FileInputStream fin=new FileInputStream("C:\\Users\\Administrator\\Desktop\\Img.jpg");
        FileOutputStream fout=new FileOutputStream("C:\\Users\\Administrator\\Desktop\\ImgCopy.jpg");
        int len=0;
        byte[] buff=new byte[1024];
        while((len=fin.read(buff))!=-1) {
            fout.write(buff, 0, len);
        }
        fin.close();
        fout.close();
    }
}

2.处理流—缓冲操作

BufferedInputStream

public class BufferedInputStream extends FilterInputStream BufferedInputStream 为另一个输入流添加一些功能，即缓冲输入以及支持 mark 和 reset 方法的能力。在创建 BufferedInputStream 时，会创建一个内部缓冲区数组。在读取或跳过流中的字节时，可根据需要从包含的输入流再次填充该内部缓冲区，一次填充多个字节。mark 操作记录输入流中的某个点，reset 操作使得在从包含的输入流中获取新字节之前，再次读取自最后一次 mark 操作后读取的所有字节。

BufferedOutputStream

public class BufferedOutputStream extends FilterOutputStream 该类实现缓冲的输出流。通过设置这种输出流，应用程序就可以将各个字节写入底层输出流中，而不必针对每次字节写入调用底层系统。
例：使用字节缓冲流实现图片的复制

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class CopyImg {
    public static void main(String[] args) throws IOException {
        BufferedInputStream bfin=new BufferedInputStream(new FileInputStream("C:\\Users\\Administrator\\Desktop\\Img.jpg"));
        BufferedOutputStream bfout=new BufferedOutputStream(new FileOutputStream("C:\\Users\\Administrator\\Desktop\\ImgCopybuff.jpg"));
        int len=0;
        byte[] buff=new byte[1024];
        while((len=bfin.read(buff))!=-1) {
            bfout.write(buff, 0, len);
        }
        bfin.close();
        bfout.close();
    }
}

3.节点流—管道操作

PipedInputStream

PipedOutputStream

//todo

4.节点流—数组操作

ByteArrayInputStream

ByteArrayOutputStream

关闭这些流都是无效的，因为这些都未调用系统资源，不需要抛IO异常。

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
/**
 * 源和目的都是内存的读写过程
 *用流的思想操作数组中的数据
 */
public class ByteArrayStreamDemo {
    public static void main(String[] args) {
        //源：内存
        ByteArrayInputStream bis=new ByteArrayInputStream("andhhshad".getBytes());
        //目的：内存
        ByteArrayOutputStream bos=new ByteArrayOutputStream();//内部有个可自动增长的数组
        //因为都是源和目的都是内存，没有调用底层资源，所以不要关闭，即使调用了close也没有任何效果，关闭后仍然可使用，不会抛出异常。
        int ch=0;
        while((ch=bis.read())!=-1) {
            bos.write(ch);
        }
        System.out.println(bos.toString());
    }
}

5.处理流—基本数据类型操作

DataOutputStream

DataInputStream

6.处理流—对象序列化操作

ObjectOutputStream

public class ObjectOutputStream extends OutputStream
implements ObjectOutput, ObjectStreamConstants

(1)ObjectOutputStream 将 Java 对象的基本数据类型和图形写入 OutputStream。只能使用 ObjectInputStream 读取（重构）对象。
(2)只能将支持 java.io.Serializable 接口的对象写入流中。
(3)writeObject 方法用于将对象写入流中。所有对象（包括 String 和数组）都可以通过 writeObject 写入。可将多个对象或基元写入流中。必须使用与写入对象时相同的类型和顺序从相应 ObjectInputstream 中读回对象。 构造方法：ObjectOutputStream(OutputStream out) 创建写入指定 OutputStream 的 ObjectOutputStream。

ObjectInputStream

public class ObjectInputStream extends InputStream implements ObjectInput, ObjectStreamConstants
(1)ObjectInputStream 对以前使用 ObjectOutputStream 写入的基本数据和对象进行反序列化。
(2)只有支持 java.io.Serializable 或 java.io.Externalizable 接口的对象才能从流读取。
(3)readObject 方法用于从流读取对象。应该使用 Java 的安全强制转换来获取所需的类型。
在 Java 中，字符串和数组都是对象，所以在序列化期间将其视为对象。读取时，需要将其强制转换为期望的类型。

例：对象读写：
Student类

import java.io.Serializable;
//学生类
public class Student implements Serializable{
    private static final long serialVersionUID = -8942780382144699003L;
    String name;
    int age;
    public Student(String name,int age){
        this.name=name;
        this.age=age;
    }
    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + "]";
    }    
}

ObjectOperate

import java.io.EOFException;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
/**
 * 使用对象输出流写对象和对象输入流读对象
 *注意：如果Student没有序列化，会抛出java.io.NotSerializableException
 *Serializable：序列号，是一个标识接口，只起标识作用，没有方法
 *当一个类的对象需要IO流进行读写的时候，这个类必须实现接口
 */
public class ObjectOperate {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        writeObject();
        //创建对象输入流的对象
        ObjectInputStream ois=new ObjectInputStream(new FileInputStream("a.txt"));
        //读取对象
        try {
            while(true){
                Object obj=ois.readObject();
                System.out.println(obj);
            }
        }catch(EOFException e){
            System.out.println("读到了文件末尾");
        }
        //释放资源
        ois.close();
    }
    public static void writeObject() throws FileNotFoundException, IOException {
        //创建对象输出流的对象
        FileOutputStream fos=new FileOutputStream("a.txt");
        ObjectOutputStream oos=new ObjectOutputStream(fos);
        //创建学生对象
        Student s1=new Student("张三",20);
        Student s2=new Student("李四",30);
        Student s3=new Student("王五",10);    
        //写出学生对象
        oos.writeObject(s1);
        oos.writeObject(s2);
        oos.writeObject(s3);
        //释放资源
    }
}

ObjectOperate2

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
/**
 * 使用对象输出流写对象和对象输入流读对象
 *解决读取对象出现异常的问题,使用集合类
 */
public class ObjectOperate2 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        listMethod();
        //创建对象输入流对象
        ObjectInputStream ois=new ObjectInputStream(new FileInputStream("b.txt"));
        //读取数据
        Object obj=ois.readObject();
        //System.out.println(obj);
        //向下转型
        ArrayList<Student> list=(ArrayList<Student>) obj;
        for(Student s:list) {
            System.out.println(s);
        }
        //释放资源
        ois.close();
    }
    public static void listMethod() throws IOException, FileNotFoundException {
        //创建对象输出流的对象
        ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("b.txt"));
        //创建集合类
        ArrayList<Student> list=new ArrayList<Student>();
        //添加学生对象
        list.add(new Student("zhangsan",20));
        list.add(new Student("lisi",30));
        //写出集合对象
        oos.writeObject(list);
        //释放资源
        oos.close();
    }
}

序列化接口Serializable的作用：没有方法，不需要覆写，是一个标记接口为了启动一个序列化功能。
唯一的作用就是给每一个需要序列化的类都分配一个序列版本号，这个版本号和类相关联。
在序列化时，会将这个序列号也一同保存在文件中，在反序列化时会读取这个序列号和本类的序列号进行匹配，如果不匹配会抛出java.io.InvalidClassException.

注意：静态数据不会被序列化，因为静态数据在方法区，不在对象里。 或者使用transient关键字修饰，也不会序列化。

7.处理流—转换控制

InputStreamReader和OutputStreamWriter是字符和字节的桥梁，也可称之为字符转换流。
原理：字节流+编码。
FileReader和FileWriter作为子类，仅作为操作字符文件的便捷类存在。当操作的字符文件，使用的是默认编码表时可以不用父类，而直接使用子类完成操作，简化代码。 一旦要指定其他编码时，不能使用子类，必须使用字符转换流。

InputStreamReader

public class InputStreamReader extends Reader
(1)InputStreamReader 是字节流通向字符流的桥梁：它使用指定的 charset 读取字节并将其解码为字符。它使用的字符集可以由名称指定或显式给定，或者可以接受平台默认的字符集。

(2)每次调用 InputStreamReader 中的一个 read() 方法都会导致从底层输入流读取一个或多个字节。要启用从字节到字符的有效转换，可以提前从底层流读取更多的字节，使其超过满足当前读取操作所需的字节。

(3)为了达到最高效率，可以考虑在 BufferedReader 内包装 InputStreamReader。
例如： BufferedReader in = new BufferedReader(new InputStreamReader(System.in))；//重要

import java.io.BufferedReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
/**
 * 使用标准输入流，读取键盘录入的数据，存储到项目根目录下的a.txt中
 * 将字节输入流转换成字符输入流，InputStreamReader
 */
public class InputStreamReaderDemo {
    public static void main(String[] args) throws IOException {
        //创建输入流对象
        BufferedReader r=new BufferedReader(new InputStreamReader(System.in));
        //创建输出流对象
        FileWriter fw=new FileWriter("a.txt");
        //读写数据
        char[] chs=new char[1024];
        int len;
        while((len=r.read(chs))!=-1) {
            fw.write(chs,0,len);
            fw.flush();
        }
        //释放资源
        r.close();
        fw.close();
    }
    public static void method2() throws IOException {
        //创建输入流对象
        InputStream is=System.in;
        Reader r=new InputStreamReader(is);
        //创建输出流对象
        FileWriter fw=new FileWriter("a.txt");
        //读写数据
        char[] chs=new char[1024];
        int len;
        while((len=r.read(chs))!=-1) {
            fw.write(chs,0,len);
            fw.flush();
        }
        //释放资源
        is.close();
        fw.close();
    }
    public static void method1() throws IOException {
        //创建输入流对象
        InputStream is=System.in;
        //创建输出流对象
        FileWriter fw=new FileWriter("a.txt");
        //读写数据
        byte[] bys=new byte[1024];
        int len;
        while((len=is.read(bys))!=-1) {
            fw.write(new String(bys,0,len));
            fw.flush();
        }
        //释放资源
        is.close();
        fw.close();
    }    
}

OutputStreamWriter

public class OutputStreamWriter extends Writer
(1)OutputStreamWriter 是字符流通向字节流的桥梁：可使用指定的 charset 将要写入流中的字符编码成字节。它使用的字符集可以由名称指定或显式给定，否则将接受平台默认的字符集。

(2)每次调用 write() 方法都会导致在给定字符（或字符集）上调用编码转换器。在写入底层输出流之前，得到的这些字节将在缓冲区中累积。可以指定此缓冲区的大小，不过，默认的缓冲区对多数用途来说已足够大。注意，传递给 write() 方法的字符没有缓冲。

(3)为了获得最高效率，可考虑将 OutputStreamWriter 包装到 BufferedWriter 中，以避免频繁调用转换器。
例如： Writer out = new BufferedWriter(new OutputStreamWriter(System.out));//重要
例如：利用标准输出流将文本输出到命令行

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Writer;

/**
 * 读取项目目录下的文件copy.java,并输出到命令行
 * 由于标准输出流是字节输出流，所以只能输出字节或者字节数组，但是我们读取到的数据是字符串，如果想进行输出，
 * 还需要转换成字节数组(method1)。
 * 要想通过标准输出流输出字符串，把标准输出流转换成一种字符输出流即可(method2)。
 */
public class OutputStreamWriterDemo {
    public static void main(String[] args) throws IOException {
        //创建输入流
        BufferedReader br=new BufferedReader(new FileReader("copy.java"));
        //创建输出流
        BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
        String line;//用于接收读到的数据
        while((line=br.readLine())!=null) {
            bw.write(line);
            bw.write("\r\n");
        }
        br.close();
        bw.close();
    }

    public static void method2() throws FileNotFoundException, IOException {
        //创建输入流
        BufferedReader br=new BufferedReader(new FileReader("copy.java"));
        //创建输出流
        //OutputStream os=System.out;
        Writer w=new OutputStreamWriter(System.out);//多态，父类引用指向子类对象
        String line;//用于接收读到的数据
        while((line=br.readLine())!=null) {
            w.write(line);
            w.write("\r\n");
        }
        br.close();
        w.close();
    }

    public static void method1() throws FileNotFoundException, IOException {
        //创建输入流
        BufferedReader br=new BufferedReader(new FileReader("copy.java"));
        //创建输出流
        OutputStream os=System.out;
        String line;//用于接收读到的数据
        while((line=br.readLine())!=null) {
            os.write(line.getBytes());
            os.write("\r\n".getBytes());
        }
        br.close();
        os.close();
    }
}

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;

public class TransStreamDemo {
    public static void main(String[] args) throws IOException {
        writeCN();
        readCN();
    }

    public static void readCN() throws UnsupportedEncodingException, FileNotFoundException, IOException {
        //InputStreamReader将字节数组使用指定的编码表解码成文字
        InputStreamReader isr=new InputStreamReader(new FileInputStream("temp.txt"),"utf-8");
        char[] buff=new char[1024];
        int len=isr.read(buff);
        System.out.println(new String(buff,0,len));
        isr.close();
    }

    public static void writeCN() throws UnsupportedEncodingException, FileNotFoundException, IOException {
        //OutputStreamWriter将字符串按照指定的编码表转成字节，再使用字符流将这些字节写出去
        OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("temp.txt"),"utf-8");//本身是字符流，传入字节流
        osw.write("你好");
        osw.close();
    }
}

8.处理流—打印控制

PrintWriter

public class PrintWriter extends Writer
(1)向文本输出流打印对象的格式化表示形式。此类实现在 PrintStream 中的所有 print 方法。不能输出字节，但是可以输出其他任意类型。

(2)与 PrintStream 类不同，如果启用了自动刷新，则只有在调用 println、printf 或 format 的其中一个方法时才可能完成此操作，而不是每当正好输出换行符时才完成。这些方法使用平台自有的行分隔符概念，而不是换行符。

(3)此类中的方法不会抛出 I/O 异常，尽管其某些构造方法可能抛出异常。客户端可能会查询调用 checkError() 是否出现错误。

import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
/**
 * 注意：创建FileWriter对象时boolean参数表示是否追加；
 *              而创建打印流对象时boolean参数表示是否自动刷新
 */
public class PrintWriterDemo {
    public static void main(String[] args) throws IOException {
        //PrintWriter pw=new PrintWriter("print.txt");
        PrintWriter pw=new PrintWriter(new FileWriter("print.txt"),true);
        pw.write("测试打印流");
        pw.println("此句之后换行");
        pw.println("特有功能：自动换行和自动刷新");
        pw.println("利用构造器设置自动刷新");
        pw.close();
    }
}

使用字符打印流复制文本文件：

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
/**
 * 使用打印流复制文本文件
 */
public class PrintWriterDemo {
    public static void main(String[] args) throws IOException {
        BufferedReader br=new BufferedReader(new FileReader("copy.java"));
        PrintWriter pw=new PrintWriter("printcopy.java");
        String line;
        while((line=br.readLine())!=null) {
            pw.println(line);
        }
        br.close();
        pw.close();
    }
}

PrintStream

public class PrintStream extends FilterOutputStreamimplements Appendable, Closeable
(1)PrintStream 为其他输出流添加了功能（增加了很多打印方法），使它们能够方便地打印各种数据值表示形式(例如：希望写一个整数，到目的地整数的表现形式不变。字节流的write方法只将一个整数的最低字节写入到目的地，比如写fos.write(97)，到目的地（记事本打开文件）会变成字符’a’,
需要手动转换：fos.write(Integer.toString(97).getBytes());而采用PrintStream：ps.print(97)，则可以保证数据的表现形式)。

//PrintStream的print方法 
public void print(int i) {
    write(String.valueOf(i));
}

(2)与其他输出流不同，PrintStream 永远不会抛出 IOException；而是，异常情况仅设置可通过 checkError 方法测试的内部标志。
另外，为了自动刷新，可以创建一个 PrintStream；这意味着可在写入 byte 数组之后自动调用 flush 方法，可调用其中一个 println 方法，或写入一个换行符或字节 (‘\n’)。

(3)PrintStream 打印的所有字符都使用平台的默认字符编码转换为字节。在需要写入字符而不是写入字节的情况下，应该使用 PrintWriter 类。
使用字节打印流复制文本文件：

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintStream;

public class PrintStreamDemo {
    public static void main(String[] args) throws IOException {
        BufferedReader br=new BufferedReader(new FileReader("copy.java"));
        PrintStream ps=new PrintStream("printcopy2.java");
        String line;
        while((line=br.readLine())!=null) {
            ps.println(line);
        }
        br.close();
        ps.close();
    }
}

9.RandomAccessFile

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;

/**
 * 注意：随机读写。数据需要规律。用RandomAccessFile类需要明确要操作的数据的位置。
 *
 */
public class RandomAccessFileDemo {
    public static void main(String[] args) throws IOException {
        //writeFile();
        RandomAccessFile raf=new RandomAccessFile("tempFile\\test.txt","r");
        raf.seek(8*1);//读第二个人
        byte[] buf=new byte[4];
        raf.read(buf);
        String name=new String(buf);
        System.out.println("name="+name);

        int age=raf.readInt();
        System.out.println("age="+age);
        raf.close();
    }

    public static void writeFile() throws FileNotFoundException, IOException {
        //明确要操作的位置，可以多个线程操作同一份文件而不冲突。多线程下载的基本原理。
        RandomAccessFile raf=new RandomAccessFile("tempFile\\test.txt","rw");

        raf.write("张三".getBytes());
        raf.writeInt(97);//保证字节原样性

        raf.write("李四".getBytes());
        raf.writeInt(99);//保证字节原样性

        System.out.println(raf.getFilePointer());//获取随机指针
        raf.seek(8*2);//设置指针
        raf.write("王五".getBytes());
        raf.writeInt(100);//保证字节原样性
        raf.close();
    }
}

10.SequenceInputStream

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

案例：媒体文件切割与合并
切割文件

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;

public class CutFile {
    /**
     * 将一个媒体文件切割成碎片
     * 思路：1、读取源文件，将源文件的数据分别复制到多个文件
     * 2、切割方式有两种：按照碎片个数切，或者按照指定大小切
     * 3、一个输入流对应多个输出流
     * 4、每个碎片都需要编号，顺序不能错
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException {
        File srcFile=new File("C:\\Users\\Administrator\\Desktop\\Test\\img.jpg");
        File partsDir=new File("C:\\Users\\Administrator\\Desktop\\cutFiles");
        splitFile(srcFile,partsDir);

    }
    //切割文件
    private static void splitFile(File srcFile, File partsDir) throws IOException {
        if(!(srcFile.exists()&&srcFile.isFile())) {
            throw new RuntimeException("源文件不是正确文件或者不存在");
        }
        if(!partsDir.exists()) {
            partsDir.mkdirs();
        }
        FileInputStream fis=new FileInputStream(srcFile);
        FileOutputStream fos=null;

        byte[] buf=new byte[1024*60];

        int len=0;
        int count=1;
        while((len=fis.read(buf))!=-1) {
            //存储碎片文件
            fos=new FileOutputStream(new File(partsDir,(count++)+".part"));
            fos.write(buf, 0, len);
            fos.close();
        }
        /*将源文件和切割的信息也保存起来，随着碎片文件一起发送
         * 信息：源文件的名称
         * 碎片的个数
         *将这些信息单独封装到一个文件中
         *还要一个输出流完成此操作 */

        String fileName=srcFile.getName();
        int partCount=count;
        fos=new FileOutputStream(new File(partsDir,count+".properties"));
//        fos.write(("fileName="+fileName+System.lineSeparator()).getBytes());
//        fos.write(("fileCount="+Integer.toString(partCount)).getBytes());
        Properties prop=new Properties();
        prop.setProperty("fileName", srcFile.getName());
        prop.setProperty("partCount", Integer.toString(partCount));
        //将属性集中的信息持久化
        prop.store(fos, "part file info");
        fis.close();
        fos.close();

    }
}

合并文件

import java.io.File;
import java.io.FileFilter;
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.Collections;
import java.util.Enumeration;
import java.util.List;
import java.util.Properties;

public class mergeFile {
    public static void main(String[] args) throws IOException {
        File pathDir=new File("C:\\Users\\Administrator\\Desktop\\cutFiles");
        //获取配置文件
        File configFile=getconfigFile(pathDir);
        //获取配置文件信息的属性集
        Properties prop=getProperties(configFile);
        System.out.println(prop);
        //获取属性集信息，将属性集信息传递到合并方法中
        merge(pathDir,prop);
    }

    private static Properties getProperties(File configFile) throws IOException {
        FileInputStream fis=null;
        Properties prop=null;
        try {
        //读取流和配置文件相关联
        fis=new FileInputStream(configFile);
        prop=new Properties();
        //流中的数据加载到集合中
        prop.load(fis);
        }finally {
            if(fis!=null) {
                fis.close();
            }
        }
        return prop;
    }

    public static File getconfigFile(File pathDir) {    
        //判断是否存在properties文件
        if(!(pathDir.exists()&&pathDir.isDirectory())) {
            throw new RuntimeException(pathDir.toString()+"不是有效目录");
        }
        File[] files=pathDir.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                return pathname.getName().endsWith(".properties");
            }

        });
        if(files.length!=1) {
            throw new RuntimeException(pathDir.toString()+"properties扩展名的文件不存在或者不唯一");
        }
        File configFile=files[0];
        return configFile;
    }

    public static void merge(File pathDir, Properties prop) throws FileNotFoundException, IOException {
        String fileName=prop.getProperty("fileName");
        int partCount=Integer.valueOf(prop.getProperty("partCount"));
        List<FileInputStream> list=new ArrayList<FileInputStream>();
        for(int i=1;i<partCount;i++) {
            list.add(new FileInputStream(pathDir.toString()+"\\"+i+".part"));
        }
        //List自身无法获取Enumeration工具类，到Collection中找
        Enumeration<FileInputStream> en=Collections.enumeration(list);
        SequenceInputStream sis=new SequenceInputStream(en);
        FileOutputStream fos=new FileOutputStream(pathDir.toString()+"\\"+fileName);
        byte[] buf=new byte[1024];
        int len=0;
        while((len=sis.read(buf))!=-1) {
            fos.write(buf,0,len);
        }
        fos.close();
        sis.close();
    }

}