JavaSE学习笔记（二十九）—— 其它流

一、操作基本数据类型的流

　　数据输入流：DataInputStream

DataInputStream(InputStream in)

　　数据输出流：DataOutputStream

DataOutputStream(OutputStream out) 

　　数据输出流允许应用程序以适当方式将基本 Java 数据类型写入输出流中。然后，应用程序可以使用数据输入流将数据读入。

public class DataStreamDemo {
    public static void main(String[] args) throws IOException {
        // 写
        // write();

        // 读
        read();
    }

    private static void read() throws IOException {
        // DataInputStream(InputStream in)
        // 创建数据输入流对象
        DataInputStream dis = new DataInputStream(new FileInputStream("dos.txt"));

        // 读数据
        byte b = dis.readByte();
        short s = dis.readShort();
        int i = dis.readInt();
        long l = dis.readLong();
        float f = dis.readFloat();
        double d = dis.readDouble();
        char c = dis.readChar();
        boolean bb = dis.readBoolean();

        // 释放资源
        dis.close();

        System.out.println(b);
        System.out.println(s);
        System.out.println(i);
        System.out.println(l);
        System.out.println(f);
        System.out.println(d);
        System.out.println(c);
        System.out.println(bb);
    }

    private static void write() throws IOException {
        // DataOutputStream(OutputStream out)
        // 创建数据输出流对象
        DataOutputStream dos = new DataOutputStream(new FileOutputStream("dos.txt"));

        // 写数据
        dos.writeByte(10);
        dos.writeShort(100);
        dos.writeInt(1000);
        dos.writeLong(10000);
        dos.writeFloat(12.34F);
        dos.writeDouble(12.56);
        dos.writeChar('a');
        dos.writeBoolean(true);

        // 释放资源
        dos.close();
    }
}

二、内存操作流

　　内存操作流一般用于处理临时信息，因为临时信息不需要保存，程序结束，数据就从内存中消失。

　　如果我们操作完毕后，未必需要产生一个文件，就可以使用内存操作流。

【字节数组】

• ByteArrayInputStream
• ByteArrayOutputStream

【字符数组】

• CharArrayReader
• CharArrayWriter

【字符串】

• StringReader
• StringWriter

public class ByteArrayStreamDemo {
    public static void main(String[] args) throws IOException {
        // 写数据
        // ByteArrayOutputStream()
        ByteArrayOutputStream baos = new ByteArrayOutputStream();

        for (int x = 0; x < 10; x++) {
            baos.write(("hello" + x).getBytes());
        }

        // 释放资源
        // 通过查看源码我们知道这里什么都没做，所以根本需要close()
        // baos.close();

        // public byte[] toByteArray()
        byte[] bys = baos.toByteArray();

        // 读数据
        // ByteArrayInputStream(byte[] buf)
        ByteArrayInputStream bais = new ByteArrayInputStream(bys);

        int by = 0;
        while ((by = bais.read()) != -1) {
            System.out.print((char) by);
        }
    }
}

三、打印流

【打印流概述】

• 字节流打印流：PrintStream
• 字符打印流：PrintWriter(重点)

【打印流的特点】

1. 只有写数据的，没有读取数据。只能操作目的地，不能操作数据源。
2. 可以操作任意类型的数据。

   pw.println("hello");
   pw.println(true);
   pw.println(100);

3. 如果启动了自动刷新，能够自动刷新。

   PrintWriter pw = new PrintWriter(new FileWriter("pw2.txt"), true);
   这时应该调用println()的方法才可以实现自动刷新，调用print()不行。
   而且这个时候不仅仅自动刷新了，还实现了数据的换行。
   println()其实等价于于：
       bw.write();
       bw.newLine();
       bw.flush();

4. 可以直接操作文本文件

   流分为基本流和高级流
   　　基本流：就是能够直接读写文件的
   　　高级流：在基本流基础上提供了一些其他的功能
   哪些流对象是可以直接操作文本文件的呢？看API,查流对象的构造方法，如果同时有File类型和String类型的参数，一般来说就是可以直接操作文件的。
   　　FileInputStream
   　　FileOutputStream
   　　FileReader
   　　FileWriter
   　　PrintStream
   　　PrintWriter

　　下面通过一个简单的PrintWriter案例来进行展示：

