io思维导向图

IO里边的东西确实特别多，所以再另开一篇，把IO里面剩下的东西记录一下，这篇里面主要的内容有打印流、对象的序列化和反序列化，随机读取流等等，还是相当实用的。

一、打印流

打印流在IO第一篇文章里面是有接触过的，当时用的转换流打印从键盘接受到的数据的时候用到了System.out这么个流对象，其实它返回的就是打印流对象PrintStream，当时实用接口直接调用了，也就是多态，并没有关注其到底是哪个子类。说道这里，也就清楚了，最常用的System.out.println()中println()方法就是打印流里面的方法。

打印流分两种：

1. 字节输出流：PrintStream
2. 字符输出流：PrintWriter，注意PrintWriter实现了PrintStream中所有的打印方法

两者的区别：

• 共性：都是负责打印数据，不会抛出异常，不操作数据源，有很多种打印方法。
• 区别：还是之前的说话，一个是字节流，一个是字符流，所以两个流的构造方法不一样，字符流（PrintWriter）流构造方法接收File对象、字节输出流、字符串形式的文件名、字符输出流四种类型的参数；而字节流（PrintStream）接收File文件对象，字符形式的文件名和字节输出流这三种类型的参数。

作用：

打印流到底有啥作用？其实说白了就是将数据打印到指定的目标上，目标可以是文件，控制台，别的电脑等等，所以打印流和之前的比如说FileWriter这些输出流的功能是有重叠的，更甚至于打印流还可以干转换流的活，代码如下：

PrintWriter pw = new PrintWriter(System.out,true); //true为开启自动刷新

所以以后要是需要输出数据，优先选择打印流其实是比较方便和实用的。实际开发中，web开发，服务器其实都用的是打印流，将数据打印到客户浏览器端。

打印流还可以开启自动刷新，具体做法就是在构造方法上加上true开启即可。

注意：这里是有限制的。要开启自动刷新，必输是流对象，且在调用println、printf、format这三个方法时才会启用。

demo：

package io;
/*
 * 打印流demo
 */
import java.io.*;

public class PrintWriterDemo {
    public static void main(String[] args) throws Exception{
        method();
    }
    
    /*
     * 使用打印流，将数据打印到各个目的地
     */
    public static void method() throws Exception{
        
        //常规打印方式，和以前的字符输出流区别不大
        PrintWriter pw = new PrintWriter("e:\\PrintDemo.txt");
        pw.print("this is a test!");
        pw.flush();
        pw.close();
        
        
        //将字符打印到字符输出流中
        PrintWriter pw1 = new PrintWriter(new FileWriter("e:\\PrintDemo1.txt"),true); //开启自动刷新
        pw1.println("this is a test!");//换行打印效果，相当于缓冲流的write+newLine
        pw1.print("this is a test!");
        pw1.close();
        
        //实现转换流的效果,只有字节流才有转换
        //开启自动刷新,重新编码
        PrintStream pw2 = new PrintStream(new FileOutputStream("e:\\PrintDemo2.txt"),true,"UTF-8");
        pw2.print("测试");//换行打印效果，相当于缓冲流的write+newLine
        pw2.flush();
        pw2.close();
        
        //从控制台到文件
        BufferedReader bfr = new BufferedReader(new InputStreamReader(System.in));//控制台接收的缓冲流
        PrintWriter pw3 = new PrintWriter(new FileOutputStream("e:\\PrintDemo3.txt"),true);
        String s = null ;
        while((s = bfr.readLine()) != null){
            if(s.endsWith("over"))
                break;
            pw3.println(s);
        }
        pw3.close();
    }
}

二、对象序列化

将对象的数据写到文件中就是对象序列化，相反把文件中的数据读取并转换为对象就是反序列化。涉及到的两个流是：

• ObjectOutputStream，这个是写对象的流
• ObjectInputStream，这个是读对象的流

1. 序列化

写对象数据的流 是ObjectOutputStream类，构造方法和写的方法：

ObjectOutputStream(OutputStream out);//一般传递子类对象 FileOutputStream
//写入方法支持基本数据类型和对象
writeObject(Object o); //写入对象
writeInt(int i);//写入基本类型，都是write+基本类型名，这个基本没用我觉得

通过将对象和数据写入文件中 ，可是实现对数据的永久性保存。通过读取和重构就可以恢复数据，但是读取数据时类型和顺序应该和写入的顺序相同。

注意：序列化的类必须继承Serializable接口，此接口中没有方法，作用就是做一个序列化的标记。

