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.结果