Java I/O流 04

Posted 2021-02-28 zhaochuming

I/O流·其他流

序列流

* A：什么是序列流
　　* 序列流可以把多个字节输入流整合成一个，从序列流中读取数据时，将从被整合的第一个流开始，读完后再读下一个

* B：使用方式
　　* 整合两个：SequenceInputStream(InputStream, InputStream)
　　* 整合多个：SequenceInputStream(Enumeration)

package com.heima.otherio;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.SequenceInputStream;
import java.util.Enumeration;
import java.util.Vector;

public class Demo1_SequenceInputStream {

    public static void main(String[] args) throws IOException {
        // demo1(); // 不用序列流的方法
        // demo2(); // 整合两个输入流
        // demo3(); // 整合多个输入流
    }

    public static void demo3() throws FileNotFoundException, IOException {
        FileInputStream fis1 = new FileInputStream("a.txt"); // 创建字节输入流
        FileInputStream fis2 = new FileInputStream("b.txt");
        FileInputStream fis3 = new FileInputStream("c.txt");

        Vector<FileInputStream> v = new Vector<FileInputStream>(); // 创建泛型为字节输入流的集合对象
        v.add(fis1); // 将流对象添加到集合内
        v.add(fis2);
        v.add(fis3);
 
        Enumeration<FileInputStream> e = v.elements(); // 根据Vector集合，创建泛型为字节输入流的枚举对象
        SequenceInputStream sis = new SequenceInputStream(e); // 将枚举中的输入流整合成一个
        FileOutputStream fos = new FileOutputStream("d.txt"); // 创建字节输出流
        
        int c;
        while ((c = sis.read()) != -1) { // 从序列流中读取数据
            fos.write(c);
        }
        sis.close(); // 关闭序列流
        fos.close();
    }

    public static void demo2() throws FileNotFoundException, IOException {
        FileInputStream fis1 = new FileInputStream("a.txt"); // 创建字节输入流1
        FileInputStream fis2 = new FileInputStream("b.txt"); // 创建字节输入流2
        SequenceInputStream sis = new SequenceInputStream(fis1, fis2); // 基于两个字节输入流，创建序列流
        FileOutputStream fos = new FileOutputStream("c.txt"); // 创建字节输出流

        int b;
        while ((b = sis.read()) != -1) { // 从序列流读取数据
            fos.write(b);
        }
        sis.close(); // sis在关闭的时候会将构造方法中的流对象也都关闭
        fos.close();
    }

    public static void demo1() throws FileNotFoundException, IOException {
        FileInputStream fis1 = new FileInputStream("a.txt"); // 创建字节输入流，关联a.txt
        FileOutputStream fos = new FileOutputStream("c.txt"); // 创建字节输出流，关联b.txt
        
        int c;
        while ((c = fis1.read()) != -1) { // 不断地在a.txt上读取字节
            fos.write(c); // 将读到的字节写到c.txt上
        }
        fis1.close(); // 关闭字节输入流1

        FileInputStream fis2 = new FileInputStream("b.txt"); // 创建字节输入流，关联c.txt
        while ((c = fis2.read()) != -1) { // 不断地在b.txt上读取字节
            fos.write(c); // 将读到的字节写到c.txt上
        }

        fis2.close(); // 关闭字节输入流2
        fos.close(); // 关闭字节输出流
    }
}

SequenceInputStream

 

 

内存输出流

* A：什么是内存输出流
　　* 该输出流可以向内存中写数据，把内存当作一个缓冲区，写出之后可以一次性获取所有数据

* B：使用方法
　　* 创建对象：new ByteArrayOutputStream()
　　* 写出数据：write(int), write(byte[ ] )
　　* 获取数据：toByteArray()

package com.heima.otherio;

import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class Demo2_ByteArrayOutputStream {

    public static void main(String[] args) throws IOException {
        // demo1();
        // demo2();
    }

    public static void demo2() throws FileNotFoundException, IOException {
        FileInputStream fis = new FileInputStream("e.txt");
        ByteArrayOutputStream baos = new ByteArrayOutputStream(); // 在内存中创建了可以增长的内存数组

        int b;
        while ((b = fis.read()) != -1) {
            baos.write(b); // 将读取到的数据逐个写到内存中
        }

        byte[] arr = baos.toByteArray(); // 将缓冲区的数据全部或取出来，并赋值给arr数组
        System.out.println(new String(arr));

        System.out.println(baos.toString()); // 将缓冲区中的内容转换为字符串，使用平台默认的码表转换
        fis.close();
        // baos.close(); // 内存流不需要关，没有关的意义
    }

    public static void demo1() throws FileNotFoundException, IOException {
        FileInputStream fis = new FileInputStream("e.txt");
        byte[] arr = new byte[4];

        int len;
        while ((len = fis.read(arr)) != -1) {
            System.out.println(new String(arr, 0, len));
        }
        fis.close();
    }
}

ByteArrayOutputStream

 

 

面试题

* 定义一个文件输入流，调用read(byte[ ] b)方法，将 a.txt文件中的内容打印出来（byte数组大小限制为5）

package com.heima.test;

