序列化和反序列化可以同时操作，比如读取文件1里的内容后，再把该文件1的内容拷贝（写入）到文件2里去，需要同时操作输入和输出，输出表示序列化，输入表示反序列化。

序列化中父类构造函数问题

对子类对象进行反序列化操作时，如果其父类没有实现序列化接口，那么其父类的构造函数会被调用。

public class ObjectSeriaDemo2 {
 public static void main(String[] args) throws Exception{
  /*ObjectOutputStream oos = new ObjectOutputStream(
    new FileOutputStream("demo/obj1.dat"));
  Foo2 foo2 = new Foo2();
  oos.writeObject(foo2);
  oos.flush();
  oos.close();*/
  
  //反序列化是否递归调用父类的构造函数
  /*ObjectInputStream ois = new ObjectInputStream(
    new FileInputStream("demo/obj1.dat"));
  Foo2 foo2 = (Foo2)ois.readObject();
  System.out.println(foo2);
  ois.close();*/
  
  
  /*ObjectOutputStream oos = new ObjectOutputStream(
    new FileOutputStream("demo/obj1.dat"));
  Bar2 bar2 = new Bar2();
  oos.writeObject(bar2);
  oos.flush();
  oos.close();*/
  
  ObjectInputStream ois = new ObjectInputStream(
    new FileInputStream("demo/obj1.dat"));
  Bar2 bar2 = (Bar2)ois.readObject();
  System.out.println(bar2);
  ois.close();
  
  
  /*
   * 对子类对象进行反序列化操作时，
   * 如果其父类没有实现序列化接口
   * 那么其父类的构造函数会被调用
   */
 }
}
/*
 *   一个类实现了序列化接口，那么其子类都可以进行序列化
 */
class Foo implements Serializable{ 
 public Foo(){
  System.out.println("foo...");
 }
}
class Foo1 extends Foo{
 public Foo1(){
  System.out.println("foo1...");
 }
}
class Foo2 extends Foo1{
 public Foo2(){
  System.out.println("foo2...");
 }
}
class Bar{
 public Bar(){
  System.out.println("bar");
 }
}
class Bar1 extends Bar{
 public Bar1(){
  System.out.println("bar1..");
 }
}
class Bar2 extends Bar1 implements Serializable{
 public Bar2(){
  System.out.println("bar2...");
 }
}

使用transient关键字不做jvm默认的序列化,可自己完成该元素的序列化

//重要语句
public class Student implements Serializable {
    private transient int stuage;
    private void writeObject(java.io.ObjectOutputStream s) 
    throws java.io.IOException{
        s.defaultWriteObject();// 把jvm能默认序列化的元素进行序列化操作
        s.writeInt(stuage);// 自己完成stuage的序列化
    } 
    private void readObject(java.io.ObjectInputStream s) 
    throws java.io.IOException, ClassNotFoundException {  
        s.defaultReadObject();// 把jvm能默认反序列化的元素进行反序列化操作  
        this.stuage = s.readInt();// 自己完成stuage的反序列化操作 
    }
}

序列化与反序列化实例

  String file = "demo/obj.dat";
  //1.对象的序列化
  /*ObjectOutputStream oos = new ObjectOutputStream(
    new FileOutputStream(file));
  Student stu = new Student("10001", "张三", 20);
  oos.writeObject(stu);
  oos.flush();
  oos.close();*/
  ObjectInputStream ois = new ObjectInputStream(
    new FileInputStream(file));
  Student stu = (Student)ois.readObject();
  System.out.println(stu);
  ois.close();

字符流---BufferedReader、BufferedWriter、PrintWriter(过滤器)---实例

  //对文件进行读写操作 
  BufferedReader br = new BufferedReader(
    new InputStreamReader(
      new FileInputStream("E:\\Temp\\javaio\\imooc.txt")));
  /*BufferedWriter bw = new BufferedWriter(
    new OutputStreamWriter(
      new FileOutputStream(""E:\\Temp\\javaio\\imooc3.txt")));*/
  PrintWriter pw = new PrintWriter("E:\\Temp\\javaio\\imooc4.txt");
  //PrintWriter pw1 = new PrintWriter(outputStream,boolean autoFlush);
  String line ;
  while((line = br.readLine())!=null){
   System.out.println(line);//一次读一行，并不能识别换行
   /*bw.write(line);
   //单独写出换行操作
   bw.newLine();//换行操作
   bw.flush();*/
   pw.println(line);
   pw.flush();
  }
  br.close();
  //bw.close();
  pw.close();

