IO知识点整理（序列化，管道流，数据流，字节数组流，与编码）

一：序列化的问题

1.序列号的使用问题

　　关于在序列化中的序列号的使用问题，一般要是使用。

　　因为，每次要序列化的类产生都会产生一个一个新的序列号，如果将这个类的程序修改后，就会产生新的序列号，以前序列化后的文件将不会被读取。

　　所以，为了程序修改后，以前序列化后的程序仍然可以被读取，使用静态的序列号十分有必要。

2.将数据进行序列化

　　中在ObjectOutputStream类。

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

 public class Test114 {

     public static void main(String[] args)  throws Exception{
         writeObj();
     }
     public static void writeObj() throws Exception{
         ObjectOutputStream objo=new ObjectOutputStream(
                 new FileOutputStream("op.txt"));
         objo.writeObject(new People0("lisi",10));
         objo.close();
     }
 }

 class People0 implements Serializable{
     //序列号
     public static final long serialVersionUID = 42L;
     //属性
     private String name;
     private int age;
     public People0(String name,int age){
         this.name=name;
         this.age=age;
     }
     public String toString() {
         return name+":"+age;
     }
 }

3.运行结果

　　

4.读序列化后的文件

 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.ObjectInputStream;
 import java.io.ObjectOutputStream;
 import java.io.Serializable;

 public class Test114 {

     public static void main(String[] args)  throws Exception{
         //writeObj();
         readObj();
     }
     public static void readObj() throws Exception{
         ObjectInputStream readObj=new ObjectInputStream(
                 new FileInputStream("op.txt"));
         People0 p=(People0)readObj.readObject();
         //因为有toString方法，所以可以直接打印
         System.out.println(p);
         //
         readObj.close();
     }
     public static void writeObj() throws Exception{
         ObjectOutputStream objo=new ObjectOutputStream(
                 new FileOutputStream("op.txt"));
         objo.writeObject(new People0("lisi",10));
         objo.close();
     }
 }

 class People0 implements Serializable{
     //序列号
     public static final long serialVersionUID = 42L;
     //属性
     private String name;
     private int age;
     public People0(String name,int age){
         this.name=name;
         this.age=age;
     }
     public String toString() {
         return name+":"+age;
     }
 }

5.运行结果

　　

6.不能序列化的情况

　　类中的static不能够序列化，因为static的属性在方法区，而序列化主要是序列化的是栈里的文件数据。

　　同时transient修饰的属性不能够序列化。

7.不能序列化的程序演示

 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.ObjectInputStream;
 import java.io.ObjectOutputStream;
 import java.io.Serializable;

 public class Test114 {

     public static void main(String[] args)  throws Exception{
         //writeObj();
         readObj();
     }
     public static void readObj() throws Exception{
         ObjectInputStream readObj=new ObjectInputStream(
                 new FileInputStream("op.txt"));
         People0 p=(People0)readObj.readObject();
         //因为有toString方法，所以可以直接打印
         System.out.println(p);
         //
         readObj.close();
     }
     public static void writeObj() throws Exception{
         ObjectOutputStream objo=new ObjectOutputStream(
                 new FileOutputStream("op.txt"));
         objo.writeObject(new People0("lisi",10,"usa"));
         objo.close();
     }
 }

 class People0 implements Serializable{
     //序列号
     public static final long serialVersionUID = 42L;
     //属性
     private String name;
     //添加transient的修饰
     private transient int age;
     //新加static
     private static String contry="cn";
     public People0(String name,int age,String contry){
         this.name=name;
         this.age=age;
         this.contry=contry;
     }
     public String toString() {
         return name+":"+age+":"+contry;
     }
 }

8.运行结果

　　运行的顺序是，先序列化，序列化后生成新的文件后，再进行反序列化。

　　这时，才会发现static与transient都没有被序列化。

　　

二：管道流与RandomAccessFile

1.管道流

　　可以将读写进行相连。

　　管道输入流应该连接到管道输出流；管道输入流提供要写入管道输出流的所有数据字节。

　　通常，数据由某个线程从 PipedInputStream 对象读取，并由其他线程将其写入到相应的 PipedOutputStream。

