15_IO流

 
 IO流 

流

 
 流的概念 

 
 流(stream)是指一连串流动字节/字符，按照先进先出的方式发送的信息的通道中。 

 
 数据源:流入通道中的数据的来源 

 
 目的地:流出通道的数据的目的地 

 
 输入流和输出流 

 
 数据源的数据流入程序的流称为输入流 

 
 程序中的数据流出到目的地的流称为输出流 

 
 流的分类 

 
 InputStream/OutputStream 

 
 inputstream 表示字节输入流，是所有字节输入流的抽象父类。提供了read/read(byte[] buf) 用于读取一个或者多个字节；close用于关闭输入流。 

 
 outputstream 表示字节输出流，是所有字节输出流的抽象父类。 

 
 FileInputStream 

 
 FileInputStream 专门用于读取文件的字节输入流。可以用于读取文本性文件(存在编码)、图片音频视频等二进制文件。 

 
 一次读取一个字节 

 
      package cn.sxt01.fileinputstream; 
     
      import java.io.File; 
     
      import java.io.FileInputStream; 
     
      import java.io.FileNotFoundException; 
     
      import java.io.IOException; 
     
      public class Test01 { 
     
       public static void main(String[] args) { 
     
       // 需求:读取c.txt中的内容 
     
       File file = new File("d:\\javatest\\c.txt"); 
     
       // 【1】构建输入流（管道） 
     
       FileInputStream fis = null; 
     
       try { 
     
       fis = new FileInputStream(file); 
     
       System.out.println(fis); 
     
       } catch (FileNotFoundException e) { 
     
       e.printStackTrace(); 
     
       } 
     
       // 【2】读取一个字节 
     
       int r = 0; 
     
       try { 
     
       r = fis.read(); 
     
       } catch (IOException e) { 
     
       e.printStackTrace(); 
     
       } 
     
       System.out.println((char)r); 
     
       // 【3】关闭流 
     
       try { 
     
       fis.close(); 
     
       } catch (IOException e) { 
     
       e.printStackTrace(); 
     
       } 
     
       } 
     
      }

 
 read() 一次读取一个字节，如果已到达文件末尾，则返回 -1。 

 
 一次读取多个字节 

 
      package cn.sxt01.fileinputstream; 
     
      import java.io.File; 
     
      import java.io.FileInputStream; 
     
      import java.io.FileNotFoundException; 
     
      import java.io.IOException; 
     
      import java.util.Arrays; 
     
      public class Test03 { 
     
       public static void main(String[] args) { 
     
       // 需求:读取c.txt中的内容 
     
       File file = new File("d:\\javatest\\c.txt"); 
     
       // 【1】构建输入流（管道） 
     
       FileInputStream fis = null; 
     
       try { 
     
       fis = new FileInputStream(file); 
     
       System.out.println(fis); 
     
       } catch (FileNotFoundException e) { 
     
       e.printStackTrace(); 
     
       } 
     
       // 【2】读取一个字节 
     
       int len = 0; // 读取到缓冲区中的字节个数 
     
       byte[] buf = new byte[2]; // 字节缓冲区 
     
       StringBuilder sb = new StringBuilder(); 
     
       try { 
     
       while( (len=fis.read(buf)) != -1 ) { 
     
       String tmp = new String(buf,0,len); 
     
       sb.append(tmp); 
     
       } 
     
       } catch (IOException e) { 
     
       e.printStackTrace(); 
     
       } 
     
       System.out.println(sb); 
     
       // 【3】关闭流 
     
       try { 
     
       fis.close(); 
     
       } catch (IOException e) { 
     
       e.printStackTrace(); 
     
       } 
     
       } 
     
      }

 
 read(byte[] buf)一次读取多个字节到字节缓冲区，并返回读取的字节个数。 

 
 FileOutputStream 

 
 一次写一个字节 

 
      package cn.sxt01.fileouputstream; 
     
      import java.io.File; 
     
      import java.io.FileInputStream; 
     
      import java.io.FileNotFoundException; 
     
      import java.io.FileOutputStream; 
     
      import java.io.IOException; 
     
      public class Test01 { 
     
       public static void main(String[] args) { 
     
       // 需求:写入helloworld 到d.txt中的内容 
     
       File file = new File("d:\\javatest\\d.txt"); 
     
       // 【1】创建输出流(管道) 
     
       FileOutputStream fos = null; 
     
       try { 
     
       fos = new FileOutputStream(file); 
     
       } catch (FileNotFoundException e) { 
     
       e.printStackTrace(); 
     
       } 
     
       //【2】写入信息到输出流 
     
       try { 
     
       fos.write('h'); 
     
       fos.write('e'); 
     
       fos.write('l'); 
     
       fos.write('l'); 
     
       fos.write('o'); 
     
       } catch (IOException e) { 
     
       e.printStackTrace(); 
     
       } 
     
       // 【3】刷新缓冲区 
     
       try { 
     
       fos.flush(); 
     
       fos.close(); 
     
       } catch (IOException e) { 
     
       e.printStackTrace(); 
     
       } 
     
       } 
     
      }

 
 当调用write(int)方法时，把一个字节写入到输出流，输出流会立即把该字节写入文件中。 

 
 所以，如果不手动代用flush方法，信息也写入到文件中。 

 
 一次写多个字节(指定编码) 

 
      package cn.sxt01.fileouputstream; 
     
      import java.io.File; 
     
      import java.io.FileInputStream; 
     
      import java.io.FileNotFoundException; 
     
      import java.io.FileOutputStream; 
     
      import java.io.IOException; 
     
      public class Test02 { 
     
       public static void main(String[] args) { 
     
       // 需求:写入helloworld 到d.txt中的内容 
     
       File file = new File("d:\\javatest\\d.txt"); 
     
       // 【1】创建输出流(管道) 
     
       FileOutputStream fos = null; 
     
       try { 
     
       fos = new FileOutputStream(file); 
     
       } catch (FileNotFoundException e) { 
     
       e.printStackTrace(); 
     
       } 
     
       //【2】写入信息到输出流 
     
       try { 
     
       String str = "hello world中国"; 
     
       // 默认gbk编码 
     
       /*byte[] buf = str.getBytes(); 
     
       fos.write(buf);*/ 
     
       byte[] buf = str.getBytes("utf8"); 
     
       fos.write(buf); 
     
       } catch (IOException e) { 
     
       e.printStackTrace(); 
     
       } 
     
       // 【3】刷新缓冲区 
     
       try { 
     
       fos.flush(); 
     
       // 【4】关闭文件 
     
       fos.close(); 
     
       } catch (IOException e) { 
     
       e.printStackTrace(); 
     
       } 
     
       } 
     
      }

 
 write(byte[] buf)一次写入多个字节到输出流。注意，此时的字节流已经经过编码。默认是系统编码(win7:gbk)。 

 
 write(byte[] buf,offset,len) 一次写入buf中从offset开始，len个长度的字节到输出流。 

 
 综合案例: 

 
 [1]把目录中的logo.jpg复制到工程中。 

 
 [2]请打印复制进度 

 
 Reader/Writer 

 
 Reader 是字符输入流的抽象父类。提供了read()一次读取一个字符;read(char[] buf)一次多去多个字符到字符缓冲区。 

 
 Writer 是字符输出流的抽象父类。提供了 

 
 write()写入单个字符 

 
 write(char[] cbuf) 写入多个字符 

 
 write(String str) 写入字符串 

 
 FileReader 

 
 FileReader是文件字符输入流，专门用于读取文本性文件。不能读取图片、音频、视频等二进制文件。 

 
 一次读取一个字符 

 
      package cn.sxt03.filereader; 
     
      import java.io.File; 
     
      import java.io.FileNotFoundException; 
     
      import java.io.FileReader; 
     
      import java.io.IOException; 
     
      public class Test01 { 
     
       public static void main(String[] args) { 
     
       File file = new File("d:\\javatest\\d.txt"); 
     
       // 【1】建立字符输入流 
     
       FileReader fr = null; 
     
       try { 
     
       fr = new FileReader(file); 
     
       } catch (FileNotFoundException e) { 
     
       e.printStackTrace(); 
     
       } 
     
       // 【2】一次读取一个字符 
     
       int r = 0; 
     
       try { 
     
       /*r = fr.read(); 
     
       r = fr.read(); 
     
       r = fr.read(); 
     
       r = fr.read(); 
     
       r = fr.read(); 
     
       r = fr.read(); 
     
       System.out.println(r);*/ 
     
       /* 
     
       中国abc\r\n 
     
       中国你好你好 
     
       */ 
     
       StringBuilder sb = new StringBuilder(); 
     
       while( (r=fr.read()) != -1 ) { 
     
       sb.append((char)r); 
     
       } 
     
       System.out.println(sb); 
     
       } catch (IOException e) { 
     
       e.printStackTrace(); 
     
       } 
     
       // 【3】关闭输入流 
     
       try { 
     
       fr.close(); 
     
       } catch (IOException e) { 
     
       e.printStackTrace(); 
     
       } 
     
       } 
     
      }

 
 一次读取多个字符 

 
      package cn.sxt03.filereader; 
     
      import java.io.File; 
     
      import java.io.FileNotFoundException; 
     
      import java.io.FileReader; 
     
      import java.io.IOException; 
     
      import java.util.Arrays; 
     
      public class Test01 { 
     
       public static void main(String[] args) { 
     
       File file = new File("d:\\javatest\\d.txt"); 
     
       // 【1】建立字符输入流 
     
       FileReader fr = null; 
     
       try { 
     
       fr = new FileReader(file); 
     
       } catch (FileNotFoundException e) { 
     
       e.printStackTrace(); 
     
       } 
     
       // 【2】一次读取多个字符 
     
       int len = 0; 
     
       char[] cbuf = new char[2]; 
     
       try { 
     
       /* 
     
       len = fr.read(cbuf); 
     
       len = fr.read(cbuf); 
     
       len = fr.read(cbuf); 
     
       System.out.println(len); 
     
       System.out.println(Arrays.toString(cbuf)); 
     
       */ 
     
       StringBuilder sb = new StringBuilder(); 
     
       while( (len=fr.read(cbuf)) != -1) { 
     
       sb.append(cbuf, 0, len); 
     
       } 
     
       System.out.println(sb); 
     
       } catch (IOException e) { 
     
       e.printStackTrace(); 
     
       } 
     
       // 【3】关闭输入流 
     
       try { 
     
       fr.close(); 
     
       } catch (IOException e) { 
     
       e.printStackTrace(); 
     
       } 
     
       } 
     
      }

 
 FileWriter 

 
 FileWriter 文件字符输出流，专门用于写入文本性文件。 

 
 通过FileWriter构造方法构造的对象写入文件时编码是系统默认编码(win7:gbk)。 

 
 由于写入的是字符，字符在写入时一定要经过编码，所以FileWriter内部有一个字符缓冲区用于存放待写入的字符，在调用flush时，FileWriter把字符缓冲区的字符编码成字节然后写入目标文件。 

 
      package cn.sxt03.filewriter; 
     
      import java.io.File; 
     
      import java.io.FileWriter; 
     
      import java.io.IOException; 
     
      public class Test01 { 
     
       public static void main(String[] args) { 
     
       File file = new File("d:\\javatest\\e.txt"); 
     
       FileWriter fw = null; 
     
       // 【1】建立输出流管道 
     
       try { 
     
       /* 
     
       * append:表示写入文件的方式 
     
       * true:追加 false:覆盖 
     
       */ 
     
       fw = new FileWriter(file,false); 
     
       } catch (IOException e) { 
     
       e.printStackTrace(); 
     
       } 
     
       // 【2】写入 
     
       try { 
     
       // 写入一个字符 
     
       /*fw.write('中'); 
     
       fw.write('国');*/ 
     
       // 写入一个字符数组 
     
       /*char[] cbuf = {'中','国','\r','\n','a','b','c'}; 
     
       fw.write(cbuf);*/ 
     
       // 写入一个字符串 
     
       fw.write("中国abc"); 
     
       } catch (IOException e) { 
     
       e.printStackTrace(); 
     
       } 
     
       // 【3】刷新 
     
       try { 
     
       fw.flush(); 
     
       fw.close(); 
     
       } catch (IOException e) { 
     
       e.printStackTrace(); 
     
       } 
     
       } 
     
      }

 
 思考:如何读取一个utf8编码的文本文件。 

 
 转换流 

 
 所谓转换流可以把字节流转化成字符流的转换流 

 
 InputStreamReader 是字节流通向字符流的桥梁，它使用指定的字符集读取字节并将其解码为字符。 

 
 OutputStreamWriter 是字符流通向字节流的桥梁，可使用指定的字符集将要写入流中的字符编码成字节 

 
 转换流工作原理 

 
 以utf8编码写入文件 

 
      package cn.sxt04.outputstramwriter; 
     
      import java.io.File; 
     
      import java.io.FileNotFoundException; 
     
      import java.io.FileOutputStream; 
     
      import java.io.FileWriter; 
     
      import java.io.IOException; 
     
      import java.io.OutputStream; 
     
      import java.io.OutputStreamWriter; 
     
      public class Test01 { 
     
       public static void main(String[] args) throws FileNotFoundException,IOException { 
     
       // 需求：写入 “中国abc” 以utf8编码写入 
     
       File file = new File("d:\\javatest\\g.txt"); 
     
       FileOutputStream out = new FileOutputStream(file); 
     
       OutputStreamWriter osw = new OutputStreamWriter(out, "utf8"); 
     
       osw.write('中'); 
     
       char[] cbuf = {'国','a'}; 
     
       osw.write(cbuf); 
     
       osw.write("中国abc"); 
     
       osw.flush(); 
     
       osw.close(); 
     
       } 
     
      }

 
 以utf8编码读取文件 

 
      public class Test02 { 
     
       public static void main(String[] args) throws FileNotFoundException,IOException { 
     
       // 需求：读取g.txt的内容 
     
       File file = new File("d:\\javatest\\g.txt"); 
     
       FileInputStream fis = new FileInputStream(file); 
     
       InputStreamReader isr = new InputStreamReader(fis, "utf8"); 
     
       /*int r = isr.read(); 
     
       System.out.println((char)r);*/ 
     
       char[] cbuf = new char[2]; 
     
       int len = 0; 
     
       StringBuilder sb = new StringBuilder(); 
     
       while( (len=isr.read(cbuf)) != -1) { 
     
       sb.append(cbuf,0,len); 
     
       } 
     
       System.out.println(sb); 
     
       } 
     
      }

 
 思考:FileReader和InputStreamReader的关系？ 

 
 注意:win7手动创建utf8编码的文件(utf8-bom) 

 
 java程序写入的utf8文件不带bom 

 
      public class Test03 { 
     
       public static void main(String[] args) throws FileNotFoundException,IOException { 
     
       // 需求：读取win手动创建的utf8编码的h.txt的内容 
     
       File file = new File("d:\\javatest\\h.txt"); 
     
       FileInputStream fis = new FileInputStream(file); 
     
       InputStreamReader isr = new InputStreamReader(fis, "utf8"); 
     
       /*int r = isr.read(); 
     
       System.out.println((char)r);*/ 
     
       char[] cbuf = new char[2]; 
     
       int len = 0; 
     
       StringBuilder sb = new StringBuilder(); 
     
       while( (len=isr.read(cbuf)) != -1) { 
     
       sb.append(cbuf,0,len); 
     
       } 
     
       System.out.println(sb); 
     
       } 
     
      }

 
 BufferedReader/BufferedWriter 

 
 FileReader 提供的读取字符的方式效率稍低，如果高效读写字符的方式，可以使用BufferedReader/BufferedWriter。 

 
 BufferedReader 

 
 BufferedReader继承于Reader，专门用于高效的处理文本，提供了readLine方法用于一次读取一行文本。 

 
 把一首诗读取到控制台显示 

 
      package cn.sxt01.bufferedreader; 
     
      import java.io.BufferedReader; 
     
      import java.io.File; 
     
      import java.io.FileNotFoundException; 
     
      import java.io.FileReader; 
     
      import java.io.IOException; 
     
      public class Test01 { 
     
       public static void main(String[] args) throws FileNotFoundException,IOException { 
     
       File file = new File("d:\\javatest\\i.txt"); 
     
       // ctrl+t:查看类继承关系 
     
       FileReader reader = new FileReader(file); 
     
       BufferedReader br = new BufferedReader(reader); 
     
       // 一次读取一行 
     
       /* 
     
       String str = br.readLine(); 
     
       str = br.readLine(); 
     
       str = br.readLine(); 
     
       str = br.readLine(); 
     
       str = br.readLine(); 
     
       System.out.println(str); 
     
       */ 
     
       String line; 
     
       while( (line=br.readLine() ) != null) { 
     
       System.out.println(line); 
     
       } 
     
       br.close(); 
     
       reader.close(); 
     
       } 
     
      }

 
 BufferedWriter 

 
 BufferedWriter 是Writer的子类，专门用于高效的写入文本。提供了writer(String)和newLine()方法，写入完成后调用flush()刷新缓冲区。 

 
      package cn.sxt01.bufferedwriter; 
     
      import java.io.BufferedReader; 
     
      import java.io.BufferedWriter; 
     
      import java.io.File; 
     
      import java.io.FileNotFoundException; 
     
      import java.io.FileOutputStream; 
     
      import java.io.IOException; 
     
      import java.io.OutputStreamWriter; 
     
      public class Test01 { 
     
       public static void main(String[] args) throws FileNotFoundException,IOException { 
     
       // 需求：以utf8存入一首诗 
     
       File file = new File("d:\\javatest\\k.txt"); 
     
       FileOutputStream out = new FileOutputStream(file); 
     
       OutputStreamWriter osw = new OutputStreamWriter(out, "utf8"); 
     
       BufferedWriter bw = new BufferedWriter(osw); 
     
       bw.write("床前明月光，"); 
     
       bw.newLine(); 
     
       bw.write("疑似地上霜。"); 
     
       bw.newLine(); 
     
       bw.flush(); 
     
       bw.close(); 
     
       osw.close(); 
     
       out.close(); 
     
       } 
     
      }

 
 标准输入输出流 

 
 标准输入流 

 
 java中用System.in表示标准输入流，属于InputStream字节输入流，标准输入设备(源):鼠标、键盘、手写板、麦克风、触摸屏等。 

 
 需求:从键盘输入一个字符并打印出来。 

 
      package cn.sxt02.inout; 
     
      import java.io.IOException; 
     
      import java.io.InputStream; 
     
      public class Test01 { 
     
       public static void main(String[] args) throws IOException { 
     
       // 从控制台输入一个字符并打印 
     
       InputStream in = System.in; 
     
       // 【1】一次读取一个字节:（输入/数据源是键盘） 
     
       // int r = in.read(); 
     
       // System.out.println((char)r); 
     
       // 【2】一次读取多个字节 
     
       byte[] buf = new byte[1024]; 
     
       int len = 0; 
     
       len = in.read(buf); 
     
       // 默认控制台是gbk编码 
     
       String str = new String(buf, 0, len); 
     
       System.out.println(str);  
     
       } 
     
      }

 
 标准输出流 

 
 java中用System.out表示标准输出流，属于PrintStream。标准的输出设备(源):显示器、显示屏 

 
 需求:从文件中读取文件内容并显示在标准输出设备上。 

 
      package cn.sxt02.inout; 
     
      import java.io.File; 
     
      import java.io.FileInputStream; 
     
      import java.io.IOException; 
     
      import java.io.PrintStream; 
     
      public class Test02 { 
     
       public static void main(String[] args) throws IOException { 
     
       // 思考：为什么会乱码？ 
     
       File file = new java.io.File("d:\\javatest\\i.txt"); 
     
       FileInputStream fis = new FileInputStream(file); 
     
       // 标准输出流（gbk） 
     
       PrintStream ps = System.out; 
     
       int len = 0; 
     
       byte[] buf = new byte[2]; 
     
       while( (len=fis.read(buf)) != -1 ) { 
     
       ps.write(buf, 0, len); 
     
       } 
     
       fis.close(); 
     
       } 
     
      }

 
 通过打印流直接写入文件 

 
      package cn.sxt02.inout; 
     
      import java.io.File; 
     
      import java.io.FileNotFoundException; 
     
      import java.io.FileOutputStream; 
     
      import java.io.PrintStream; 
     
      import java.io.UnsupportedEncodingException; 
     
      public class Test05 { 
     
       public static void main(String[] args) throws FileNotFoundException, UnsupportedEncodingException { 
     
       // 通过打印流写入数据到一个文件(gbk) 
     
       /*File file = new File("d:\\javatest\\m.txt"); 
     
       PrintStream ps = new PrintStream(file); 
     
       ps.write('a'); 
     
       ps.write('b'); 
     
       ps.close();*/ 
     
       // 通过打印流写入一个utf8编码的文件 
     
       File file = new File("d:\\javatest\\m1.txt"); 
     
       PrintStream ps = new PrintStream(file,"utf8"); 
     
       ps.println("abc中国"); 
     
       ps.close(); 
     
       } 
     
      }

 
 需要flush的PrintStream 

 
      package cn.sxt02.inout; 
     
      import java.io.File; 
     
      import java.io.FileNotFoundException; 
     
      import java.io.FileOutputStream; 
     
      import java.io.PrintStream; 
     
      import java.io.UnsupportedEncodingException; 
     
      public class Test04 { 
     
       public static void main(String[] args) { 
     
       PrintStream ps = System.out; 
     
       ps.write('a'); 
     
       ps.write('b'); 
     
       ps.flush(); 
     
       } 
     
      }

 
 PrintStream称为打印字节流，继承于OutputStream，之前已经知道OutputStream写入文件时不需要flush。PrintStream的目的地是显示器，在PrintStream内部有个缓冲区，专门用于缓冲待输出的字节，结合显示器工作原理，当需要显示器显示待打印的字节时，需要手动调用flush方法，此时显示器才解码后显示。 

 
 测试自动刷新(C) 

 
      package cn.sxt02.inout; 
     
      import java.io.File; 
     
      import java.io.FileNotFoundException; 
     
      import java.io.FileOutputStream; 
     
      import java.io.IOException; 
     
      import java.io.PrintStream; 
     
      import java.io.UnsupportedEncodingException; 
     
      public class Test04 { 
     
       public static void main(String[] args) throws IOException { 
     
       PrintStream ps = System.out; 
     
       /*ps.write('a'); 
     
       ps.write('b');*/ 
     
       // 自动调用flush方法 
     
       /*byte[] buf = {'a','b'}; 
     
       ps.write(buf);*/ 
     
       // 自动调用flush方法 
     
       /*ps.write('a'); 
     
       ps.write('b'); 
     
       ps.write('\n');*/ 
     
       // 自动调用flush方法 
     
       ps.println("ab"); 
     
       // sps.flush(); 
     
       } 
     
      }

 
 字符打印流 

 
 PrintWriter 专门用于向自定目的地(显示器、文件、浏览器)中输出大量字符。继承于Writer。除了write(char)/write(char[] cbuf),还提供了特有的print/println方法用于输出各位数据类型的字符。 

 
      public class Test01 { 
     
       public static void main(String[] args) { 
     
       // 字符输出流 
     
       PrintWriter pw = new PrintWriter(System.out); 
     
       pw.println("hello"); 
     
       pw.println("中国"); 
     
       pw.flush(); 
     
       pw.close(); 
     
       } 
     
      }

 
 序列化 

 
 把(程序)内存中的数据保存到硬盘的过程就是序列化，也称为数据持久化。 

 
 当我们把硬盘中的数据再次读取到内存中时，这个过程就是反序列化。 

 
 Serializable接口 

 
 自定义类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化 

 
 需求:把一个对象序列化到d:\\javatest\\n1.txt 

 
      package cn.sxt04.serializable; 
     
      import java.io.File; 
     
      import java.io.FileOutputStream; 
     
      import java.io.IOException; 
     
      import java.io.ObjectOutputStream; 
     
      public class Test01 { 
     
       public static void main(String[] args) throws IOException { 
     
       User user = new User("001", "二狗", "123", 20); 
     
       /** 
     
       * 思路: 
     
       * 序列化:把对象个各个属性按照有规律的格式拼接成字符串，把字符串写入文件。 
     
       * 反序列化:把文件中的字符串读取为内存中，按序列化格式把字符串拆开得到很多属性值，然后初始化对象。 
     
       */ 
     
       // String info = user.getId()+"-"+user.getName()+"-"+user.getPwd()+"-"+user.getAge(); 
     
       // System.out.println(info); 
     
       File file = new File("d:\\javatest\\n1.sxt"); 
     
       FileOutputStream out = new FileOutputStream(file); 
     
       ObjectOutputStream oos = new ObjectOutputStream(out); 
     
       oos.writeObject(user); 
     
       oos.close(); 
     
       out.close(); 
     
       } 
     
      }

 
 需求：把刚在序列化的对象反序列化 

 
      package cn.sxt04.serializable; 
     
      import java.io.File; 
     
      import java.io.FileInputStream; 
     
      import java.io.FileOutputStream; 
     
      import java.io.IOException; 
     
      import java.io.ObjectInputStream; 
     
      import java.io.ObjectOutputStream; 
     
      public class Test02 { 
     
       public static void main(String[] args) throws IOException, ClassNotFoundException { 
     
       File file = new File("d:\\javatest\\n1.sxt"); 
     
       FileInputStream in = new FileInputStream(file); 
     
       ObjectInputStream ois = new ObjectInputStream(in); 
     
       User user = (User) ois.readObject(); 
     
       System.out.println(user); 
     
       } 
     
      }

 
 序列号 

 
 当程序在升级过程中对源代码进行修改，新代码对之前的序列化文件进行反序列化存在一个InvalidClassException异常 

 
      Exception in thread "main" java.io.InvalidClassException: cn.sxt04.serializable.User; local class incompatible: stream classdesc serialVersionUID = 4281284299154400224, local class serialVersionUID = 8687762707351138232 
     
       at java.io.ObjectStreamClass.initNonProxy(ObjectStreamClass.java:687) 
     
       at java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:1876) 
     
       at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1745) 
     
       at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:2033) 
     
       at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1567) 
     
       at java.io.ObjectInputStream.readObject(ObjectInputStream.java:427) 
     
       at cn.sxt04.serializable.Test02.main(Test02.java:19)

 
 如何解决？ 

 
 始终保持本地类和序列化中文件的类的版本号一致。 

 
 [1]默认版本号，永远是1L 

 
 [2]手动根据类的信息(属性、方法)生成一串数字。 

 
 版本号工作原理 

 
 如果自定义类没有添加任何序列化版本号，jvm自动添加一个序列化版本号，当修改源代码时，jvm自动升级该序列化版本号，此时导致和序列化到本地文件的类版本号不一致，反序列化必将失败，抛出InvalidClassException异常。 

 
 transient 关键字 

 
 在序列化过程中，存在一些字段序列化没有意义或一些敏感自动不许序列化，可以使用transient修饰。 

 
      public class User implements Serializable { 
     
       /** 
     
       * 
     
       */ 
     
       private static final long serialVersionUID = 1L; 
     
       private String id; 
     
       private String name; 
     
       private transient String pwd; 
     
       private int age; 
     
       private String phone;

 
 其他流 

 
 DataInputStream/DataOutputStream 

猜你喜欢