public class PrintWriterDemo {
    public static void main(String[] args) throws IOException {
        // 创建打印流对象
        // PrintWriter pw = new PrintWriter("pw.txt");
        // 开启自动刷新
        PrintWriter pw = new PrintWriter(new FileWriter("pw.txt"), true);

        // write只能操作字符串
        /*pw.write("hello");
        pw.write("world");
        pw.write("java");*/

        // 要操作任意类型的数据,要使用print()或println()
        /*pw.print(true);
        pw.print(100);
        pw.print("hello");*/
        // 使用print()操作数据后,如果没有调用close(),数据是不会自动刷新的

        // 使用println(),并且使用public PrintWriter(Writer out,boolean autoFlush)构造方法后,就能使用自动刷新了,即使不调用close(),数据也能写入到文件
        // 此时的println()相当于write()+newLine()+flush()三个方法的综合
        pw.println(true);
        pw.println(100);
        pw.println("hello");

        // pw.close();
    }
}

【打印流复制文本文件】

/**
 * 需求：PrintWriterDemo.java复制到Copy.java中
 * 数据源：
 *         DataStreamDemo.java -- 读取数据 -- FileReader -- BufferedReader
 * 目的地：
 *         Copy.java -- 写出数据 -- FileWriter -- BufferedWriter -- PrintWriter
 */
public class CopyFileDemo {
    public static void main(String[] args) throws IOException {
        // 以前的版本
        /*BufferedReader br = new BufferedReader(new FileReader("PrintWriterDemo.java"));
        // 封装目的地
        BufferedWriter bw = new BufferedWriter(new FileWriter("Copy.java"));

        String line = null;
        while ((line = br.readLine()) != null) {
            bw.write(line);
            bw.newLine();
            bw.flush();
        }

        bw.close();
        br.close();*/

        // 打印流的改进版
        // 封装数据源
        BufferedReader br = new BufferedReader(new FileReader("PrintWriterDemo.java"));
        // 封装目的地
        PrintWriter pw = new PrintWriter(new FileWriter("Copy.java"), true);

        String line = null;
        while ((line = br.readLine()) != null) {
            pw.println(line);
        }

        pw.close();
        br.close();
    }
}

四、标准输入输出流

 　　System类中的两个成员变量：

• public static final InputStream in　　 “标准”输入流。
• public static final PrintStream out      “标准”输出流。

4.1 System.out

　　public static final PrintStream out “标准”输出流。

　　可以得知：PrintStream ps = System.out;

public class SystemOutDemo {
    public static void main(String[] args) {
        // 有这里的讲解我们就知道了，这个输出语句其本质是IO流操作，把数据输出到控制台。
        System.out.println("helloworld");

        // 获取标准输出流对象
        PrintStream ps = System.out;
        ps.println("helloworld");

        ps.println();
        // ps.print();//这个方法不存在

        System.out.println();
        // System.out.print();//这是错误的
    }
}

【转换流的应用】

public class SystemOutDemo2 {
    public static void main(String[] args) throws IOException {
        // 获取标准输出流
        // PrintStream ps = System.out;
        // OutputStream os = ps;
        // OutputStream os = System.out;//多态
        // 我能不能按照刚才使用标准输入流的方式一样把数据输出到控制台呢？
        // OutputStreamWriter osw = new OutputStreamWriter(os);
        // BufferedWriter bw = new BufferedWriter(osw);
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));

        bw.write("hello");
        bw.newLine();

        bw.write("world");
        bw.newLine();

        bw.write("java");
        bw.newLine();
        bw.flush();

        bw.close();
    }
}

4.2 System.in

　　System.in 标准输入流。是从键盘获取数据的　

　　通过public static final InputStream in，可知InputStream is = System.in

【键盘录入数据】

　　前面我们已经学习了两种键盘录入数据的方式：

1. main方法的args接收参数。

   java HelloWorld hello world java

2. Scanner(JDK5以后的)

   Scanner sc = new Scanner(System.in);
   String s = sc.nextLine();
   int x = sc.nextInt()

　　今天我们再来学习一种方式：通过字符缓冲流包装标准输入流实现。

　　获取标准输入流的方式是：InputStream is = System.in;

　　我要怎么实现一次获取一行数据呢?首先你得知道一次读取一行数据的方法是哪个呢？readLine()

　　而这个方法在哪个类中呢?BufferedReader

