其它几个常用的IO辅助流

常用的其它流

1、数据流(DataInputStream/DataOutputStream)

java.io
类 DataInputStream

java.lang.Object
  继承者
java.io.InputStream

  继承者

java.io.FilterInputStream
  继承者

java.io.DataInputStream

public class DataInputStream

　　extends FilterInput Stream

　　　　　　implements DataInput

数据输入流允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型。应用程序可以使用数据输出流写入稍后由数据输入流读取的数据。

DataInputStream 对于多线程访问不一定是安全的。 线程安全是可选的，它由此类方法的使用者负责。

数据输出流类似，具体可查看jdk文档。

数据的访问和其它流有所不同

先写出，后读取

*读取的顺序与写出保持一致

写出的时候就可以使用ByteArrayOutputStream 写到内存里

package com.sxt.io;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;

/**
 * 数据流:
 * 1、写出后读取
 * 2、读取的顺序与写出保持一致
 * 
 * DataOutputStream
 * DataInputStream
 * @author liuzeyu12a
 *
 */
public class DataTest {

    public static void main(String[] args) throws IOException {
        //写出
        ByteArrayOutputStream baos =new ByteArrayOutputStream();
        DataOutputStream dos =new DataOutputStream(new BufferedOutputStream(baos));
        //操作数据类型 +数据
        dos.writeUTF("编码辛酸泪");
        dos.writeInt(18);
        dos.writeBoolean(false);
        dos.writeChar('a');
        dos.flush();
        byte[] datas =baos.toByteArray();
        System.out.println(datas.length);
        //读取
        DataInputStream dis =new DataInputStream(new BufferedInputStream(new ByteArrayInputStream(datas)));
        //顺序与写出一致
        String msg = dis.readUTF(); 
        int age = dis.readInt();
        boolean flag = dis.readBoolean();
        char ch = dis.readChar();
        System.out.println(flag);
    }

}

2、对象流(ObjectInputStream/ObjectOutputStream)

(对象的序列化与反序列化)

java.io
类 ObjectInputStream

java.lang.Object
  继承者

java.io.InputStream

  继承者

java.io.ObjectInputStream

public class ObjectInputStream
　　extends InputStream
　　　　implements ObjectInput, ObjectStreamConstants

ObjectInputStream

（1）ObjectInputStream 对以前使用 ObjectOutputStream 写入的基本数据和对象进行反序列化。

（2）只有支持 java.io.Serializable 或 java.io.Externalizable 接口的对象才能从流读取。

（3）readObject 方法用于从流读取对象。应该使用 Java 的安全强制转换来获取所需的类型。在 Java 中，字符串和数组都是对象，所以在序列化期间将其视为对象。读取时，需要将其强制转换为期望的类型。

ObjectOutputStream的继承树与ObjectOutputStream类似

public class ObjectOutputStream
　　extends OutputStream
　　　　implements ObjectOutput, ObjectStreamConstants

ObjectOutputStream

（1）ObjectOutputStream 将 Java 对象的基本数据类型和图形写入 OutputStream。只能使用 ObjectInputStream 读取（重构）对象。

（2）只能将支持 java.io.Serializable 接口的对象写入流中。

（3）writeObject 方法用于将对象写入流中。所有对象（包括 String 和数组）都可以通过 writeObject 写入。可将多个对象或基元写入流中。必须使用与写入对象时相同的类型和顺序从相应 ObjectInputstream 中读回对象。

构造方法：ObjectOutputStream(OutputStream out)  　　

创建写入指定 OutputStream 的 ObjectOutputStream。

我们对外提供一个类Employee 用于被序列化和反序列化
代码：

//javabean 封装数据
class Employee implements java.io.Serializable{
    private transient String name; //该数据不需要序列化
    private double salary;
    public Employee() {
    }
    public Employee(String name, double salary) {
        this.name = name;
        this.salary = salary;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public double getSalary() {
        return salary;
    }
    public void setSalary(double salary) {
        this.salary = salary;
    }
    
}

操作这个类：

package com.sxt.io;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Date;

/**
 * 对象流:
 * 1、写出后读取
 * 2、读取的顺序与写出保持一致
 * 3、不是所有的对象都可以序列化Serializable
 * 
 * ObjectOutputStream
 * ObjectInputStream
 * @author liuzeyu
 *
 */
public class ObjectTest {