　　不建议对这两个对象尝试使用单个线程，因为这样可能死锁线程。

2.管道流程序（多线程）

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

 public class Test115 {

     public static void main(String[] args) throws Exception {
         PipedInputStream in=new PipedInputStream();
         PipedOutputStream out=new PipedOutputStream();
         in.connect(out);    //链接connect

         Writer w=new Writer(out);
         Reader r=new Reader(in);
         new Thread(w).start();
         new Thread(r).start();
     }

 }
 class Writer implements Runnable{
     private PipedOutputStream out;
     public Writer(PipedOutputStream out){
         this.out=out;
     }
     public void run(){
         try{
             Thread.sleep(5000);
             out.write("sjhdbs".getBytes());
             out.close();
         }catch(Exception e){
             e.toString();
         }
     }
 }
 class Reader implements Runnable{
     private PipedInputStream in;
     public Reader(PipedInputStream in){
         this.in=in;
     }
     public void run(){
         try{
             byte[] buf=new byte[1024];
             int len=in.read(buf);
             String str=new String(buf,0,len);
             System.out.println("str="+str);
             in.close();
         }catch(Exception e){
             e.toString();
         }
     }
 }

3.运行结果

　　

4.RandomAccessFile

　　该类不是算是IO体系中子类。
　　而是直接继承自Object。
　　但是它是IO包中成员。因为它具备读和写功能。
　　内部封装了一个数组，而且通过指针对数组的元素进行操作。
　　可以通过getFilePointer获取指针位置，
　　同时可以通过seek改变指针的位置。　　

　　通过构造函数可以看出，该类只能操作文件。
　　而且操作文件还有模式：只读r，，读写rw等。

5.写入程序

　　在程序中使用writeInt，这个方法是每次写入4个字节，如果使用write则是每次写入1个字节。

　　考虑到数字的越界，这里使用writeInt方法。

　　这个方法的写方式在下面的程序中没有什么特殊的地方。

 import java.io.FileNotFoundException;
 import java.io.RandomAccessFile;

 public class Test116 {
     public static void main(String[] args) throws Exception{
         randomWrite();
     }
     /**
      * 简单的写入
      * @throws Exception
      */
     public static void randomWrite() throws Exception{
         RandomAccessFile raf=new RandomAccessFile("pu.txt","rw");
         raf.write("张三".getBytes());
         raf.writeInt(97);
         raf.write("李四".getBytes());
         raf.writeInt(20);
         raf.close();
     }
 }

6.结果　　

　　

7.分别使用seek与skipBytes的读方式（待探求为啥读取有问题）

 import java.io.FileNotFoundException;
 import java.io.RandomAccessFile;

 public class Test117 {

     public static void main(String[] args) throws Exception{
         System.out.println("seek function");
         randomReadSeek();
         System.out.println("skipBytes function");
         randomReadSkipbytes();
     }
     /**
      * seek function
      * @throws Exception
      */
     public static void randomReadSeek() throws Exception{
         RandomAccessFile raf=new RandomAccessFile("pu.txt", "r");
         raf.seek(0);
         byte[] buf = new byte[8];

         raf.read(buf);

         String name = new String(buf);

         int age = raf.readInt();

         System.out.println("name="+name);
         System.out.println("age="+age);

         raf.close();
     }
     public static void randomReadSkipbytes()throws Exception{
         RandomAccessFile raf=new RandomAccessFile("pu.txt", "r");
         raf.skipBytes(2);
         byte[] buf = new byte[8];

         raf.read(buf);

         String name = new String(buf);

         int age = raf.readInt();

         System.out.println("name="+name);
         System.out.println("age="+age);

         raf.close();
     }

 }

三：数据流对象的操作

1.关于DataInputStream与DataOutputStream的介绍

　　其主要是将数据与流进行结合。

　　

2.写数据程序

 import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;

 public class Test118 {

     public static void main(String[] args) throws Exception {
         dataWrite();

     }
     public static void dataWrite()throws Exception{
         DataOutputStream dos=new DataOutputStream(new FileOutputStream("data.txt"));
         dos.writeInt(78);
         dos.writeBoolean(true);
         dos.writeDouble(89.90907);
         dos.close();
     }
 }