import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class Test1 {
    /*
     * 分析：
     * 1、read(byte[] b)是字节输入流的方法，因此需要创建FileInputStream，关联a.txt
     * 2、创建字节数组，长度为5
     * 3、创建内存输出流，将读到的数组写到内存输出流中
     * 4、将内存输出流的数据全部转换为字符串打印
     * 5、关闭输入流
     */
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("a.txt"); // 创建字节输入流，关联a.txt
        ByteArrayOutputStream baos = new ByteArrayOutputStream(); // 创建内存流
        
        byte[] arr = new byte[5];
        int len;
        while ((len = fis.read(arr)) != -1) { // 通过长度为5的数组读取数据
            baos.write(arr, 0, len); // 将数据写入内存中
        }
        
        System.out.println(baos); // 将内存中的内容以字符串的形式打印
        fis.close(); // 关闭字节流
    }
}

Test1

 

 

对象操作流ObjectOutputStream

* A：什么是对象操作流
　　* 该流可以将一个对象写出，或者读取一个对象到程序中，也就是执行了序列化和反序列化的操作
　　* 对象需要实现序列化接口，可以可选择的重写ID号，类似于软件的版本号

* B：使用方法
　　* 写出：new ObjectOutputStream(OutputStream), writeObject()

package com.heima.bean;

import java.io.Serializable;

public class Person implements Serializable{

    /**
     * 对象必须实现 可序列化接口
     */
    private static final long serialVersionUID = 2L;
    private String name;
    private int age;
    private String gender;
    public Person() {
        super();
        
    }
    public Person(String name, int age) {
        super();
        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 + "]";
    }
    
}

Person类

package com.heima.otherio;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.ArrayList;

import com.heima.bean.Person;

public class Demo3_ObjectOutputStream {

    public static void main(String[] args) throws IOException, IOException {
        // demo1();
        // demo2();
    }

    public static void demo2() throws IOException, FileNotFoundException {
        Person p1 = new Person("张三", 23);
        Person p2 = new Person("李四", 24);
        Person p3 = new Person("王五", 25);
        Person p4 = new Person("赵六", 26);
        
        ArrayList<Person> list = new ArrayList<Person>();
        list.add(p1);
        list.add(p2);
        list.add(p3);
        list.add(p4);
        
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("e.txt"));
        oos.writeObject(list);    // 把整个集合对象一次写出
        oos.close();
    }

    public static void demo1() throws IOException, FileNotFoundException {
        Person p1 = new Person("张三",23); // 对象必须可序列化
        Person p2 = new Person("李四",24);

        // FileOutputStream fos = new FileOutputStream("f.txt");
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("f.txt")); // 创建对象输出流 
        oos.writeObject(p1);
        oos.writeObject(p2);

        oos.close();
    }
}

ObjectOutputStream

 

 

 对象操作流ObjectInputStream

* 读取：new ObjectInputStream(InputStream), readObject()

package com.heima.otherio;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;

import com.heima.bean.Person;

public class Demo4_ObjectInputStream {

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        // demo1();
        // demo2();
    }

    public static void demo2() throws IOException, FileNotFoundException, ClassNotFoundException {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("e.txt"));
        ArrayList<Person> list = (ArrayList<Person>) ois.readObject();    // 将集合对象一次读取
        for (Person person : list) {
            System.out.println(person);
        }
    }

    public static void demo1() throws IOException, FileNotFoundException, ClassNotFoundException {
        // 对象输入流是反序列化
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("e.txt")); // 创建对象输入流

        Person p1 = (Person) ois.readObject(); // 从文件中读取对象，需要强转，因为读取时自动类型提升为Object
        Person p2 = (Person) ois.readObject();

        System.out.println(p1);
        System.out.println(p2);

        ois.close();
    }
}

ObjectInputStream

 

 

 打印流的概述和特点

* A：什么时打印流
　　* 该流可以很方便的将对象的 toString()结果输出，并自动加上换行，而且可以使用自动刷出的模式
　　* System.out就是一个PrintStream，其默认向控制台输出信息

* B：使用方式
　　* 打印：print(), println()
　　* 自动刷出：PrintWriter(OutputStream out, boolean autoFlush, String encoding)
　　* 打印流以只操作数据为目的

package com.heima.otherio;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;
import java.io.PrintWriter;

import com.heima.bean.Person;

public class Demo5_PrintStream {
    /*
     * PritnStream和 PrintWriter 分别是打印的字节流和字符流
     * 二者是以只操作数据为目的的
     */
    public static void main(String[] args) throws IOException {
        // demo1();
        // demo2();
    }

    public static void demo2() throws FileNotFoundException {
        PrintWriter pw = new PrintWriter(new FileOutputStream("f.txt"), true); // true表示打开了AutoFlush功能
        pw.println(97);    // 自动刷出功能只针对println方法
        pw.write(97);
        pw.print(97);
        pw.close();
    }

    public static void demo1() {
        System.out.println("aaa");
        PrintStream ps = System.out;    // 获取标准输出流
        ps.println(97); // 打印97，底层通过 Integer.toString()将97 转换成字符串打印
        ps.write(97);    // 打印a，查找码表，找到对应的值进行打印
        
        Person p1 = new Person("张三", 23);
        ps.println(p1); // 默认调用对象的 toString()方法
        
        Person p2 = null; // 打印引用数据类型，如果是null就打印null
        ps.println(p2);
        ps.close(); // 关闭打印流
    }
}

PrintStream