    public static void main(String[] args) throws IOException, ClassNotFoundException {

        //写出 -->序列化
        ByteArrayOutputStream baos =new ByteArrayOutputStream();
        ObjectOutputStream oos =new ObjectOutputStream(new BufferedOutputStream(baos));
        //操作数据类型 +数据
        oos.writeUTF("编码辛酸泪");
        oos.writeInt(18);
        oos.writeBoolean(false);
        oos.writeChar('a');
        //对象
        oos.writeObject("谁解其中味");
        oos.writeObject(new Date());
        Employee emp =new Employee("马云",400);
        oos.writeObject(emp);
        oos.flush();
        byte[] datas =baos.toByteArray();
        System.out.println(datas.length);

        //读取 -->反序列化
        ObjectInputStream ois =new ObjectInputStream(new BufferedInputStream(new ByteArrayInputStream(datas)));
        //顺序与写出一致
        String msg = ois.readUTF(); 
        int age = ois.readInt();
        boolean flag = ois.readBoolean();
        char ch = ois.readChar();
        System.out.println(flag);
        //对象的数据还原  
        Object str = ois.readObject();
        Object date = ois.readObject();
        Object employee = ois.readObject();
        
        if(str instanceof String) {
            String strObj = (String) str;
            System.out.println(strObj);
        }
        if(date instanceof Date) {
            Date dateObj = (Date) date;
            System.out.println(dateObj);
        }
        if(employee instanceof Employee) {
            Employee empObj = (Employee) employee;
            System.out.println(empObj.getName()+"-->"+empObj.getSalary());
        }
        
    }

}

其中对象流即可以操作基本数据类型，类似于数据流。也可以操作对象-->写出的过程称为类序列化，读取的过程称为反序列化。
这个时候时间对象的数据存入内存中，当然我们也可以存入到文件中。
见代码：

package com.sxt.io;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Date;

/**
 * 对象流: 1、写出后读取 2、读取的顺序与写出保持一致 3、不是所有的对象都可以序列化Serializable
 * 
 * ObjectOutputStream ObjectInputStream
 * 
 * @author liuzeyu12a
 *
 */
public class ObjectTest02 {

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        // 写出 -->序列化
        ObjectOutputStream oos = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream("obj.ser")));
        // 操作数据类型 +数据
        oos.writeUTF("编码辛酸泪");
        oos.writeInt(18);
        oos.writeBoolean(false);
        oos.writeChar('a');
        // 对象
        oos.writeObject("谁解其中味");
        oos.writeObject(new Date());
        Employee emp = new Employee("马云", 400);
        oos.writeObject(emp);
        oos.flush();
        oos.close();

        // 读取 -->反序列化
        ObjectInputStream ois = new ObjectInputStream(new BufferedInputStream(new FileInputStream("obj.ser")));
        // 顺序与写出一致
        String msg = ois.readUTF();
        int age = ois.readInt();
        boolean flag = ois.readBoolean();
        char ch = ois.readChar();
        System.out.println(flag);

        // 对象的数据还原
        Object str = ois.readObject();
        Object date = ois.readObject();
        Object employee = ois.readObject();

        if (str instanceof String) {
            String strObj = (String) str;
            System.out.println(strObj);
        }
        if (date instanceof Date) {
            Date dateObj = (Date) date;
            System.out.println(dateObj);
        }
        if (employee instanceof Employee) {
            Employee empObj = (Employee) employee;
            System.out.println(empObj.getName() + "-->" + empObj.getSalary());
        }
        ois.close();
    }
}

3、打印流PrintWriter和PrintStream

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();
    }
}

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

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

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

PrintStream 的其它操作

package io深入学习;

import java.io.BufferedOutputStream;
import java.io.FileDescriptor;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;

public class PrintStream1 {

    public static void main(String[] args) throws FileNotFoundException {

        PrintStream ps = System.out;  //将System.out赋值给ps对象
        ps.println("我是谁???");
        ps.print(false);
    
        //创建文件输出流以写入由指定的 File对象表示的文件。 
        ps = new PrintStream(
                new BufferedOutputStream(
                        new FileOutputStream("print.txt")),true);
        ps.print("这是打印流...");
        ps.println("打印到文件里的");
        ps.flush();   //确记要flush
        
        System.setOut(ps);//重定向到文件
        System.out.println("changeing");
        ps.flush();  //将把"change" 输出到文件里
        
        //重定向回控制台
        ps = new PrintStream(
                new BufferedOutputStream(
                        new FileOutputStream(FileDescriptor.out)),true);
        System.setOut(ps);
        System.out.println("我又回来控制台了...");
    }

}

