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
        //目的地   dest
        File 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);
        //选择流 DataOutputStream
        DataOutputStream 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);
        //选择源DataOutputStream
        ObjectOutputStream 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到文件中,而不需要手动flush
        System.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