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();
         }

     }
 }