3、RandomAccessFile文件随机读写类

java.lang.Object

  继承

java.io.RandomAccessFile

public class RandomAccessFile
　　　extends Object
　　　　implements DataOutput, DataInput, Closeable
常用的构造方法：

public RandomAccessFile(File file,
                        String mode)
                 throws FileNotFoundException

mode 参数指定用以打开文件的访问模式。允许的值及其含意为：

值	含意
"r"	以只读方式打开。调用结果对象的任何 write 方法都将导致抛出 IOException。
"rw"	打开以便读取和写入。如果该文件尚不存在，则尝试创建该文件。
"rws"	打开以便读取和写入，对于 "rw"，还要求对文件的内容或元数据的每个更新都同步写入到底层存储设备。
"rwd"	打开以便读取和写入，对于 "rw"，还要求对文件内容的每个更新都同步写入到底层存储设备。

该类对象并不是流体系中的一员，其封装了字节流，同时还封装了一个缓冲区（字符数组），通过内部的指针来操作字符数组中的数据。 该对象特点：

1. 该对象只能操作文件，所以构造函数接收两种类型的参数：a.字符串文件路径；b.File对象。
2. 该对象既可以对文件进行读操作，也能进行写操作，在进行对象实例化时可指定操作模式(r,rw)

通常，如果此类中的所有读取例程在读取所需数量的字节之前已到达文件末尾，则抛出 EOFException（是一种 IOException）。
如果由于某些原因无法读取任何字节，而不是在读取所需数量的字节之前已到达文件末尾，则抛出 IOException，而不是 EOFException。
需要特别指出的是，如果流已被关闭，则可能抛出 IOException。 

注意：该对象在实例化时，如果要操作的文件不存在，会自动创建；如果文件存在，写数据未指定位置，会从头开始写，即覆盖原有的内容。 可以用于多线程下载或多个线程同时写数据到文件。

package io深入学习;

import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;

public class RAccessFile {

    public static void main(String[] args) throws IOException{
        test03();

    }
    
    //自定起始内容，读取剩余内容
    public static void test01()  throws IOException {
        RandomAccessFile raf = new RandomAccessFile(new File("Copy.java"),"rw");
        //从第二个位置开始访问文件
        raf.seek(2);
        int temp=0;
        byte [] flush = new byte[1024];
        while((temp = raf.read(flush))!=-1) {
            System.out.print(new String(flush,0,temp));
        }
    }
    
    //分块思想：起始和实际大小
    public static void test02() throws IOException {
        RandomAccessFile  raf = new RandomAccessFile(new File("Copy.java"),"rw");
        int actualSize = 1026;
        int pos = 2;
        int temp =0;
        raf.seek(pos);
        byte[] flush = new byte[1024];
        while((temp = raf.read(flush))!=-1) {
            if(actualSize > temp) {//1026>1024 故读取1024个字节
                System.out.println(new String(flush,0,temp));
                actualSize -=temp;
            }else {  //读取剩下的字节数
                System.out.println(new String(flush,0,actualSize));
                break;
            }
        }
    }


    //分几块?每块大小?
    public static void test03() throws IOException {        
        long bPos = 2;    
        File src = new File("Copy.java");
        
        long blockSize = 100;
        long len  = src.length();
        long actualSize = blockSize>len?len:blockSize;
        System.out.println("文件大小："+len);
        int size = (int) Math.ceil(((1.0*len)/blockSize));  //转为double并向上取整
        System.out.println("块数"+size);
        for(int i = 0 ;i <size;i++) {
            bPos = i*blockSize;
            if(i == size-1) { //最后一块
                actualSize = len;
            }else {
                actualSize = blockSize;
                len -=actualSize;            
            }        
            System.out.println(i+"-->"+bPos +"-->"+actualSize);
            split(i,bPos,actualSize);
        }            
    }

//分块思想：起始和实际大小
    public static void split(int i,long bPos,long actualSize) throws IOException {
        RandomAccessFile  raf = new RandomAccessFile(new File("Copy.java"),"rw");
        RandomAccessFile  raf2 = new RandomAccessFile(new File("dest/"+i+"Copy.java"),"rw");
        int temp =0;
        raf.seek(bPos);
        byte[] flush = new byte[100];
        while((temp = raf.read(flush))!=-1) {
            if(actualSize > temp) {        //1026>1024 故读取1024个字节
                System.out.println(new String(flush,0,temp));            
                actualSize -=temp;
                raf2.write(flush,0,temp);
            }else {  //读取剩下的字节数
                System.out.println(new String(flush,0,(int)actualSize));
                raf2.write(flush,0,(int)actualSize);
                break;
            }
        }
    }
}