InputStreamReader   完成byte流解析为char流,按照编码解析
OutputStreamWriter  提供char流到byte流，按照编码处理 

字符流---FileReader、FileWriter(文件读写流)---实例

  FileReader fr = new FileReader("e:\\javaio\\imooc.txt");
  FileWriter fw = new FileWriter("e:\\javaio\\imooc2.txt");
  //FileWriter fw = new FileWriter("e:\\javaio\\imooc2.txt",true);
  char[] buffer = new char[2056];
  int c ;
  while((c = fr.read(buffer,0,buffer.length))!=-1){
   fw.write(buffer,0,c);
   fw.flush();
  }
  fr.close();
  fw.close();

字符流---InputStreamReader、OutputStreamWriter(字节字符转换流)---实例

  FileInputStream in = new FileInputStream("E:\\Temp\\javaio\\imoocutf8.txt");
  InputStreamReader isr = new InputStreamReader(in,"utf-8");//默认项目的编码,操作的时候，要写文件本身的编码格式
 
  FileOutputStream out = new FileOutputStream("E:\\Temp\\javaio\\imoocutf81.txt");
  OutputStreamWriter osw = new OutputStreamWriter(out,"utf-8");
  /*int c ;
  while((c = isr.read())!=-1){
   System.out.print((char)c);
  }*/
  char[] buffer = new char[8*1024];
  int c;
  /*批量读取，放入buffer这个字符数组，从第0个位置开始放置，最多放buffer.length个
    返回的是读到的字符的个数
  */
  while(( c = isr.read(buffer,0,buffer.length))!=-1){
   String s = new String(buffer,0,c);
   System.out.print(s);
   osw.write(buffer,0,c);
   osw.flush();
  }
  isr.close();
  osw.close();

认识文本和文本文件
java的文本(char)是16位无符号整数，是字符的unicode编码（双字节编码)
文件是byte byte byte ...的数据序列
文本文件是文本(char)序列按照某种编码方案(utf-8,utf-16be,gbk)序列化为byte的存储结果

 从应用程序中把输入放入文件，相当于将一缸水倒入到另一个缸中:
 FileOutputStream--->write()方法相当于一滴一滴地把水“转移”过去
 DataOutputStream-->writeXxx()方法会方便一些，相当于一瓢一瓢把水“转移”过去
 BufferedOutputStream--->write方法更方便，相当于一飘一瓢先放入桶中，再从桶中倒入到另一个缸中，性能提高了

try {
   long start = System.currentTimeMillis();
   /*IOUtil.copyFileByByte(new File("E:\\Temp\\aa.mp3"), new File("E:\\Temp\\bb.mp3"));//两万多毫秒*/
   /*IOUtil.copyFileByBuffer(new File("E:\\Temp\\aa.mp3"), new File("E:\\Temp\\bb.mp3"));//一万多毫秒*/
   IOUtil.copyFile(new File("E:\\Temp\\aa.mp3"), new File("E:\\Temp\\bb.mp3"));//7毫秒
   long end = System.currentTimeMillis();
   System.out.println(end - start );
  } catch (IOException e) {
   e.printStackTrace();
  }

字节流---DataInputStream、DataOutputStream(数据输入、输出流)

//DataOutputStream实例  
  String file = "demo/dos.dat";
  DataOutputStream dos = new DataOutputStream(new FileOutputStream(file));
  dos.writeInt(10);
  dos.writeInt(-10);
  dos.writeLong(10l);
  dos.writeDouble(10.5);
  //采用utf-8编码输出
  dos.writeUTF("中国");
  //采用utf-16be编码写出
  dos.writeChars("中国");
  dos.close();
  IOUtil.printHex(file);

