Java IO (三) 读取其他进程数据,RandomAccessFile,序列化和反序列化

摘要：虚拟机读取其他进程的数据对象的方法可以运行平台上的其他程序该方法产生一个对象对象代表由该程序启动启动的子进程类提供如下三个方法用于和其子进程通信获取子进程的错误流获取子进程的输入流获取子进程的输出流这里的输入流输出流容易混淆从程序的角度思考

Runtime对象的exec方法可以运行平台上的其他程序,该方法产生一个Process对象,Process对象代表由该Java程序启动启动的子进程,Process类提供如下三个方法,用于和其子进程通信:

InputStream getErrorStream() 获取子进程的错误流
InputStream getInputStream() 获取子进程的输入流
OutputStream getOutputStream() 获取子进程的输出流

  
这里的输入流输出流容易混淆.从程序的角度思考,子进程读取程序的数据,为输出流.子进程读取数据,是让程序把数据输出到子进程中.

java//省略代码

            Process p = Runtime.getRuntime().exec("javac");
            BufferedReader br = new BufferedReader(new InputStreamReader(p.getErrorStream(),"GBK"));
            String buff;
            while ((buff = br.readLine()) != null ) {
                System.out.println(buff);
            }

//省略代码

javapublic class WriteToProcess {
    public static void main(String[] args) {
        PrintStream ps = null;
        try {
            //返回运行该命令的子进程
            Process p = Runtime.getRuntime().exec("java ReadStand");
            //p进程的输出流创建PrintStream对象
            //对本程序是输出流,对p进程则是输入流
            ps = new PrintStream(p.getOutputStream());
            BufferedReader br = new BufferedReader(new InputStreamReader(p.getInputStream()));
            String content;
            while ((content = br.readLine()) != null) {
                System.out.println(content);
            }
            ps.println("普通字符串");
            ps.println(new WriteToProcess());
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            if (null != ps) {
                ps.close();
            }
        }
    }
}
class ReadStand {
    public static void main(String[] args) {
        PrintStream ps = null;
        Scanner sc = new Scanner(System.in);
        try {
            ps = new PrintStream("src	estout.txt");
            sc.useDelimiter("
");
            while (sc.hasNext()) {
                ps.print("键盘输入的内容是:" + sc.next());
            }
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            sc.close();
            ps.close();
        }
    }
}

  
计算机中"随机访问"是由Random Access两个单词单词翻译而来.Random不仅有随机的意思,还有任意的意思.如果

  能这样理解Random,可以更好的理解Random Access:任意访问,也就是说可以自由访问任意存储点的存储器(与磁盘,

  磁带等需要寻道,倒带才可访问存储点的存储器区分);而RandomAccessFile的含义是可以自由访问文件的任意地方(与

  InputStream,Reader依次向后读取区分).

    //省略代码
    RandomAccessFile raf = null;
    //省略代码
    try {
        raf = new RandomAccessFile("out.txt","rw");
        raf.seek(raf.length());
        raf.write("追加内容
".getBytes());
    }

javapublic static void insert(String fileName,long pos,String insertContent) {
        RandomAccessFile raf = null;
        try {
            raf = new RandomAccessFile(fileName, "rw");
            File tmpFile = File.createTempFile("temp", null);
            tmpFile.deleteOnExit();
            BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(tmpFile)));
            BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(tmpFile)));
            //设置文件指针位置
            raf.seek(pos);
            String content;
            /**
             * 将插入点内容保存在临时文件中
             * 读取插入点后所有文件内容
             */
            while ((content = raf.readLine()) != null) {
                    //将数据写入临时文件
                    bw.write(content);
            }
            bw.flush();
            bw.close();
            //重新设置指针位置
            raf.seek(pos);
            //插入内容
            raf.write(insertContent.getBytes());
            //追加临时文件中内容
            while ((content = br.readLine()) != null) {
                raf.write(content.getBytes());
            }
            br.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            try {
                raf.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }


    }

javapublic class ObjectOutputStreamTest {
    public static void main(String[] args) {
        ObjectOutputStream oos = null;

        try {
            //创建一个ObjectOutputStream输出流
            oos = new ObjectOutputStream(new FileOutputStream("src//io//person.txt"));
            Person p1 = new Person("swk", 20);
            //把对象写入输出流
            oos.writeObject(p1);
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally { 
                try {
                    if (null != oos) {
                        oos.close();
                    }
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }

class Person implements Serializable {

    private static final long serialVersionUID = 1L;
    private String name;
    private int age;

    public Person(String name,int age) {
        // TODO Auto-generated constructor stub    
        System.out.println("Person 构造函数");
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }


}

java//省略代码
    ObjectInputStream ois = null;
        try {
            //创建ObjectInputStream输入流
            ois = new ObjectInputStream(new FileInputStream("src//io//person.txt"));
            //从流中读取对象,并强制转换为Person类型
            Person p = (Person)ois.readObject();
            System.out.println("Age:" + p.getAge() + ",name:" + p.getName());
        } 
//省略代码

  
反序列化读取的只是Java对象的数据,而不是Java类,因此采用反序列化恢复Java对象时,必须提供Java对象所属的class文件,否则引发ClassNotFoundException.

  
Person类只有一个有参数构造器,并没有无参数构造器,而且构造函数内有打印语句.当反序列化读取Java对象时,没有看到程序调用该构造器,这表明反序列化机制无需通过构造器来初始化Java对象.

  
如果向文件中使用序列化多个Java对象,使用反序列化机制恢复时,必须按实际写入顺序读取.