2. 反序列化

其实io学到这里，基本的规律基本上已经出来了，有输出就对应着有输入，有写就有读，方法都是对应起来的。

ObjectInputStream(new FileInputStream("e:\\ObjectStream.txt"));//构造方法的一个例子
Object readObject();// 读的方法

读这里需要注意一点，返回的是Object对象，也就是说类型被提升，多态调用时没有什么问题，但是需要调用子类特有方法时，需要做类型转化，加之如果文件里写了很多种不同的类对象，在顺序没有保证的情况下，最后在做类型转换之前进行判断。

序列化和反序列化的demo：

package io;
/*
 * 对象序列化demo
 */
import java.io.*;
import SetDemo.Person;//person类的代码在set那篇文章里有写

public class ObjectStreamDemo {
    public static void main(String[] args) throws Exception{
        method();
        method_1();
    }
    
    /*
     * 序列化
     */
    public static void method() throws Exception{
        //其实输出的是二进制文件
      //Person类已实现Serializable接口，否则会报异常
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("e:\\ObjectStream.txt"));
        
        Person p1 = new Person("杨比轩", 20);//新建两个对象用于序列化
        Person p2 = new Person("比轩", 21);
        
        oos.writeObject(p1);
        oos.writeObject(p2);
        
        oos.flush();
        oos.close();
    }
    
    /*
     * 反序列化
     */
    public static void method_1() throws Exception{
        //读比较简单，保证对象class文件可以加载，并且按顺序走就可以了
        //如果没有person类， 会报出 找不到此类  的异常
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("e:\\ObjectStream.txt"));
        
        System.out.println(ois.readObject());
        System.out.println(ois.readObject());
        
        ois.close();
    }
}

3. 阻止变量的序列化

有两种方法:

• 一种是将对象内的成员变量变为静态的，此时默认不会将其序列化，反之读取的时候就获取不到此数据。
• 另一种是加关键字transient即可，这个关键字也就这一个作用：阻止变量序列化。

4.Serializable接口的意义

上面说了，没有实现Serializable接口的对象时没有办法序列化的，但是Serializable接口中有没有方法，那这个到底是干嘛用的呢？

存在意义，称为标记型接口，就是在你的类上标记一下，JVM看到这个标记，可以进行序列化。就像现实生活中给文件盖个章一样，有戳JVM就认，没戳就不认，这么个道理。

5. 序列化ID

首先先解释一下，什么是序列号。其实java文件在编译生成class文件的时候，会计算出一个序列号保存在二进制文件当中。所以我们当我们反序列化时，如果此时被序列化的对象的class文件在被序列化后改动过，其序列号就会发生变化，一做反序列化，就会报出序列号不一致的异常（InvalidClassException)。

那如果实现就算了改了对象的源码，也重新编译了class文件，此时反序列化也不会报错呢，这就需要显式的申明一个序列号的long型变量：

static final long serialVersionUID = XXXX L;//变量的修饰符和变量名都是java固定的，只能修改具体的数值。

三、关于接口和Object

接口是不继承任何类的，但是下面这个代码却可以编译通过：

interface A{    
}

class B implements A{
}

public class demo{
  public static void main(String[] args){
    A temp = new B();
    A.hashCode();
  }
}

我们都知道，编译看左边，所以编译的时候其实和子类B是没有什么关系的，此时接口A既没有继承Object类，也没有任何方法，但是却可以调用Object类下的任一方法，这个是不是有点想不通。

原因呢Sun公司其实有说过：就是在借楼中，隐含定义了Object中的所有方法，这些方法都是抽象的。

四、Properties和IO的结合使用

Properties和IO的结合使用可以用来加载配置文件等等，使用起来还是比较方便的。而且，之前也说话，Properties是一个线程安全的类，存储键值对的集合，不能存储null和重复对象，特有方法为setProperty和getProperty。

load方法的形式为public synchronized void(Reader/InputStream)，传递字节流对象或者字符流对象，没有返回值。只需要将io对象传递进去即可，全自动，比较方便。

同时，如果需要将内存中的Properties对象中的数据写回文件，可以使用public void store(Writer writer, String comments)方法， comments为注释。

demo：

package map;
/*
 * IO和Properties的配合使用
 */
import java.io.*;
import java.util.*;
public class PropertiesDemo1 {
    public static void main(String[] args) throws Exception {
      method();
    }
    
