IO流（二）I/O

一.IO流概述

     1.定义：Java的IO流是实现输入输出的基础，它可以方便地实现数据的输入/输出操作。

     2.流的分类:

               (1)按流向来分：输入流和输出流

               (2)按操作的数据来分：字节流和字符流

               (3)按流的角色来分:节点流和处理流

二.IO流类图

   常用流分类：

   通常来说，字节流的功能比字符流强大，因为计算机里所有的数据都是二进制的，而字节流可以处理所有的二进制文件，但如果使用字节流来处理文本文件，则需要将字节转换为字符，这增加了编程复杂度。所以有这样一个规则：如果操作的内容是文本，则考虑使用字符流，如果操作的内容是二进制内容，则应考虑使用字节流。

三.常用流介绍

     1.转换流：输入/输出流体系中还提供了两个转换流，这两个转换流用于实现将字节流转换成字符流。

                    InputStreamReader将字节输入流转换成字符输入流，OutputStreamWriter将字节输出流转换成字符输出流。

public class InputStreamReaderDemo {
    public static void main(String[] args) {
        // 将标准字节输入流转换为字符流
        InputStreamReader reader = new InputStreamReader(System.in);
        // 将字符流进一步包装成缓冲流
        BufferedReader buffer = new BufferedReader(reader);
        String line = null;
        try {
            // System.out.println("请输入:");
            while ((line = buffer.readLine()) != null) {

                if ("exit".equals(line)) {
                    System.exit(1);// 读取到exit，程序退出
                }
                System.out.println("输出内容:" + line);
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

   2.缓冲流

      BufferedInputStream,BufferedOutputStream,BufferedReader,BufferedeWriter

       使用缓冲流的好处:能够高效的读写信息，原理是先将数据缓存起来，然后再一起写入或者读取出来。

   3.打印流

      PrintStream,PrintWriter

　　使用打印流的好处：可以很方便的进行输出

      

public class PrintDemo {
    
    public static void main(String[] args) {
        printToFile();
        System.out.println("success");
    }
    
    public static void printToFile(){
        try {
            OutputStream output = new FileOutputStream("D:\\code\\999.txt");
            PrintWriter pw  = new PrintWriter(new BufferedOutputStream(output));
            pw.println("我是一只小小小鸟");
            pw.println(true);
            pw.println(999);
            pw.println(1.114);
            pw.flush();
            pw.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        
    }
}

 4.对象流：序列化和反序列化对象

　　（1）什么是对象序列化

　　　　对象序列化的目标是将对象保存到磁盘中，或在网络中传输对象。

　　　　对象序列化机制允许把内存中的对象转换成平台无关的二进制流，从而允许把这种二进制流持久地保存在磁盘上，或通过网络将这种二进制流传输到另一个网络节点，其他程序一旦获得这个二进制流，就可以将这种二进制流恢复成原来的java对象。

　　（2）如何让类是可序列化的

　　　　实现Serializable接口，该接口是一个标记接口，接口内无任何需要实现的方法。

　　（3）对象的序列化和反序列化

　　　　对象序列化(Serialize)是指将一个java对象写入IO流中，对象的反序列化(Deserialize)是指从IO流中恢复该java对象

　　（4）怎么使用对象流实现序列化

　　　　两个类:ObjectOutputStream,ObjectInputStream 对象流是处理流，需要建立在节点流的基础之上。

　　　　两个方法:writeObject(), readObject()

　　　　如果不想序列化某个成员变量，可以在声明中加入关键字 transient, 例如private transient int age;

　　　　使用方法见下面代码：（Dog类省略）

　　　　

package com.gdp.xuliehua;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;

public class TestDog {
    public static void main(String[] args) {
        //writeObject();
        //readObject();
        //writeObject2();
        readObject2();
    }
    /**
     * 将对象写入到文件中
     */
    public static void writeObject(){
        try {
            OutputStream out = new FileOutputStream("D:\\dog.txt");
            ObjectOutputStream oos = new ObjectOutputStream(out);
            oos.writeInt(130);
            Dog dog = new Dog("小黑",3);
            oos.writeObject(dog);
            oos.flush();
            oos.close();
            out.close();
            System.out.println("OK");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        
    }
    /**
     * 从文件中读取对象
     */
    public static void readObject(){
        try {
            InputStream in = new FileInputStream("D:\\dog.txt");
            ObjectInputStream ois = new ObjectInputStream(in);
            int i = ois.readInt();
            Dog dog = (Dog)ois.readObject();
            ois.close();
            in.close();
            System.out.println(i);
            System.out.println(dog);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        
    }
    /**
     * 序列化多个对象，采用对象数组来实现将对象写入文件中
     */
    public static void writeObject2(){
        Dog dog1 = new Dog("小黑",5);
        Dog dog2 = new Dog("小白",3);
        Dog dog3 = new Dog("小红",6);
        try {
            OutputStream out = new FileOutputStream("D:\\obj.tmp");
            ObjectOutputStream oos = new ObjectOutputStream(out);
            Dog[] dogs = new Dog[]{dog1,dog2,dog3};
            oos.writeObject(dogs);
            oos.flush();oos.close();out.close();
            System.out.println("ok");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        
        
    }
    /**
     * 将多个对象从文件中读取出来
     * 1.读取出来的对象是对象数组
     * 2.遍历数组，取出对象
     */
    public static void readObject2(){
        try {
            InputStream in= new FileInputStream("D:\\obj.tmp");
            ObjectInputStream ois = new ObjectInputStream(in);
            Dog[] dogs = (Dog[])ois.readObject();
            ois.close();in.close();
            for (Dog dog : dogs) {
                System.out.println(dog);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        
    }
}

 5.ByteArrayInputStream和ByteArrayOutputStream

　　（1）ByteArrayInputStream包含一个内部缓冲区，该缓冲区包含从流中读取的字节。

　　　　关闭ByteArrayInputStream无效，此类的方法在关闭流后仍可被调用，而不会产生任何IOException。

　　（2）ByteArrayOutputStream,此类实现一个输出流，其中的数据被写入一个byte数组，缓冲区会随着数据的不断写入而自动增长，可以使用toByteArray()和toString()获取数据.

     　　关闭ByteArrayOutputStream无效，此类的方法在关闭流后仍可被调用，而不会产生任何IOException。

　　(3)使用方法如下列代码:

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;

public class ByteArrayDemo {
    public static void main(String[] args) {
        write();
    }
    /**
     * 写入数据，不与文件关联，写入内存
     * 读取数据并显示
     */
    public static void write(){
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        String info = "我是一只小小小小鸟!";
        try {
            bos.write(info.getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }
        //读取数据
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        StringBuffer buf = new StringBuffer();
        byte[] bytes = new byte[1024];
        int temp ;
        try {
            while((temp=bis.read(bytes))!=-1){
                buf.append(new String(bytes, 0, temp));
            }
            System.out.println(buf.toString());
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
    }
}

 6.过滤器数据流:DataInputStream和DataOutputStream

　　(1)DataInputStream和DataOutputStream专门用于读写基本数据类型数据，而对象流既可以读写基本数据类型的数据也可以读写对象。

　　(2)它是一个处理流，需要建立在节点流的基础之上,如new DataInputStream(new FileInputStream("text.txt"))

　　(3)DataInputStream和DataOutputStream有读写的相关方法一一对应，基本使用方法见下面代码：

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class DataStreamDemo {
    public static void main(String[] args) {
        // write();
        read();
    }

    /**
     * 向文件写入数据
     */
    public static void write() {
        try {
            OutputStream out = new FileOutputStream("D:\\test.txt");
            DataOutputStream dos = new DataOutputStream(out);
            dos.writeInt(100);// 写入int数值
            dos.writeDouble(99.99);// 写入double数值
            dos.writeBoolean(true);// 写入boolean值
            dos.writeUTF("我是一只小小小小鸟");
            dos.flush();
            dos.close();
            out.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    /**
     * 从文件读取数据
     */
    public static void read() {
        try {
            InputStream in = new FileInputStream("D:\\test.txt");
            DataInputStream dis = new DataInputStream(in);
            System.out.println(dis.readInt());
            System.out.println(dis.readDouble());
            System.out.println(dis.readBoolean());
            System.out.println(dis.readUTF());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}