ObjectInputStream和ObjectOutputStream

ObjectInputStream和ObjectOutputStream这两个包装类，用于从底层输入流中读取对象类型的数据和将对象类型的数据写入到底层输入流。
ObjectInputStream与ObjectOutputStream类所读写的对象必须实现了Serializable接口。对象中的transient和static类型的成员变量不会被读取和写入。
一个可以被序列化的MyClass类的定义：
public class MyClass implements Serializable{
  public transient Thread t;
  private String customerID;
  private int total;
}

编程举例：创建了一个可序列化的学生对象，并用ObjectOutputStream类把他存储到一个文件（mytext.txt）中，然后再用ObjectInputStream类把存储的数据读取到一个学生对象中，即恢复保存的学生对象。


import java.io.*;

public class Student implements Serializable {
  int id;
  String name;
  int age;
  String department;
  public Student(int id, String name, int age, String department){
    this.id = id;
    this.name = name;
    this.age = age;
    this.department = department;
  } 
}

import java.io.*;

public class Serialization {
  public static void main(String [] args) throws Exception {
    Student stu1 = new Student(19, "zhangsan", 25, "huaxue");
    Student stu1 = new Student(20, "lisi", 23, "wuli");

    FileOutputStream fos = new FileOutputStream("student.txt");
    ObjectOutputStream oos = new ObjectOutputStream(fos);
    oos.writeObject(stu1);
    oos.writeObject(stu2);
    oos.close();

    FileInputStream fin = new FileInputStream("student.txt");
    ObjectInputStream ois = new ObjectInputStream(fin);
    stu1 = (Student)ois.readObject();
    stu2 = (Student)ois.readObject();
    ois.close();

    System.out.println("id:" + stu1.id);
    System.out.println("name:" + stu1.name);
    System.out.println("age:" + stu1.age);
    System.out.println("department:" + stu1.department);

    System.out.println("id:" + stu2.id);
    System.out.println("name:" + stu2.name);
    System.out.println("age:" + stu2.age);
    System.out.println("department:" + stu2.department);
  }
}


字节流与字符流的转换：
  能不能找到一种简单的方式来读取键盘上输入的一行字符，如何找？
  InputStreamReader和OutputStreamWriter,是用于将字节流转换成字符流来读写的两个类，InputStreamReader可以将一个字节流中的字节解码成字符后读取，OutputStreamWriter将字符编码成字节后写入到一个字节流中。
  InputStreamReader的两个主要的构造函数：
    -InputStreamReader(InputStream in)
    -InputStreamReader(InputStream in, String CharsetName)
  OutputStreamWriter的两个主要的构造函数：
    -OutputStreamWriter(OutputStream in)
    -OutputStreamWriter(OutputStream in, String CharsetName)
  避免频繁地在字符与字节间进行转换，最好不要直接使用InputStreamReader和OutputStreamWriter类来读写数据，应尽量使用BufferedWriter类包装OutputStreamWriter类，用BufferedReader类包装InputStreamReader。


java程序与其他进程的数据通信：
  在java程序中可以用Process类的实例对象来表示子进程，子进程的标准输入和输出不再连接到键盘和显示器，而是以管道流的形式连接到父进程的一个输出流和输入流对象上。
  调用Process类的getOutputStream和getInputStream方法可以获得连接到子进程的输出流和输入流对象。
  编程实例：在TestInOut类中启动java.exe命令执行另外一个MyTest类，TestInOut和MyTest通过进程间的管道相互传递数据。

import java.io.*;

public class TestInOut implements Runnable {
  Process p = null;
 
  public TestInOut(){
    try{
      p = Runtime.getRuntime().exec("java MyTest");
      //这里的new TestInOut()不能这么写，很危险，可能产生无限递归。
      //而且process的对象也不是一个，用this表达。
      //new Thread(new TestInOut()).start();
      new Thread(this).start();
    }catch(Exception e){
      e.printStackTrace();
    }
  }

  public static void main(String[] args){
    TestInOut tio = new TestInOut();
    tio.send();
   
  }

  public void send(){
    try{
      OutputStream ops = p.getOutputStream();
      while(true){
        ops.write("help/r/n".getBytes());
      }
    }catch(Exception e){
      e.printStackTrace();
    }
  }

  public void run(){
    try{
      InputStream ips = p.getInputStream();  
      BufferedReader bfr = new BufferedReader(new InputStreamReader(in));
      while(true){
        String strLine = bfr.readLine();
        System.out.println(strLine);
      }
    }catch(Exception e){
      e.printStackTrace();
    }
  }
}

public class MyTest{
  public static void main(String[] args) throws Exception {
    while(true){
      System.out.println("hi:" +
      new BufferedReader(new InputStreamReader(System.in)).readLine());
    }
  }
}