    /*
     * 从文本中读取键值对存储到Properties中
     * 修改使用setProperty
     * 
     * 保存使用store
     * 注意先load后再新建文件输出流，否则会清空掉文件内的数据
     * 注释不能写中文，因为写进去的是utf的十六进制编码，不是文本
     * 
     * list方法，传递打印流，将键值对打印到配置文件中
     */
    public static void method() throws Exception{
        Properties p = new Properties();
        
        FileReader fr = new FileReader("f:\\config.ini");
        
        p.load(fr);
        
        //p.setProperty("id", "789");
        
        FileWriter fw = new FileWriter("f:\\config.ini");
        p.store(fw,null);
        fr.close();
        fw.close();
        System.out.println(p);
        
        p.setProperty("address", "home");
        p.setProperty("address1", "school");
        p.setProperty("address2", "company");
        p.setProperty("id", "123");
        
        p.list(new PrintStream(new File("f:\\config.ini")));
        
    }
    
    //测试结论：使用完load方法后，Reader指向了文件末尾，但是没有被关闭
    public static void test() throws Exception{
        
        Properties p = new Properties();
        
        FileReader fr = new FileReader("f:\\config.ini");
        
        p.load(fr);
        
        char[] ch = new char[100];
        
        fr.read(ch);
        System.out.println(ch);
    }
}

附上一个练习，自己实现load方法：

package map;
/*
 * 自己实现load方法
 * 方法申明和原方法基本一致
 * 有两个重载形式字节流和字符流
 * 因为是自定义方法，所以没有this对象，直接把Properties当做参数传递机那里
 */

import java.io.*;
import java.util.*;

public class LoadDemo {
    public static void main(String[] args) throws IOException {

        Properties p = new Properties();
        FileReader fr = new FileReader("f:\\config.ini");
        
        load(fr, p);
        System.out.println(p);
    }

    /*
     * 字符流load
     * 目标，读取配置文件里的数据，转换为Properties的元素
     * 按行读取，获取行数据，然后按等号切割，返回String[]，前K后V
     * 
     * 疑问：
     * 按照io的规范，其实BufferedReader在这里是要close掉的
     * 但是此处要是关闭了BufferedReader，传递进来的Reader也会被关掉
     * 也就是说，用户传递进来的参数一进被关闭掉了，这回使的用户后续使用出现问题
     * 但是，思考了下，也不知道怎么解决这个问题，希望有大神可以回答
     * java的load是没有关闭传递进去的对象的，但是看不大懂内部的具体实现
     */
    public static void load(Reader reader, Properties p) throws IOException {

        String str = null;
        BufferedReader br = new BufferedReader(reader); //使用Buffered可以使用readLine
        while ((str = br.readLine()) != null) {
            //先去掉空格
            str = str.trim();
            // 忽略掉注释的内容...
            if (!(str.startsWith("#") || str.startsWith("-"))) {
                
                String[] kv = str.split("=");

                // 去掉不符合规定的内容
                if (kv.length == 2) {
                    p.setProperty(kv[0], kv[1]);
                }
            }
        }
    }
    
    //重载字节流的形式
    public static void load(InputStream is, Properties p) throws IOException{
        
        //使用转换流，将字节流数据处理为字符流，之后和字符流处理方式相同
        InputStreamReader br = new InputStreamReader(new FileInputStream("F:\\config.ini"));
        load(br,p);//其余都是一样的，调参数为reader类型的方法
    }
}

这个练习也引出了一个疑问，在代码中有提到：

按照io的规范，其实BufferedReader在这里是要close掉的。但是此处要是关闭了BufferedReader，传递进来的Reader也会被关掉。也就是说，用户传递进来的参数已经被关闭掉了，这会使得用户后续使用出现问题。思考了下，也不知道怎么解决这个问题，希望有大神可以回答。试了一下，java的load是没有关闭传递进去的对象的，但是看不大懂内部的具体实现

五、IO读写基本类型数据

可以使用IO流DataOutputStream，DataInputStream来读写基本数据。

• DataOutputStream继承OutputStream，字节输出流。构造方法和输出方法为：

DataOutputStream(OutputStream o);//实际操作都传递FileOutputStream
writeInt(int) //方法名为：write + 基本数据类型名称

• DataInputStream继承InputStream，字节输入流。构造方法和读取方法为：

DataInputStream(InputStream i);//实际操作都传递FileInputStream
int readInt();//方法名为：read + 基本数据类型名

DataInputStream读到末尾时会抛出EOFException（end of file exception)，所以需要循环读取时一般都利用异常赖退出循环。

直接提供demo：

