Java学习：I/O流（2）

LineNumberReader

跟踪行号的缓冲字符输入流，父类为BufferedReader。

成员方法：

getLineNumber()
          获得当前行号。

setLineNumber(int lineNumber)
          设置当前行号。

练习代码如下：

//创建LineNumberReader对象
        //public LineNumberReader(Reader in)
        LineNumberReader lnr = new LineNumberReader(new FileReader("a.txt"));
        
        //默认起始行号从0开始
        //设置其实行号为从10开始
        lnr.setLineNumber(10);
        
        //一次读取一行
        String line;
        while ((line = lnr.readLine())!=null) {
            //打印每一行的行号和内容
            System.out.println(lnr.getLineNumber()+":"+line);
        }
        
        //关流
        lnr.close();

结果如下：

操作基本数据类型的流

DataInputStream:读数据

DataOutputStream:写数据

具体的方法见API

练习代码如下：

public static void main(String[] args) throws IOException {
        //写数据和读数据
        write();
        read();
    }

    private static void read() throws IOException {
        //DataInputStream:读数据
        //创建对象：public DataInputStream(InputStream in)
        DataInputStream dis = new DataInputStream(new FileInputStream("dos.txt"));
        
        //读数据了,按什么顺序写入就必须按照什么顺序读出来
        System.out.println(dis.readByte());
        System.out.println(dis.readShort());
        System.out.println(dis.readInt());
        System.out.println(dis.readLong());
        System.out.println(dis.readChar());
        System.out.println(dis.readFloat());
        System.out.println(dis.readDouble());
        System.out.println(dis.readBoolean());
        
        //关流
        dis.close();
    }

    private static void write() throws IOException {
        //public DataOutputStream(OutputStream out)
        DataOutputStream dos = new DataOutputStream(new FileOutputStream("dos.txt"));
        
        //给流关联的文件中写入基本类型的数据
        dos.writeByte(20);
        dos.writeShort(200);
        dos.writeInt(2000);
        dos.writeLong(20000L);
        
        dos.writeChar(97);
        dos.writeFloat(12.34F);
        dos.writeDouble(23.34);
        dos.writeBoolean(true);
        
        //关流
        dos.close();
    }

结果如下：

内存操作流

解决临时数据存储的问题。

操作字节数组

ByteArrayInputStream
ByteArrayOutputStream
byte[] toByteArray() 将之前写入内存的流转换成字节数组
操作字符数组
CharArrayReader
CharArrayWrite
操作字符串
StringReader
StringWriter

练习代码：

//给内存中写数据public ByteArrayOutputStream()
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        //给内存中调用方法写数据
        baos.write("hello".getBytes());
        //将写入内存中的数据读取出来
        byte[] buf = baos.toByteArray();//调用这个方法，将之前写入内存中的数据存储到字节数组中
        ByteArrayInputStream bais = new ByteArrayInputStream(buf);//将刚才存储到字节数组中的内容关联上bais
        
        //只有这样之后，我们才可以直接从bais中读取我们想要的内容
        //一次读取一个字节
        int by;
        while ((by=bais.read())!=-1) {
            System.out.print((char)by);
        }
        //关流
        bais.close();
        baos.close();

打印流

字节打印流  PrintStream

字符打印流  PrintWriter

特点：

A:只能操作目的地，不能操作数据源

B:可以操作任意类型的数据

C:如果启动了自动刷新，能够自动刷新

如果启用了自动刷新，则只有在调用 println、printf 或 format 的其中一个方法时才可能完成此操作

D:可以操作文件的流
注意：什么流可以直接操作文件？
看流对象的API,如果其构造方法同时有File和String类型的参数，就可以直接操作文件。

    //注意：如果已经开启了自动刷新功能，必须调用则 println、printf 或 format的时候，才可以实现自动刷新
        pw.println("hello");
        pw.println("java");
        pw.println("world");//调用println这个方法给文件中写数据，1.写数据  2.换行  3.刷新
        
        //可以操作任意类型的数据
        pw.println(true);
        pw.println(12.34);
        
        //关流
        pw.close();

合并流：

SequenceInputStream类可以将多个输入流串流在一起，合并为一个输入流，因此，该流也被称为合并流。

构造：
SequenceInputStream(InputStream s1, InputStream s2) ：将s1和s2合并成一个输入流，先读取s1后读取s2

联系代码如下：

//将两个数据源合而为一
        SequenceInputStream sis = new SequenceInputStream(new FileInputStream("PrintWriterDemo.java"), new FileInputStream("SystemIn2.java"));
        //封装目的地
        FileOutputStream fos = new FileOutputStream("copy2.java");
        
        //一下读写一个字节数组
        byte[] buf = new byte[1024];
        int len;
        while ((len=sis.read(buf))!=-1) {
            //读多少写多少
            fos.write(buf, 0, len);
        }
        
        //关流
        fos.close();
        sis.close();

对象的序列化和反序列化

序列化流：把对象按照流一样的方式写到文件或者在网络中传输。

反序列化流：把文件或者网络中的流对象数据还原对象。

ObjectOutputStream：序列化流
writeObject(Object obj) 将指定的对象写入 ObjectOutputStream。　　

ObjectInputStream：反序列化流
Object readObject() 从 ObjectInputStream 读取对象。

如何实现序列化？

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

注意：如果一个类不是实现Serializable接口无法把实例化，会报异常java.io.NotSerializableException

public class Studnet implements Serializable{
    //实现这个接口不需要实现任何方法，这个接口说白了就是仅仅给Student类，打上了一个可以被序列化的标示
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Studnet(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public Studnet() {
        super();
        // TODO Auto-generated constructor stub
    }
    @Override
    public String toString() {
        return "Studnet [name=" + name + ", age=" + age + "]";
    }

//创建序列化流对象
        //public ObjectOutputStream(OutputStream out)
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("oos.txt"));
        
        //创建一个学生对象，将学生对象写入文件中
        Studnet s = new Studnet("刘德华", 50);
        oos.writeObject(s);
        // java.io.NotSerializableException
        //类通过实现 java.io.Serializable 接口以启用其序列化功能
        
        //关流
        oos.close();

//创建反序列化流对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("oos.txt"));
        
        //读取文件中存储的对象，以实现反序列化
        //readObject()
        Object object = ois.readObject();
        System.out.println(object);
        
        //关流
        ois.close();