//DataInputStream实例
  String file = "demo/dos.dat";
  IOUtil.printHex(file);
  DataInputStream dis = new DataInputStream(new FileInputStream(file));
  int i = dis.readInt();
  System.out.println(i);
  i = dis.readInt();
  System.out.println(i);
  long l = dis.readLong();
  System.out.println(l);
  double d = dis.readDouble();
  System.out.println(d);
  String s = dis.readUTF();
  System.out.println(s);
  dis.close();

字节流---FileOutputStream(文件输出流)

 public static void copyFile(File srcFile,File destFile) throws IOException{
  if(!srcFile.exists()){
   throw new IllegalArgumentException("文件"+srcFile+"不存在");
  }
  if(!srcFile.isFile()){
   throw new IllegalArgumentException(srcFile+"不是文件");
  }
  FileInputStream in = new FileInputStream(srcFile);
  FileOutputStream out = new FileOutputStream(destFile);
  byte[] buf = new byte[8*1024];
  int b;
  while((b = in.read(buf,0,buf.length))!=-1){
   out.write(buf, 0, b);
   out.flush();//最好加上
  }
  in.close();
  out.close();
 }

字节流---FileInputStream(文件输入流)---read(byte[] b, int off, int len)

public static void printHexByByteArray(String fileName) throws IOException{
  FileInputStream in = new FileInputStream(fileName);
  byte[] buf = new byte[20*1024];
  /*从in中批量读取字节，放入到buf这个字节数组中，
  * 从第0个位置开始放，最多放buf.length个
  * 返回的是读到的字节的个数
  */
  /*int bytes = in.read(buf,0,buf.length);//一次性读完，说明字节数组足够大
  int j = 1;
  for(int i=0;i<bytes;i++){
   if(buf[i]<=0xf){
    System.out.print("0");
   }
   System.out.print(Integer.toHexString(buf[i])+" ");
   if(j++%10==0){
    System.out.println();
   }
  }*/
  int bytes = 0;
  int j = 1;
  while((bytes = in.read(buf,0,buf.length))!=-1){
   for(int i = 0;i<bytes;i++){
    if(buf[i]<=0xf){
     System.out.print("0");
    }
    System.out.print(Integer.toHexString(buf[i]&0xff)+" ");
    if(j++%10==0){
     System.out.println();
    }
   }
  }
 }

字节流---FileInputStream(文件输入流)---read()

public static void printHex(String fileName) throws IOException{
  //把文件作为字节流进行读操作
  FileInputStream in = new FileInputStream(fileName);
  int b;
  int i = 1;
  while((b = in.read())!=-1){
   if(b<=0xf){
    //单位数前面补0
    System.out.print("0");
   }
   System.out.print(Integer.toHexString(b)+" ");
   if(i++%10==0){
    System.out.println();
   }
  }
  in.close();
 }

RandomAccessFile的基本操作

  RandomAccessFile raf = new RandomAccessFile(file, "rw");
  //指针的位置
  System.out.println(raf.getFilePointer());
  
  raf.write('A');//只写了一个字节
  System.out.println(raf.getFilePointer());
  raf.write('B');
  
  int i = 0x7ffffff;
  //用write方法每次只能写一个字节，如果要把i写进去就得写4次
  raf.write(i>>>24);//高8位
  raf.write(i>>>16);
  raf.write(i>>>8);
  raf.write(i);
  System.out.println(raf.getFilePointer());
  
  //可以直接写一个int
  raf.writeInt(i);
  
  String s = "中";
  //以gbk编码存储
  byte[] gbk = s.getBytes("gbk");
  raf.write(gbk);
  System.out.println(raf.length());
  
  //读文件，必须把指针移到头部
  raf.seek(0);
  //一次性读取,把文件中的内容都读到字节数组中
  byte[] buf = new byte[(int)raf.length()];
  raf.read(buf);
  System.out.println(Arrays.toString(buf));
  
  //以字符串输出
  String str = new String(buf,"gbk");
  System.out.println(str);
  
  //以十六进制输出
  for (byte b : buf) {
   System.out.print(Integer.toHexString(b & 0xff) + " ");
  }
  
  //关闭
  raf.close();