Java IO：基于字节的IO操作

包括：

1. FileInputStream
2. ByteArrayInputStream
3. ObjectInputStream
4. BufferedInputStream
5. DataInputStream

上面 5 个为常用的基于字节操作的 IO 操作类，其中前三个 相当于 装饰器模式的 ConcreteComponent，后两个是具体的装饰者类。传送门：装饰器模式

一. FileInputStream

    用于读取文件内容。常用的有两种构造函数，例如：

public FileInputStream(String name) throws FileNotFoundException {
    this(name != null ? new File(name) : null);
}

public FileInputStream(File file) throws FileNotFoundException {
    ...
}

    其中 name 和 file 都是指向 需要读取的文件。Demo：

public class Test{
    public static void main(String[] args) {
        InputStream inputStream = null;
	try {
	    inputStream = new FileInputStream("/Users/yunxin/Desktop/a");
	    byte data[] = new byte[inputStream.available()];
	    inputStream.read(data);
	    System.out.println(new String(data));
			
	} catch (FileNotFoundException e) {
	    e.printStackTrace();
	} catch (IOException e) {
	    e.printStackTrace();
	} finally {
	    if(inputStream != null){
	        try {
		    inputStream.close();
		} catch (IOException e) {
		    e.printStackTrace();
		}
	    }
	} 
    }
}

    需要注意的是 try-catch-finally

二. ByteArrayInputStream

    ByteArrayInputStream，主要是应对流的来源和目的地不一定是文件这种情况，比如说可能是内存，可能是数组。例如：

public class Test{
    public static void main(String[] args) {
	byte data[] = "abc".getBytes();
	InputStream inputStream = new ByteArrayInputStream(data);
		
	byte data0[] = new byte[data.length]; 
	try {
	    inputStream.read(data0);
	    System.out.println(new String(data0));
	} catch (IOException e) {
	    e.printStackTrace();
	} finally {
	    if (inputStream != null) {
		try {
		    inputStream.close();
		} catch (IOException e) {
		    e.printStackTrace();
		}
	    }
	}
    }
}

三. ObjectInputStream
    ObjectInputStream 可以用于读取对象，但是读取的对象必须实现 Serializable 接口。

public class Test{
    public static void main(String[] args) {
	ObjectOutputStream objectOutputStream = null;
	try {
	    objectOutputStream = new ObjectOutputStream(new FileOutputStream("/Users/yunxin/Desktop/a"));
	    User user = new User();
	    user.setNum(2);
	    objectOutputStream.writeObject(user);
	} catch (FileNotFoundException e) {
	    e.printStackTrace();
	} catch (IOException e) {
	    e.printStackTrace();
	} finally {
	    if(objectOutputStream != null){
	        try {
		    objectOutputStream.close();
		} catch (IOException e) {
		    e.printStackTrace();
		}
	    }
	}
    }
}
class User implements Serializable{  
    private static final long serialVersionUID = -8987587467273881932L;  
    private int num;  
    public int getNum() {  
        return num;  
    }  
    public void setNum(int num) {  
        this.num = num;  
    }  
    @Override  
    public String toString() {  
        return "User [num=" + num + "]";  
    }     
}  

四. BufferedInputStream

    BufferedInputStream 提供了一个缓冲的功能，可以避免大量的磁盘IO。因为像FileInputStream 这种，每一次的读取，都是一次磁盘IO。

public class Test{
    public static void main(String[] args) {
	BufferedInputStream bufferedInputStream = null;
	try {
	    bufferedInputStream = new BufferedInputStream(new FileInputStream("/Users/yunxin/Desktop/a"));
	    byte data[] = new byte[bufferedInputStream.available()];
	    bufferedInputStream.read(data);
	    System.out.println(new String(data));
			
	} catch (FileNotFoundException e) {
	    e.printStackTrace();
	} catch (IOException e) {
	    e.printStackTrace();
	} finally {
	    if(bufferedInputStream != null){
	        try {
		    bufferedInputStream.close();
		} catch (IOException e) {
		    e.printStackTrace();
		}
	    }
	} 
    }
}

五. DataInputStream

    该类的主要作用是可以返回一些基本类型或者是String类型，否则的话，只能返回byte类型的数据，利用该类，我们可以更好的操作数据。

public class Test{
    public static void main(String[] args) {
        DataOutputStream dataOutputStream = null;
	try {
	    dataOutputStream = new DataOutputStream(new FileOutputStream("/Users/yunxin/Desktop/a"));
	    dataOutputStream.writeInt(999);
	} catch (FileNotFoundException e) {
	    e.printStackTrace();
	} catch (IOException e) {
	    e.printStackTrace();
	} finally {
	    if(dataOutputStream != null){
	        try {
		    dataOutputStream.close();
		} catch (IOException e) {
		    e.printStackTrace();
		}
	    }
	} 
    }
}