java中的IO操作总结（四）

前面已经把java io的主要操作讲完了

这一节我们来说说关于java io的其他内容

 

Serializable序列化

实例1：对象的序列化

import  java.io.File;
import  java.io.FileOutputStream;
import  java.io.IOException;
import  java.io.ObjectOutputStream;
import  java.io.Serializable;

@SuppressWarnings ( "serial" )
//一个类要想实现序列化则必须实现Serializable接口
class  Person implements  Serializable {
    private  String name;
    private  int  age;

    public  Person(String name, int  age) {
        this .name = name;
        this .age = age;
    }

    public  String toString() {
        return  "Name:"  + this .name + ", Age:"  + this .age;
    }
}

public  class  Demo {
    public  static  void  main(String[] args) {
        String path = File.separator + "home"  + File.separator + "siu"  +
                      File.separator + "work"  + File.separator + "demo.txt" ;

        Person p1 = new  Person( "zhangsan" , 12 );
        Person p2 = new  Person( "lisi" , 14 );

        //此处创建文件写入流的引用是要给ObjectOutputStream的构造函数玩儿
        FileOutputStream fos = null ;
        ObjectOutputStream oos = null ;
        try  {
            fos = new  FileOutputStream(path);
            oos = new  ObjectOutputStream(fos);

            //这里可以写入对象，也可以写入其他类型数据
            oos.writeObject(p1);
            oos.writeObject(p2);
        } catch  (IOException e) {
            e.printStackTrace();
        } finally  {
            try  {
                oos.close();
            } catch  (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

所谓对象序列化就是把一个对象进行持久化存储，方便保留其属性

通俗点说，等于把一个对象从堆内存里边揪出来放到硬盘上

当然，如果你开心，你可以序列化其他东西，包括数组，基本数据类型等等

来看看内容，神马玩意儿这是……

 

实例2：对象的反序列化

import  java.io.File;
import  java.io.FileInputStream;
import  java.io.IOException;
import  java.io.ObjectInputStream;

public  class  Demo {
    public  static  void  main(String[] args) {
        String path = File.separator + "home"  + File.separator + "siu"  +
                      File.separator + "work"  + File.separator + "demo.txt" ;

        //好吧，这里代码写得着实有点长了，还要抛异常什么的
        //如果你也看的烦，那就在主方法上抛吧，构造方法里用匿名对象就好了
        //什么？别告诉我你不知道匿名对象
        FileInputStream fis = null ;
        ObjectInputStream ois = null ;
        try  {
            fis = new  FileInputStream(path);
            ois = new  ObjectInputStream(fis);

            //这里返回的其实是一个Object类对象
            //因为我们已知它是个Person类对象
            //所以，就地把它给向下转型了
            Person p = (Person)ois.readObject();
            System.out.println(p);

            //抛死你，烦烦烦～！！！
        } catch  (IOException e) {
            e.printStackTrace();
        } catch  (ClassNotFoundException e) {
            e.printStackTrace();
        } finally  {
            try  {
                //还是要记得关闭下流
                ois.close();
            } catch  (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

你看，我们把一个对象存放在硬盘上是为了方便日后使用

现在用得着它了，自然得拿出来

 

管道流

实例3：线程的通信

import  java.io.IOException;
import  java.io.PipedInputStream;
import  java.io.PipedOutputStream;

//实现Runnable接口，实现一个读的线程
class  Read implements  Runnable {
    private  PipedInputStream in;
    //将需要读的管道流传入到构造函数中
    public  Read(PipedInputStream in) {
        this .in = in;
    }

    //实现读这一线程
    public  void  run() {
        try  {
            byte [] buf = new  byte [ 1024 ];
            int  temp = 0 ;
            //循环读取
            //read是一个阻塞方法，需要抛异常
            //此处把打印流的代码也加入进来
            //是因为如果没有读取到数据，那么打印的代码也无效
            while ((temp = in.read(buf)) != - 1 ) {
                String str = new  String(buf, 0 ,temp);
                System.out.println(str);
            }
        } catch  (IOException e) {
            //其实这里应抛出一个自定义异常的
            //暂时我还没弄清楚
            e.printStackTrace();
        } finally  {
            try  {
                //我已经抛火了，这只是为了提醒自己异常很重要
                in.close();
            } catch  (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

//这里实现一个写的类
class  Write implements  Runnable {
    private  PipedOutputStream out;
    //将管道输入流传进来
    public  Write(PipedOutputStream out) {
        this .out = out;
    }

    public  void  run() {
        try  {
            //这里开始写出数据
            out.write( "管道输出" .getBytes());
        } catch  (IOException e) {
            e.printStackTrace();
        } finally  {
            try  {
                //其实应该可以把这个关闭方法写到上面那个try里边
                //但是这样感觉怪怪的，逻辑不大对
                out.close();
            } catch  (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

public  class  Demo {
    public  static  void  main(String[] args) {
        PipedInputStream in = new  PipedInputStream();
        PipedOutputStream out = new  PipedOutputStream();
        try  {
            //连接管道
            in.connect(out);

            //创建对象，开启线程
            //此处同样放进try...catch里面
            //因为如果没有链接管道，下面操作无意义
            Read r = new  Read(in);
            Write w = new  Write(out);
            //把已经实现好run方法的对象放入线程中执行
            new  Thread(r).start();
            new  Thread(w).start();

        } catch  (IOException e) {
            e.printStackTrace();
        }
    }
}

 好吧，废了那么大劲儿，就打印了这么一句话，异常抛弃来很烦，为了注重细节……

管道流也许很难理解，其实非也

我们知道，字节流和字符流都需要数组来进行流的中转

而管道流则直接串联两条流，一边发送数据，一边接收

然而，同时通信的的两种状态，如何才能确定发送和接收的一致性呢

那么，就需要用到线程，无论是接收方还是发送方先执行

总会造成一个线程的阻塞状态，从而等待另一方的数据传过来

总体而言，管道流的目的，也就是为了线程通信

此外，还有PipedReader和PipedWriter类，操作原理都一样，这里就不再赘述了

 

DataOutputStream和DataInputStream类

实例4：基本数据类型的写入

import  java.io.DataOutputStream;
import  java.io.File;
import  java.io.FileOutputStream;
import  java.io.IOException;

public  class  Demo {
    public  static  void  main(String[] args) {
        String path = File.separator + "home"  + File.separator + "siu"  +
                      File.separator + "work"  + File.separator + "demo.txt" ;

        DataOutputStream d = null ;
            try  {
                //此处需要传入一个OutputStream类的对象
                d = new  DataOutputStream( new  FileOutputStream(path));
                //开始写入基本数据类型
                d.writeInt( 12 );
                d.writeBoolean( true );
                d.writeDouble( 12.2223 );
                d.writeChar( 97 );
                //刷新流
                d.flush();

            } catch  (IOException e) {
                e.printStackTrace();
            } finally  {
                try  {
                    d.close();
                } catch  (IOException e) {
                    e.printStackTrace();
                }
            }
    }
}

此处我们并不能直观看懂内容，因为它采用字节流的方式操作，而不是字符流

我们只需要知道，此程序已经将基本数据类型写入到硬盘即可

 

实例5：基本数据类型的读取

import  java.io.DataInputStream;
import  java.io.File;
import  java.io.FileInputStream;
import  java.io.IOException;

public  class  Demo {
    public  static  void  main(String[] args) {
        String path = File.separator + "home"  + File.separator + "siu"  +
                      File.separator + "work"  + File.separator + "demo.txt" ;

        DataInputStream d = null ;
            try  {
                d = new  DataInputStream( new  FileInputStream(path));
                //按存储顺序读取基本数据类型
                System.out.println(d.readInt());
                System.out.println(d.readBoolean());
                System.out.println(d.readDouble());
                System.out.println(d.readChar());

            } catch  (IOException e) {
                e.printStackTrace();
            } finally  {
                try  {
                    d.close();
                } catch  (IOException e) {
                    e.printStackTrace();
                }
            }
    }
}

 这里要注意的是，一定要按照写入顺序读取，否则会发生数据的打印错误