代码重新优化

package com.sxt.io;

import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;

/**
 * 随机读取和写入流 RandomAccessFile
 * @author liuzeyu12a
 *
 */
public class RandTest02 {

    public static void main(String[] args) throws IOException {
        //分多少块
        File src = new File("p.png");
        //总长度
        long len = src.length();
        //每块大小
        int blockSize =1024;
        //块数: 多少块
        int size =(int) Math.ceil(len*1.0/blockSize);
        System.out.println(size);
        
        //起始位置和实际大小
        int beginPos = 0;
        int actualSize = (int)(blockSize>len?len:blockSize); 
        for(int i=0;i<size;i++) {
            beginPos = i*blockSize;
            if(i==size-1) { //最后一块
                actualSize = (int)len;
            }else {
                actualSize = blockSize;
                len -=actualSize; //剩余量
            }
            System.out.println(i+"-->"+beginPos +"-->"+actualSize);
            split(i,beginPos,actualSize);
        }
        
    }
    /**
     * 指定第i块的起始位置 和实际长度
     * @param i
     * @param beginPos
     * @param actualSize
     * @throws IOException
     */
    public static void split(int i,int beginPos,int actualSize ) throws IOException {
        RandomAccessFile raf =new RandomAccessFile(new File("p.png"),"r");
        RandomAccessFile raf2 =new RandomAccessFile(new File("dest/"+i+"p.png"),"rw");
        //随机读取 
        raf.seek(beginPos);
        //读取
        //3、操作 (分段读取)
        byte[] flush = new byte[1024]; //缓冲容器
        int len = -1; //接收长度
        while((len=raf.read(flush))!=-1) {            
            if(actualSize>len) { //获取本次读取的所有内容
                raf2.write(flush, 0, len);
                actualSize -=len;
            }else { 
                raf2.write(flush, 0, actualSize);
                break;
            }
        }            
        raf2.close();
        raf.close();
    }


}

3、序列流SequenceInputStream和SequenceOutputStream

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

构造方法：

public SequenceInputStream(Enumeration<? extends InputStream> e)
参数是一个枚举类型
通过记住参数来初始化新创建的 SequenceInputStream，该参数必须是生成运行时类型为 InputStream 对象的 Enumeration 型参数。
将按顺序读取由该枚举生成的输入流，以提供从此 SequenceInputStream 读取的字节。在用尽枚举中的每个输入流之后，将通过调用该流的 close 方法将其关闭。 

文件的切割与合并：

package com.sxt.io;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.RandomAccessFile;
import java.io.SequenceInputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.Vector;

/**
 * 面向对象思想封装 分割
 * @author liuzeyu12a
 *
 */
public class SplitFile {
    //源头
    private File src;
    //目的地(文件夹)
    private String destDir;
    //所有分割后的文件存储路径
    private List<String> destPaths;
    //每块大小
    private int blockSize;
    //块数: 多少块
    private int size;
    
