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

原文链接：https://blog.csdn.net/scgaliguodong123_/article/details/45938555

本站声明:网站内容来源于网络,如有侵权,请联系我们,我们将及时处理。

本博客所有文章如无特别注明均为原创。
复制或转载请以超链接形式注明转自起风了，原文地址《Java IO之DataInputStream,ObjectInputStream,ByteArrayInputStream等》

一、节点流

1、字节数组 字节 节点流

二、处理流

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

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

3、关闭流两种方式

4、打印流

1、字节数组字节节点流

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