【210天】黑马程序员27天视频学习笔记【Day22-上】

时间 2019-12-07

原文原文链接

叨逼叨两句

快乐来的越容易，痛苦也就会来的越频繁。java

若是没有互联网，也许你这辈子真就受困于你身边圈子的认知了。面试

22-(01-02):序列流（整合两个流对象+整合多个流对象）

序列流的存在价值是：帮助整合多个文件的内容放到一个文件中。数组
整合多个时，须要使用枚举的方式。优化

package com.test.demo001;

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

public class Demo010 {
    public static void main(String[] args) throws IOException {
        //demo01();
        //demo02();
        demo03();
        
    }

    private static void demo03() throws FileNotFoundException, IOException {
        FileInputStream fis1 = new FileInputStream("a.txt");
        FileInputStream fis2 = new FileInputStream("b.txt");
        FileInputStream fis3 = new FileInputStream("c.txt");
        
        Vector<InputStream> v = new Vector<>();  //建立Vector集合对象
        v.add(fis1);
        v.add(fis2);
        v.add(fis3);
        Enumeration<InputStream> en = v.elements();//获取枚举引用
        SequenceInputStream sis = new SequenceInputStream(en);
        FileOutputStream fos = new FileOutputStream("o.txt");
        int a;
        while((a = sis.read())!= -1){
            fos.write(a);
        }
        sis.close();
        fos.close();
    }

    private static void demo02() throws FileNotFoundException, IOException {
        FileInputStream fis1 = new FileInputStream("a.txt");
        FileInputStream fis2 = new FileInputStream("b.txt");
        FileInputStream fis3 = new FileInputStream("c.txt");
        
        SequenceInputStream sis = new SequenceInputStream(fis1,fis2);//只能整合两个流对象
        FileOutputStream fos = new FileOutputStream("o.txt");
        
        int a;
        while((a = sis.read())!= -1){
            fos.write(a);
        }
        
        sis.close();
        fos.close();
    }

    private static void demo01() throws FileNotFoundException, IOException {
        FileInputStream fis1 = new FileInputStream("a.txt");
        FileOutputStream fos = new FileOutputStream("o.txt");
        
        int a;
        while((a = fis1.read())!= -1){
            fos.write(a);
        }
        fis1.close();
        
        FileInputStream fis2 = new FileInputStream("b.txt");
        int b;
        while((b = fis2.read())!= -1){
            fos.write(b);
        }
        fis2.close();
        
        FileInputStream fis3 = new FileInputStream("c.txt");
        int c;
        while((c = fis3.read())!= -1){
            fos.write(c);
        }
        fis3.close();
        
        fos.close();
    }
}

22-03：内存输出流

概述

该输出流能够向内存中写入数据，它是把内存做为一个缓冲区，写出以后一次性将数据取出，经常使用于聊天应用。编码
数组和集合在内存中用完就自动释放了，不像流，跟硬盘有关联，须要手动关闭。code

使用方式

建立对象：new ByteArrayOutputStream()对象
写出数据：write(int),write(byte[])接口
获取数据：toByteArray()游戏

private static void demo01() throws FileNotFoundException, IOException {
        FileInputStream fis = new FileInputStream("a.txt");
        ByteArrayOutputStream baos = new ByteArrayOutputStream();//在内存中建立了能够增加的内存数组
        
        int a;
        while((a = fis.read())!= -1){
            baos.write(a);            //将读取到的数据逐个写到内存中
        }
        
        fis.close();
        
        //这种方式能够指定转换数组的编码
//        byte[] arr = baos.toByteArray();           //将缓冲区的数据所有获取出来，并赋值给arr数组
//        System.out.println(new String(arr));
        
        //这种方式使用的是平台默认的编码表
        System.out.println(baos);
        
    }

22-04：内存输出流之黑马面试题

FileInputStream读取中文时出现乱码的解决方案：内存
1. 字符流
2. 内存输出流：ByteArrayOutputStream

package com.test.demo001;

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

public class Demo010 { 
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("d.txt");
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        byte[] arr = new byte[5];
        int len;
        while((len = fis.read(arr))!= -1){
            baos.write(arr,0,len);
        }
        System.out.println(baos);
        fis.close();
    }
}

22-(05-08)

对象操做流ObjectOutputStream（序列化、存档）

序列化：将对象写到文件上【相似游戏存档】
反序列化：将对象从文件中读取出来【相似游戏读档】
对象写到文件上会是乱码，但木有关系，能读出来就行。
对象必须是可序列化的，即它必须实现Serializeable接口
Serializeable接口中没有任何方法，它就是一个标记而已
若本身不指定，则类的ID号是随机的

package com.test.demo001;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class Demo010 {
    public static void main(String[] args) throws IOException {
        Student s1 = new Student("z3",23);
        Student s2 = new Student("l4",24);
        FileOutputStream fos = new FileOutputStream("k.txt");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        oos.writeObject(s1);
        oos.writeObject(s2);
        fos.close();
        oos.close();
        
    }
}

对象操做流ObjectInputStream（反序列化、读档）

package com.test.demo001;

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

public class Demo011 {
    public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("k.txt"));
        Student s1 = (Student) ois.readObject();
        Student s2 = (Student) ois.readObject();
        //Student s3 = (Student) ois.readObject(); //当文件读到末尾出现EOFException
        System.out.println(s1);
        System.out.println(s2);
    }
}

对象操做流优化

序列化

package com.test.demo001;

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

public class Demo010 {
    public static void main(String[] args) throws IOException{
        Student s1 = new Student("z3",23);
        Student s2 = new Student("z4",24);
        Student s3 = new Student("z5",25);
        Student s4 = new Student("z6",26);
        ArrayList<Student> list = new ArrayList<>(); 
        list.add(s1);
        list.add(s2);
        list.add(s3);
        list.add(s4);
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("test.txt"));
        oos.writeObject(list); //将集合对象一次写入
        oos.close();
    }
}

反序列化

package com.test.demo001;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.ArrayList;

public class Demo011 {
    public static void main(String[] args) throws IOException, ClassNotFoundException{
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("test.txt"));
        ArrayList<Student> list = (ArrayList<Student>) ois.readObject(); //将集合对象一次读取
        for (Student stu : list) {
            System.out.println(stu);
        }
        ois.close();
        
    }
}

ID号（版本号）

不先存档（序列化）就读档（反序列化），会报错。
private static final long serialVersionUID = 1L;