package io;
/*
 * 基本数据类型的读写demo
 * DataOutputStream 基本数据类型的输出
 * 只有一种构造方法
 * DataOutputStream(OutputStream out) 
 * 
 * DataInputStream 基本数据类型的读取，其余一样    
 * 
 */
import java.io.*;
public class DataStreamDemo {
    public static void main(String[] args) throws Exception{
        
//      method();
//      method2();
        wirteAndReadUTF();
    }
    
    /*
     * 基本数据类型的输出
     * 写入的是实际的数据内容，而且是连续性的写入
     * 并不会记录写的数据类型及其数量信息
     * 所以，读取的时候，不知道写的具体类型是什么，
     * 读到文件末尾了，就报出EOF异常
     */
    public static void method() throws Exception{
        DataOutputStream dos =  new DataOutputStream(new FileOutputStream("F:\\data.txt"));
        
        dos.writeInt(654);
        dos.writeByte(45);
        dos.writeByte(45);
        dos.writeByte(45);
        dos.writeByte(45);
        dos.writeDouble(68516951.684162);
        dos.close();
    }
    
    /*
     * 基本数据类型的读取
     * while永真循环读取，抓住异常时break
     * 
     */
    public static void method2() throws Exception{
        DataInputStream dis =  new DataInputStream(new FileInputStream("F:\\data.txt"));
        double a = 0;
        while(true){
            try{
                a = dis.readDouble();
                System.out.println(a);
            }catch(EOFException e){
                break;
            }
        }
        dis.close();
    }
    
    /*
     * 使用writeUTF的形式进行写入和读取
     */
    public static void wirteAndReadUTF() throws Exception{
        
        DataOutputStream dos = new DataOutputStream(new FileOutputStream("F:\\utf.txt"));
        dos.writeUTF("写什么都行0\r\n");
        
        dos.writeUTF("写什么都行1");
        dos.writeUTF("写什么都行2");
        dos.writeUTF("写什么都行3");
        dos.close();
        
        //先尝试用普通的方式去读取
        //结论，内容可以正确读取，但是前面有不能解码的数据
        BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("f:\\utf.txt"),"utf-8"));
        System.out.println("UTF编码的转换流进去读取：" + br.readLine());
        br.close();
        
        //尝试使用DataInputStram 进行读取,可以正确的读取，没有任何的异常出现
        DataInputStream dis = new DataInputStream(new FileInputStream("F:\\utf.txt"));
        System.out.println("writeUTF读取：" + dis.readUTF());
        dis.close();
    }
}

六、操作内存中的字节数组

ByteArrayInputStream，此流对象用来读取字节数组，而数组是存在内存中的，不占用底层系统的资源，所以此流关闭无效，强行调用close方法之后也继续可以使用，同时不会产生IO异常，构造方法中传递一个字节数组，用来存储读取的数据。

ByteArrayOutputStream，用来写字节数组，实际的数据是写进的内存中，同时也是关闭无效，空参构造。

输出流常用的有以下方法：

Byte[] toByteArray(); //返回流中的数组
String toString(); //将流中的数据，转成字符串
String toString(String字符集名字); //将流中的数据，按照传入的编码表转成字符串

demo

import java.io.*;
/*
 * ByteArrayStreamDemo
 */

public class ByteArrayStreamDemo {
    public static void main(String[] args) throws Exception{
        method1();
    }
    
    /*
     * 读取文件到内存，然后使用ByteArrayOutputStream输出到新文件
     */
    public static void method1() throws Exception{
        
        //指定文件，替换为自己的测试文件即可
        FileInputStream fis = new FileInputStream
          (new File("F:\\迅雷下载\\372.90-notebook-win10-64bit-international-whql.exe"));
        ByteArrayOutputStream dos = new ByteArrayOutputStream();
        
        byte[] data = new byte[2014];
        int len = 0;
        
        //这样做会把整个文件在装到内存中,文件过大会出内存溢出的异常
        //我装的文件大概在330MB，此程序结束后，内存会被释放掉
        //可以调用垃圾回收提前释放内存
        while((len = fis.read(data)) != -1){
            dos.write(data,0,len);
        }
        fis.close();
        
        //睡十秒，便于观察内存的占用的情况
        Thread.sleep(10000);
        
        //直接全部输出到新的文件中去
        FileOutputStream fos = new FileOutputStream(new File("F:\\nivdia.exe"));
        fos.write(dos.toByteArray());
        fos.flush();
        fos.close();
    }
    