　　所以，你这次应该创建BufferedReader的对象，但是底层还是的使用标准输入流BufferedReader br = new BufferedReader(is);

　　按照我们的推想，现在应该可以了，但是却报错了。原因是：字符缓冲流只能针对字符流操作，而你现在是字节流，所以就会报错。

　　那么，我还就想使用了，怎么办呢？

　　可以把字节流转换为字符流，然后在通过字符缓冲流操作

　　InputStreamReader isr = new InputStreamReader(is);

       BufferedReader br= new BufferedReader(isr);

public class SystemInDemo {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        System.out.println("请输入一个字符串：");
        String line = br.readLine();
        System.out.println("你输入的字符串是：" + line);

        System.out.println("请输入一个整数：");
        line = br.readLine();
        int i = Integer.parseInt(line);
        System.out.println("你输入的整数是：" + i);
    }
}

五、随机访问流

　　随机访问流：RandomAccessFile类不属于流，是Object类的子类。但它融合了InputStream和OutputStream的功能。支持对文件的随机访问读取和写入。

　　public RandomAccessFile(String name,String mode)：第一个参数是文件路径，第二个参数是操作文件的模式。模式有四种，我们最常用的一种叫"rw",这种方式表示我既可以写数据，也可以读取数据

public class RandomAccessFileDemo {
    public static void main(String[] args) throws IOException {
        // write();
        read();
    }

    private static void read() throws IOException {
        // 创建随机访问流对象
        RandomAccessFile raf = new RandomAccessFile("raf.txt", "rw");

        int i = raf.readInt();
        System.out.println(i);
        // 该文件指针可以通过 getFilePointer方法读取，并通过 seek 方法设置。
        System.out.println("当前文件的指针位置是：" + raf.getFilePointer());

        char ch = raf.readChar();
        System.out.println(ch);
        System.out.println("当前文件的指针位置是：" + raf.getFilePointer());

        String s = raf.readUTF();
        System.out.println(s);
        System.out.println("当前文件的指针位置是：" + raf.getFilePointer());

        // 我不想重头开始了，我就要读取a，怎么办呢?
        raf.seek(4);
        ch = raf.readChar();
        System.out.println(ch);
    }

    private static void write() throws IOException {
        // 创建随机访问流对象
        RandomAccessFile raf = new RandomAccessFile("raf.txt", "rw");

        // 怎么玩呢?
        raf.writeInt(100);
        raf.writeChar('a');
        raf.writeUTF("中国");

        raf.close();
    }
}

六、合并流

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

　　SequenceInputStream(InputStream s1, InputStream s2)

/*
 * 以前的操作：
 * a.txt -- b.txt
 * c.txt -- d.txt
 * 
 * 现在想要：
 * a.txt+b.txt -- c.txt
 */
public class SequenceInputStreamDemo {
    public static void main(String[] args) throws IOException {
        // SequenceInputStream(InputStream s1, InputStream s2)
        // 需求：把ByteArrayStreamDemo.java和DataStreamDemo.java的内容复制到Copy.java中
        InputStream s1 = new FileInputStream("ByteArrayStreamDemo.java");
        InputStream s2 = new FileInputStream("DataStreamDemo.java");
        SequenceInputStream sis = new SequenceInputStream(s1, s2);
        BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream("Copy.java"));

        // 如何写读写呢，其实很简单，你就按照以前怎么读写，现在还是怎么读写
        byte[] bys = new byte[1024];
        int len = 0;
        while ((len = sis.read(bys)) != -1) {
            bos.write(bys, 0, len);
        }

        bos.close();
        sis.close();
    }
}

　　SequenceInputStream(Enumeration<? extends InputStream> e)

/*
 * 以前的操作：
 * a.txt -- b.txt
 * c.txt -- d.txt
 * e.txt -- f.txt
 * 
 * 现在想要：
 * a.txt+b.txt+c.txt -- d.txt
 */
