Java IO之DataInputStream,ObjectInputStream,ByteArrayInputStream等

一、节点流

1、字节数组 字节 节点流

输入流 ByteArrayInputStream read(byte[] b, int off, int len)+close()
输出流 ByteArrayOutputStream write(byte[] b, int off, int len)+ toByteArray() 这是个新增方法，不要使用多态

package IOOthers;import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;/*** 字节数组流 节点流* 数组的长度有限，数据量不会很大* * 节点 数据源（文件，字节数组<可以理解为服务器内存>）* 文件内容不用太大* 1、文件-文件输入流-程序-字节数组输出流->字节数组* 2、字节数组-字节数组输入流-程序-文件输出流->文件*/
public class Demo01 {
    public static void main(String[] args) {try {//程序-字节数组输出流->字节数组-字节数组输入流-程序read(write());} catch (IOException e) {e.printStackTrace();}}/*** 输入流的操作与文件输入流操作一致* 读取字节数组* @throws IOException */public static void read(byte[] src) throws IOException{/*//数据源String msg = "操作与文件输入流操作一致";byte[] src = msg.getBytes();*///选择流 InputStream is = new BufferedInputStream(new ByteArrayInputStream(src));      //操作byte[] flush = new byte[1024];int len = 0;while(-1!=(len = is.read(flush))){System.out.print(new String(flush,0,len));}//释放资源is.close();}   //输出流与操作文件输出流 有些不同，有新增方法，不能使用多态public static byte[] write() throws IOException{//目的地byte[] dest;//选择流 不同点 新增方法不能使用多态ByteArrayOutputStream bos = new ByteArrayOutputStream();//操作写出String msg = "操作与文件输入流操作一致";byte[] info = msg.getBytes();bos.write(info,0,info.length);//获取数据 数据量不会很大dest = bos.toByteArray();//释放资源bos.close();return dest;}   
}

运行结果：

操作与文件输入流操作一致

package IOOthers;import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;/*** 1、文件----------程序------------->字节数组* 文件输入流 字节数组输出流* * 2、字节数组--------------程序----------->文件* 字节数组输入流 文件输出流*/
public class Demo02 {
    public static void main(String[] args) throws IOException {byte[] data = getBytesFromFile("g:/writer.txt");System.out.println(new String(data));toFileFromByteArray(data,"g:/ouba.txt");        }//文件---程序-->字节数组public static  byte[] getBytesFromFile(String srcPath) throws IOException{//创建文件源File src = new File(srcPath);//创建字节数组目的地byte[] dest = null;//选择流//文件输入流InputStream is = new BufferedInputStream(new FileInputStream(src)); //字节数组输出流不能使用多态ByteArrayOutputStream bos = new ByteArrayOutputStream();//操作 不断读取文件，写出到字节数组流中byte[] flush = new byte[1024];int len = 0;while(-1!=(len=is.read(flush))){//写出到字节数组流中bos.write(flush,0,len);}bos.flush();//获取数据dest = bos.toByteArray();       bos.close();is.close();return dest;    }/*** 2、字节数组--程序-->文件* @throws IOException */public static  void  toFileFromByteArray(byte[] src,String destPath) throws IOException{//1、创建源 src//目的地 destFile dest  = new File(destPath);        //2、选择流//字节数组输入流InputStream is = new BufferedInputStream(new ByteArrayInputStream(src));//文件输出流OutputStream os = new BufferedOutputStream(new FileOutputStream(dest));//3、操作 不断读取字节数组byte[] flush = new byte[1024];int len = 0;while(-1!=(len=is.read(flush))){//写出到文件中os.write(flush,0,len);}os.flush(); //4、释放资源/*os.close();is.close();*/FileUtil.close(os,is);}
}

运行结果：

每个人都有青春，
每个青春都有一个故事，
每个故事都有一个遗憾，
每个遗憾却都存在着他的美好。ouye

二、处理流

1、基本数据类型+String ， 保留数据+基本类型

输入流：DataInputStream readXxx()
输出流：DataOutputStream writeXxx()

package IOOthers;import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;/*** 输出到文件中或者从文件中读取* * 数据类型(基本数据类型+字符串)处理流* 1、输入流DataInputStream readXxx()* 2、输出流DataOutputStream writeXxx()* 新增方法不能使用多态* java.io.EOFException:没有读取到相关的内容*/@SuppressWarnings("all")
public class Demo03 {
    public static void main(String[] args) {try {write("g:/try/321.txt");read("g:/try/321.txt");} catch (IOException e) {e.printStackTrace();} }/*** 基本数据类型+字符串 输出到文件* @param destPath* @throws IOException*/public static void write(String destPath) throws IOException{double point = 2.5;long num = 100L;String str  = "数据类型";//创建源File dest = new File(destPath);//选择流 DataOutputStreamDataOutputStream dos = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(dest)));//操作 写出的顺序-->为读取做准备dos.writeDouble(point);dos.writeLong(num);dos.writeUTF(str);dos.flush();//释放资源dos.close();}/*** 从文本中读取 （字符串+基本数据类型）* @throws IOException */public static void read(String destPath) throws IOException {//创建源File src = new File(destPath);//输入流DataInputStream dis = new DataInputStream(new BufferedInputStream(new FileInputStream(src)));  //操作 读取的顺序与写出一致，必须先存在才能读取//顺序与写的时候不一致，可能存在顺序问题double point = dis.readDouble();long num = dis.readLong();String str = dis.readUTF();dis.close();System.out.println(point+"--"+num+"--"+str);}
}

运行结果：

2.5--100--数据类型

package IOOthers;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;
/*** 输出到字节数组中或者从字节数组中读取* * @author liguodong*/@SuppressWarnings("all")
public class Demo04 {
    public static void main(String[] args) {try {byte[] data = write();read(data);System.out.println(data.length);        } catch (IOException e) {e.printStackTrace();}}/*** 数据+类型 输出到 字节数组中* @return* @throws IOException*/public static byte[] write() throws IOException{//目标数组byte[] dest = null;double point = 2.5;long num = 100L;String str  = "数据类型";//选择流DataOutputStream 存在多态行为ByteArrayOutputStream bos = new ByteArrayOutputStream();DataOutputStream dos = new DataOutputStream(new BufferedOutputStream(bos));//操作 写出的顺序dos.writeDouble(point);dos.writeLong(num);dos.writeUTF(str);dos.flush();//获取数据dest =bos.toByteArray();//释放资源dos.close();        return dest;}/*** 从字节数组中读取数据+类型*/public static void read(byte[] src) throws IOException {   //输入流 没有所谓的多态行为DataInputStream dis = new DataInputStream(new BufferedInputStream(new ByteArrayInputStream(src)));//操作 读取的顺序与写出一致，必须先存在才能读取//顺序与写的时候不一致，可能存在顺序问题double point = dis.readDouble();long num = dis.readLong();String str = dis.readUTF();dis.close();System.out.println(point+"--"+num+"--"+str);}
}

运行结果：

2.5--100--数据类型
30

2、引用类型（对象），保留对象类型+数据

反序列化 — 输入流ObjectInputStream
序列化—输出流：ObjectOutputStream
注意：
先序列化，后反序列化，反序列化顺序必须与序列化顺序一致。
不是所有的对象都可以序列化，必须实现java.io.Serializable接口。
不是所有的属性都需要序列化，不需要使用序列化的属性使用transient。

package IOOthers;/*** 空接口只是一个标识,标识可以序列化。*/
@SuppressWarnings("all")
public class Employee implements java.io.Serializable{
    //不需要序列化private transient String name;private double salary;public Employee(){}public Employee(String name, double salary) {super();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 IOOthers;import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
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.Arrays;/*** 不是所有的`对象`都可以序列化，必须实现java.io.Serializable接口。* 不是所有的`属性`都需要序列化，不需要使用序列化的属性使用transient。* @author liguodong*/public class Demo05 {
    public static void main(String[] args) throws ClassNotFoundException {try {seri("g:/try/ser.txt");readseri("g:/try/ser.txt");} catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();}}//序列化public static void seri(String destPath) throws FileNotFoundException, IOException{Employee emp = new Employee("Mark",1000000);int[] arr = {
   1,2,4,32};// 数组对象，它的内部就可以进行序列化。//创建源File dest = new File(destPath);//选择源DataOutputStreamObjectOutputStream dos = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream(dest)));  //操作写出的顺序 为读写准备 dos.writeObject(emp);dos.writeObject(arr);//释放资源dos.close();}   //反序列化public static void readseri(String destPath) throws FileNotFoundException, IOException, ClassNotFoundException{//1、创建院File src = new File(destPath);      //2、选择流ObjectInputStream dis = new ObjectInputStream(new BufferedInputStream(new FileInputStream(src)));//3、读取Object obj = dis.readObject();if(obj instanceof Employee){Employee emp= (Employee)obj;System.out.println(emp.getName()+"-->"+emp.getSalary());}obj = dis.readObject();     int[] arr = (int [])obj;System.out.println(Arrays.toString(arr));//4、释放资源dis.close();}
}

运行结果：

null-->1000000.0
[1, 2, 4, 32]

3、关闭流两种方式

package IOOthers;import java.io.Closeable;
import java.io.IOException;@SuppressWarnings("all")
public class FileUtil {
    //工具类关闭流//多态方式//可变参数：... <只能放在形参最后一个位置> 处理方式与数组一致 public static void close(Closeable ... io){for(Closeable temp:io){try {if(null!=temp){temp.close();}} catch (IOException e) {e.printStackTrace();}}}/*** 泛型方法 和上一种一样的效果 */ public static <T extends Closeable> void cloaseAll(T ... io){for(Closeable temp:io){try {if(null!=temp){temp.close();}} catch (IOException e) {e.printStackTrace();}}}   
}

4、打印流

package IOOthers;import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;
/*** PrintStream 打印流 -->处理流*/public class Demo06 {
    public static void main(String[] args) throws FileNotFoundException {System.out.println("test");PrintStream ps = System.out;ps.println(false);//输出到文件File src = new File("g:/try/test.txt");//false覆盖 true追加ps = new PrintStream(new BufferedOutputStream(new FileOutputStream(src,true)));      ps.println("io is so easy2fdsf13");ps.close();      }
}

运行结果：

test
false

package IOOthers;import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileDescriptor;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.PrintStream;
import java.util.Scanner;/***三个常量*1、System.in 输入流 键盘输入*2、System.out 输出流 标准输出*3、System.err * ==>重定向* setIn()* setOut()* setErr()* static FileDescriptor in 输入* static FileDescriptor out 输出*/
@SuppressWarnings("all")
public class Demo07 {
    public static void main(String[] args) throws FileNotFoundException {test1();System.out.println("=====@@@=====");test2();System.out.println("=====@@@=====");        test3();}public static void test1(){System.out.println("test");System.err.println("err");}//不再使用控制台输入，而是从文件中获取public static void test2() throws FileNotFoundException{InputStream is = System.in;//键盘输入is = new BufferedInputStream(new FileInputStream("g:/try/test.txt"));Scanner sc = new Scanner(is);System.out.println("从文件中读取：");//System.out.println(sc.nextLine());//注意这只是读取了一行while(sc.hasNextLine()){System.out.println(sc.nextLine());}}public static void test3() throws FileNotFoundException{//重定向 到文件中 //PrintStream(OutputStream out, boolean autoFlush) //创建新的打印流，后面一个形参,true表示自动flush到文件中,而不需要手动flushSystem.setOut(new PrintStream(new BufferedOutputStream(new FileOutputStream("g:/try/print.txt")),true));System.out.println("file--a");//控制台到文件System.out.println("file--test");//重定向回控制台 要加true 将流flush出去 FileDescriptor不能直接使用System.setOut(new PrintStream(new BufferedOutputStream(new FileOutputStream(FileDescriptor.out)),true));System.out.println("console--test");}
}

运行结果：

err
test
=====@@@=====
从文件中读取：
io is so easy2fdsf13
io is so easy2fdsf13
io is so easy2fdsf13
=====@@@=====
console--test

package IOOthers;import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
/*** 封装输入 类似于Scanner的操作*/
public class Demo08 {
    public static void main(String[] args) throws IOException {InputStream is = System.in;//字节流//InputStreamReader 是字节流通向字符流的桥梁 转换流//字符流--转换流--字节流 使用了新增方法不能使用多态BufferedReader br = new BufferedReader(new InputStreamReader(is));System.out.println("请输入：");String msg = br.readLine();//处理一行System.out.println(msg);}
}

运行结果：

请输入：
123-->这是自己输入的
123-->这是打印到控制台的

**注：**Java IO流的设计采用的就是装饰设计模式。
装饰设计模式相关案例：
http://blog.csdn.net/scgaliguodong123_/article/details/44044135