day22（SequenceInputStream，ByteArrayOutputStream，ObjectOutputStream）

1.序列流

• 序列流可以把多个字节输入流整合成一个, 从序列流中读取数据时, 将从被整合的第一个流开始读, 读完一个之后继续读第二个, 以此类推.
• 构造方法
  
  • SequenceInputStream(InputStream, InputStream)
  • SequenceInputStream(Enumeration)

public class Temp1_SequenceInputStream {
    public static void main(String[] args) throws IOException {
        InputStream in1 = new FileInputStream("file\\a.txt");
        InputStream in2 = new FileInputStream("file\\b.txt");

        //第一种构造方法
        //SequenceInputStream sInputStream = new SequenceInputStream(in1, in2);

        //第二种构造方法
        Vector<InputStream> v = new Vector<>();
        v.add(in1);
        v.add(in2);
        Enumeration<InputStream> elements = v.elements();
        SequenceInputStream sInputStream = new SequenceInputStream(elements);


        OutputStream out = new FileOutputStream("file\\c.txt");
        int a;
        while((a=sInputStream.read())!=-1){
            out.write(a);
        }
        out.close();
        sInputStream.close();
    }
}

2.内存输出流

• 该输出流可以向内存中写数据, 把内存当作一个缓冲区, 写出之后可以一次性获取出所有数据

• 使用方式

  • 创建对象: new ByteArrayOutputStream()
  • 写出数据: write(int), write(byte[])
  • 获取数据: toByteArray()

public class Temp2_ByteArrayOutputStream {
    public static void main(String[] args) throws IOException {
        //创建
        ByteArrayOutputStream baOutputStream = new ByteArrayOutputStream();
        //写数据
        baOutputStream.write("内存输出流".getBytes());
        //获取数据
        byte[] byteArray = baOutputStream.toByteArray();
        System.out.println(new String(byteArray));
        baOutputStream.close();
    }
}

• 面试题

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

public class Temp3_ByteArrayOutputStream2 {
    //定义一个文件输入流,调用read(byte[] b)方法,将a.txt文件中的内容打印出来(byte数组大小限制为5)
    public static void main(String[] args) throws IOException {
        FileInputStream f = new FileInputStream("file\\temp3.txt");
        ByteArrayOutputStream bOutputStream = new ByteArrayOutputStream();

        byte[] cs = new byte[5];
        int a;
        while((a=f.read(cs))!=-1){
            bOutputStream.write(cs,0,a);
        }
        byte[] byteArray = bOutputStream.toByteArray();
        System.out.println(new String(byteArray));
        bOutputStream.close();
        f.close();
    }
}

3.对象操作流ObjecOutputStream

• 该流可以将一个对象写出, 或者读取一个对象到程序中. 也就是执行了序列化和反序列化的操作.

• 对象必须实现Serializable接口

• 使用方式：

  • 写出: new ObjectOutputStream(OutputStream), writeObject()
  • 读取: new ObjectInputStream(InputStream), readObject()

//对象实现Serializable接口
//不用必须加id号，id号的作用
class Person implements Serializable{
    private String name;
    private int age;


    public Person() {
        super();
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
}

public class Temp4_ObjectOutputStream {
    public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
        ObjectOutputStream obStream = new ObjectOutputStream(new FileOutputStream("file\\temp4.txt"));

        Person p = new Person("wbl",30);
        obStream.writeObject(p);
        obStream.close();

        ObjectInputStream obOutStr = new ObjectInputStream(new FileInputStream("file\\temp4.txt"));
        Object obj = obOutStr.readObject();
        if(obj instanceof Person){
            Person p1 = (Person)obj;
            System.out.println(p1);
        }
        obOutStr.close();
    }
}

public class Temp5_ObjectOutputStream2 {
    //对象操作流优化
    //将对象存储在集合中写出
    public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
        ObjectOutputStream objOutstr = new ObjectOutputStream(new FileOutputStream("file\\temp5.txt"));
        List<Person> list = new ArrayList<>();
        list.add(new Person("wbl",34));
        list.add(new Person("xsq", 34));
        list.add(new Person("lhk",32));
        objOutstr.writeObject(list);
        objOutstr.close();