    public SplitFile(String srcPath,String destDir) {
        this(srcPath,destDir,1024);
    }
    public SplitFile(String srcPath,String destDir,int blockSize) {
        this.src =new File(srcPath);
        this.destDir =destDir;
        this.blockSize =blockSize;
        this.destPaths =new ArrayList<String>();
        
        //初始化
         init();
    }
    //初始化
    private void init() {
        //总长度
        long len = this.src.length();        
        //块数: 多少块
        this.size =(int) Math.ceil(len*1.0/blockSize);
        //路径
        for(int i=0;i<size;i++) {
            this.destPaths.add(this.destDir +"/"+i+"-"+this.src.getName());
        }
    }
    /**
     * 分割
     * 1、计算每一块的起始位置及大小
     * 2、分割
     * @throws IOException 
     */
    public void split() throws IOException {
        //总长度
        long len = src.length();        
        //起始位置和实际大小
        int beginPos = 0;
        int actualSize = (int)(blockSize>len?len:blockSize); 
        for(int i=0;i<size;i++) {
            beginPos = i*blockSize;
            if(i==size-1) { //最后一块
                actualSize = (int)len;
            }else {
                actualSize = blockSize;
                len -=actualSize; //剩余量
            }
            splitDetail(i,beginPos,actualSize);
        }
    }    
    /**
     * 指定第i块的起始位置 和实际长度
     * @param i
     * @param beginPos
     * @param actualSize
     * @throws IOException
     */
    private  void splitDetail(int i,int beginPos,int actualSize ) throws IOException {
        RandomAccessFile raf =new RandomAccessFile(this.src,"r");
        RandomAccessFile raf2 =new RandomAccessFile(this.destPaths.get(i),"rw");
        //随机读取 
        raf.seek(beginPos);
        //读取
        //3、操作 (分段读取)
        byte[] flush = new byte[1024]; //缓冲容器
        int len = -1; //接收长度
        while((len=raf.read(flush))!=-1) {            
            if(actualSize>len) { //获取本次读取的所有内容
                raf2.write(flush, 0, len);
                actualSize -=len;
            }else { 
                raf2.write(flush, 0, actualSize);
                break;
            }
        }            
        raf2.close();
        raf.close();
    }    
    /**
     * 文件的合并
     * @throws IOException 
     */
    public void merge(String destPath) throws IOException {
        //输出流
        OutputStream os =new BufferedOutputStream( new FileOutputStream(destPath,true));    
        Vector<InputStream> vi=new Vector<InputStream>();
        SequenceInputStream sis =null;
        //输入流
        for(int i=0;i<destPaths.size();i++) {
            vi.add(new BufferedInputStream(new FileInputStream(destPaths.get(i))));                                            
        }
        sis =new SequenceInputStream(vi.elements());
        //拷贝
        //3、操作 (分段读取)
        byte[] flush = new byte[1024]; //缓冲容器
        int len = -1; //接收长度
        while((len=sis.read(flush))!=-1) {
            os.write(flush,0,len); //分段写出
        }            
        os.flush();    
        sis.close();
        os.close();
    }
    public static void main(String[] args) throws IOException {
        SplitFile sf = new SplitFile("src/com/sxt/io/SplitFile.java","dest") ;
        sf.split();
        sf.merge("aaa.java");
    }
}

 *总结一下IO流使用的规律：

再扔个图比较好查看

（1）明确要操作的数据是数据源还是数据目的(要读还是要写)

　　　　　　源：InputStream　　Reader

　　　　　　目的：OutputStream　　Writer

（2）明确要操作的设备上的数据是字节还是文本

　　　　　　源：

　　　　　　　　字节：InputStream

　　　　　　　　文本：Reader

　　　　　　目的：

　　　　　　　　字节：OutputStream

　　　　　　　　文本：Writer

（3）明确数据所在的具体设备

　　　　　　源设备：

　　　　　　　　硬盘：文件 File开头

　　　　　　　　内存：数组，字符串 ByteArrayInputStream/ByteArrayOutputStream

　　　　　　　　键盘：System.in

　　　　　　　　网络：Socket

　　　　　　目的设备：

　　　　　　　　硬盘：文件 File开头

　　　　　　　　内存：数组，字符串  ByteArrayInputStream/ByteArrayOutputStream

　　　　　　　　屏幕：System.out

　　　　　　　　网络：Socket

（4）明确是否需要额外功能？

　　　　需要转换——转换流 InputStreamReader OutputStreamWriter

　　　　需要高效——缓冲流Bufferedxxx

　　　　多个源——序列流 SequenceInputStream

　　　　对象序列化——ObjectInputStream,ObjectOutputStream(数据的存储用的)

　　　　保证数据的输出形式——打印流PrintStream Printwriter

　　　　操作基本数据，保证字节原样性——DataOutputStream,DataInputStream

 参考附上大佬的博客：https://www.cnblogs.com/hopeyes/p/9736642.html(崇拜大佬可以把博客写的这么棒，总结的面面俱到)