public class SequenceInputStreamDemo2 {
    public static void main(String[] args) throws IOException {
        // 需求：把下面的三个文件的内容复制到Copy.java中
        // ByteArrayStreamDemo.java,CopyFileDemo.java,DataStreamDemo.java

        // SequenceInputStream(Enumeration e)
        // 通过简单的回顾我们知道了Enumeration是Vector中的一个方法的返回值类型。
        // Enumeration<E> elements()
        Vector<InputStream> v = new Vector<InputStream>();
        InputStream s1 = new FileInputStream("ByteArrayStreamDemo.java");
        InputStream s2 = new FileInputStream("CopyFileDemo.java");
        InputStream s3 = new FileInputStream("DataStreamDemo.java");
        v.add(s1);
        v.add(s2);
        v.add(s3);
        Enumeration<InputStream> en = v.elements();
        SequenceInputStream sis = new SequenceInputStream(en);
        BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream("Copy.java"));

        // 如何写读写呢，其实很简单，你就按照以前怎么读写，现在还是怎么读写
        byte[] bys = new byte[1024];
        int len = 0;
        while ((len = sis.read(bys)) != -1) {
            bos.write(bys, 0, len);
        }

        bos.close();
        sis.close();
    }
}

七、序列化流

• 序列化流：把对象按照流一样的方式存入文本文件或者在网络中传输。对象 → 流数据(ObjectOutputStream)
• 反序列化流:把文本文件中的流对象数据或者网络中的流对象数据还原成对象。流数据 → 对象(ObjectInputStream)

　　由于我们要对对象进行序列化，所以我们先自定义一个Person类，该类必须要实现 java.io.Serializable 接口以启用其序列化功能（该接口居然没有任何方法，类似于这种没有方法的接口被称为标记接口）。未实现此接口的类将无法使其任何状态序列化或反序列化，并且报NotSerializableException:未序列化异常。

public class Person implements Serializable {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = 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;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

　　编写测试类

public class ObjectStreamDemo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        // 序列化数据其实就是把对象写到文本文件
        // write();

        read();
    }

    private static void read() throws IOException, ClassNotFoundException {
        // 创建反序列化对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("oos.txt"));

        // 还原对象
        Object object = ois.readObject();

        // 释放资源
        ois.close();

        // 输出对象
        System.out.println(object);
    }

    private static void write() throws IOException {
        // 创建序列化流对象
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("oos.txt"));

        // 创建对象
        Person person = new Person("林青霞", 27);

        // public final void writeObject(Object obj)
        oos.writeObject(person);

        // 释放资源
        oos.close();
    }
}

　　依次运行write()和read()方法，即可输出对象内容：

　　这时候，简单修改Person类的内容，比如将age的private修饰符去掉：

public class Person implements Serializable {
    private String name;
    int age;

    ...
} 

　　这时候再测试ObjectStreamDemo，却发现程序报错了：

　　Exception in thread "main" java.io.InvalidClassException:

　　day16.Person; local class incompatible: stream classdesc serialVersionUID = -1292889811426758397,

　　local class serialVersionUID = -26945631235202424

　　为什么会有问题呢?

　　Person类实现了序列化接口，那么它本身也应该有一个标记值。这个标记值假设是100。

　　开始的时候：

　　　　Person.class -- id=100

　　　　wirte数据： oos.txt -- id=100

　　　　read数据: oos.txt -- id=100

　　在我们修改完Person类的内容后：

　　　　Person.class -- id=200

　　　　wirte数据： oos.txt -- id=100

　　　　read数据: oos.txt -- id=100

　　此时write/read数据的id和Person.class的id不一致，所以就会报以上错误。

　　可是，我们在实际开发中，可能还需要使用以前写过的数据，不能重新写入。怎么办呢?

　　回想一下原因是因为它们的id值不匹配。每次修改java文件的内容的时候,class文件的id值都会发生改变。而读取文件的时候，会和class文件中的id值进行匹配。所以，就会出问题。

　　但是呢，如果我有办法，让这个id值在java文件中是一个固定的值，这样，你修改文件的时候，这个id值还会发生改变吗?

　　不会。现在的关键是我如何能够知道这个id值如何表示的呢?

　　不用担心，你不用记住，也没关系，只需自动生成即可。

　　

　　这样就能自动生成一个序列化的id值了，而且产生这个值以后，我们对类进行任何改动，它读取以前的数据是没有问题的。

　　

　　注意：

　　我一个类中可能有很多的成员变量，有些我不想进行序列化。请问该怎么办呢?

　　这时候可以使用transient关键字声明不需要序列化的成员变量。

　　

　　这时候再去读取数据时，被transient声明的成员变量就使用的是默认值了：