        ObjectInputStream objInStr = new ObjectInputStream(new FileInputStream("file\\temp5.txt"));
        List<Person> list2 = (List<Person>) objInStr.readObject();
        for (Person person : list2) {
            System.out.println(person);
        }
        objInStr.close();
    }
}

4.打印流

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

public class Temp4_PrintStream {
    public static void main(String[] args) {
        PrintStream ps = System.out;
        //等价于System.out.println()
        ps.println(97); 
        ps.print(new Person("wbl", 34));
    }
}

• 打印: print(), println()
• 自动刷出: PrintWriter(OutputStream out, boolean autoFlush, String encoding)

public class Temp5_PrintStream2 {
    public static void main(String[] args) throws FileNotFoundException {
        PrintStream pStream = new PrintStream(new FileOutputStream("file\\temp5.txt"), true);

        pStream.println("你好");
        pStream.print("我好");
        pStream.close();
    }
}

5.标准输入输出流

• a.什么是标准输入输出流

  • System.in是InputStream, 标准输入流, 默认可以从键盘输入读取字节数据
  • System.out是PrintStream, 标准输出流, 默认可以向Console中输出字符和字节数据

• b.修改标准输入输出流

public class Temp6_biaozhun {
    public static void main(String[] args) throws IOException {
        System.setIn(new FileInputStream("file\\temp6_in.txt"));
        System.setOut(new PrintStream("file\\temp6_out.txt"));

        InputStream in = System.in;
        OutputStream out = System.out;

        int a;
        while((a=in.read())!=-1){
            out.write(a);
        }

        out.flush();
        out.close();
        in.close();
    }
}

6.修改标准输入输出流拷贝图片

7.两种方式实现键盘录入

• BufferedReader的readLine方法。

  * BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
  

• Scanner

public class temp7_jianpan {
    public static void main(String[] args) throws IOException {
        BufferedReader bReader = new BufferedReader(new InputStreamReader(System.in));
        System.out.println(bReader.readLine());
        bReader.close();
    }
}

8.随机访问流概述和读写数据

• RandomAccessFile概述
  
  • RandomAccessFile类不属于流，是Object类的子类。但它融合了InputStream和OutputStream的功能。
  • 支持对随机访问文件的读取和写入。
  • 随机访问文件的行为类似存储在文件系统中的一个大型 byte 数组。存在指向该隐含数组的光标或索引，称为文件指针。
• 方法:
  
  • read() 从此文件中读取一个数据字节。
  • write() 向此文件写入指定的字节，从当前文件指针开始写入（替换）。
  • seek() 设置到此文件开头测量到的文件指针偏移量，在该位置发生下个读取或写入操作。

public class Temp12_RandomAccessFile {
    public static void main(String[] args) throws IOException {
        RandomAccessFile random = new RandomAccessFile("file\\temp12.txt", "rw");
        random.write(110);
        //先偏移
        random.seek(4);
        random.write(110);
        //在末尾添加数据
        random.seek(random.length());
        random.write(110);
        random.close();
    }
}

9.数据输入输出流

• 什么是数据输入输出流
  
  • DataInputStream, DataOutputStream可以按照基本数据类型大小读写数据
  • 例如按Long大小写出一个数字, 写出时该数据占8字节. 读取的时候也可以按照Long类型读取, 一次读取8个字节.

public class Temp13_DataStream {
    public static void main(String[] args) throws IOException {
        //读的时候必须按照写的顺序读取
        DataOutputStream dataOut = new DataOutputStream(new FileOutputStream("file\\temp13.txt"));
        dataOut.writeInt(12);
        dataOut.writeBoolean(true);
        dataOut.close();

        DataInputStream dataIn = new DataInputStream(new FileInputStream("temp13.txt"));
        int num = dataIn.readInt();
        boolean str = dataIn.readBoolean();
        dataIn.close();
        System.out.println(num+" "+str);
    }
}

10.Properties的概述

• Properties的概述
  
  • Properties 继承于 Hashtable
  • Properties 类表示了一个持久的属性集。
  • Properties 可保存在流中或从流中加载。
  • 属性列表中每个键及其对应值都是一个字符串。

11.常用方法

• public Object setProperty(String key,String value)
• public String getProperty(String key)
• public Set stringPropertyNames()
• Properties的load()和store()功能