    /*
     * 普通读写操作
     */
    public static void method() throws UnsupportedEncodingException{
        
        ByteArrayInputStream bats = new ByteArrayInputStream("嘻嘻哈哈".getBytes());
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        
        int len = 0;
        while((len = bats.read()) != -1){
            System.out.println(len);
            baos.write(len);
        }
        
        String s = baos.toString("gbk");
        System.out.println(s);
        
    }
}

七、随机读写流

RandomAccessFile这个随机读写流有点类似于C++中的文件操作对象，能够指定读写的位置，同时同一流对象既能够读取数据也能够写入数据，在已经有数据存在的位置继续写数据会覆盖掉之前的数据。

构造方法：

RandomAccessFile(File file, String mode); //mode为文件打开的方式
RandomAccessFile(String name, String mode); 

mode为文件打开的方式，具体有以下四种方式：

rws和rwd的具体区别：

"rwd" 模式可用于减少执行的 I/O 操作数量。使用 "rwd" 仅要求更新要写入存储的文件的内容；使用 "rws" 要求更新要写入的文件内容及其元数据，这通常要求至少一个以上的低级别 I/O 操作。

常用的方法：

void close(); //关闭流对象
long getFilePointer(); //获取当前文件指针的位置
long length(); //获取文件的长度，按字节计算
int read(); //读取一个字节数据
int read(byte[] b); //读取一个字节数组长度的数据
int read(byte[] b, int off, int len); //读取指定长度的数据
int readInt(); //读取int长度的数据
String readLine(); //读行
void seek(long pos); //设置文件指针的位置
void setLength(long newLength); //设置文件大小，可以用于创建空白文件
void write(byte[] b); //写数据

demo：

package io;

import java.io.*;

/*
 * 随机读写流RandomAccessFile
 * 此流特点，能读能写，能指定文件指针位置，四种打开模式
 * 写：可以写基本数据类型和字节数据
 */
public class RandomAccessFileDemo {
    public static void main(String[] args) throws Exception {
        method();
    }

    /*
     * 实现文件的指定位置读写 
     * 1. 获取一个文件，包括文件名和大小信息
     * 2. 在新目录下创建一个相同大小的新文件,模拟下载文件 
     * 3.然后先复制文件的后半段，再复制文件的前半段信息 
     * 4. 完成复制，尝试打开复制的exe文件，看是否成功
     */
    public static void method() throws Exception {

        // 初始化源文件
        //一个330MB的exe程序
        File file = new File("F:\\nivdia.exe");
        long fileLength = file.length();

        // 源文件名字的处理
        String fileName = file.getName();
        System.out.println(fileName);
        String[] nameAndType = fileName.split("\\.");
        System.out.println(nameAndType.length);
        fileName = nameAndType[0] + "2." + nameAndType[1];

        // 创建随机读取对象，指定模式为rw模式
        RandomAccessFile raf = new RandomAccessFile
          (new File(file.getParentFile(), fileName), "rw");
        // 设置文件大小，如果文件存在，文件大小会被改变
        raf.setLength(fileLength);
        
        //先写后半部分的数据
        // 因为要同时操作两个文件，都还要指定位置读写，所有还需要创建一个随机读写流
        // 因为原文件只需要读取数据，所以为只读模式
        RandomAccessFile rf = new RandomAccessFile(file, "r");
        int len = 0;
        byte[] data = new byte[1024];
        long backHalf = fileLength / 2;
        rf.seek(backHalf);
        raf.seek(backHalf);
        
        //因为文件不规律，所以需要处理好尾部
        //有规律的话，用抓文件末尾异常也可以结束掉循环
        byte[] endsData = new byte[(int) (backHalf % 1024)];
        
        while (true) {
            if((rf.getFilePointer() - backHalf + 1024) > backHalf){
                rf.read(endsData);
                raf.write(endsData);
                break;
            }else{
                rf.read(data);
                raf.write(data);
            }
        }
        
        //接着写前半部分的数据
        rf.seek(0);
        raf.seek(0);
        //此处由于没有到文件末尾，所以不能使用EOF异常来进行判断
        //前后两次肯定会有交叉的地方，由于会覆盖读写，所以不用考虑，
        //只需要确定超过一半就可以
        while(true){
            len = rf.read(data);
            raf.write(data, 0, len);
            if(rf.getFilePointer() > backHalf)
                break;
        }
        rf.close();
        raf.close();
    }
}

模拟下载后文件信息对比（下篇关于线程的文章里会提供多线程通信发包的方式来模拟下载）：

信息对比

以上就是IO流的所以内容。

附：
java--IO流（一）