3.读的程序

　　注意点是，读取数据的时候，必须与写的数据类型相对应，保持读写的一致性。

 import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;

 public class Test118 {

     public static void main(String[] args) throws Exception {
         //dataWrite();
         dataRead();
     }
     public static void dataRead() throws Exception{
         DataInputStream dis=new DataInputStream(new FileInputStream("data.txt"));
         int num=dis.readInt();
         boolean state=dis.readBoolean();
         double twonum=dis.readDouble();
         System.out.println("num="+num+",state="+state+",twonum="+twonum);
     }
     public static void dataWrite()throws Exception{
         DataOutputStream dos=new DataOutputStream(new FileOutputStream("data.txt"));
         dos.writeInt(78);
         dos.writeBoolean(true);
         dos.writeDouble(89.90907);
         dos.close();
     }
 }

4.运行结果

　　

5.关于DataInputStream中的writeUIF的特殊性（包含readUIF）

　　

　　所以在下面，通过程序进行验证。

6.带编码的可以读写字串的程序

 import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;

 public class Test119 {

     public static void main(String[] args)throws Exception {
         writeUtf();
         readUtf();
     }
     public static void writeUtf()throws Exception{
         DataOutputStream dos=new DataOutputStream(new FileOutputStream("string.txt"));
         dos.writeUTF("shdfcsdcnklbsnkl");
         dos.close();
     }
     public static void readUtf()throws Exception{
         DataInputStream dis=new DataInputStream(new FileInputStream("String.txt"));
         String str=dis.readUTF();
         System.out.println("str="+str);
     }

 }

7.运行结果

　　

8.使用FileOutputStream的编码方式对字符串的读写

 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.OutputStream;
 import java.io.OutputStreamWriter;
 import java.io.UnsupportedEncodingException;

 public class Test120 {
     public static void main(String[] args) throws Exception{
         OutputStreamWriter fos=new OutputStreamWriter(new FileOutputStream("gnk.txt"),"gbk");
         fos.write("你好");
         fos.close();
     }
 }

9.结果

　　

四：字节数组流的操作

1.程序

 /*
 用于操作字节数组的流对象。

 ByteArrayInputStream ：在构造的时候，需要接收数据源，。而且数据源是一个字节数组。

 ByteArrayOutputStream： 在构造的时候，不用定义数据目的，因为该对象中已经内部封装了可变长度的字节数组。
 这就是数据目的地。
 因为这两个流对象都操作的数组，并没有使用系统资源。
 所以，不用进行close关闭。
 在流操作规律讲解时：
 源设备，
     键盘 System.in，硬盘 FileStream，内存 ArrayStream。
 目的设备：
     控制台 System.out，硬盘FileStream，内存 ArrayStream。
 用流的读写思想来操作数据。
 */
 import java.io.*;
 class ByteArrayStream
 {
     public static void main(String[] args)
     {
         //数据源。
         ByteArrayInputStream bis = new ByteArrayInputStream("ABCDEFD".getBytes());
         //数据目的
         ByteArrayOutputStream bos = new ByteArrayOutputStream();

         int by = 0;

         while((by=bis.read())!=-1)
         {
             bos.write(by);
         }
         System.out.println(bos.size());
         System.out.println(bos.toString());
     }
 }

五：编码

1.介绍

　　编码：将字符串变成字节数组

　　解码：将字节数组变成字符串

　　String-->byte[]; str.getBytes(charsetName);
　　byte[] -->String: new String(byte[],charsetName);

2.程序

 import java.util.Arrays;

 public class Test121 {
     public static void main(String[] args)throws Exception {
         String str="嘿嘿";
         byte[] buf1=str.getBytes("utf-8");
         //打印字节码
         System.out.println(Arrays.toString(buf1));
         //utf-8解码
         String s1=new String(buf1,"gbk");
         System.out.println("s1="+s1);
         //再使用utf-8编码
         byte[] buf2=s1.getBytes("gbk");
         System.out.println(Arrays.toString(buf2));
         //打印
         String s2=new String(buf2,"utf-8");
         System.out.println("s2="+s2);
     }
 }

3.结果