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

叨逼叨两句

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

2. 如果没有互联网，也许你这辈子真就受困于你身边圈子的认知了。

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

1. 序列流的存在价值是：帮助整合多个文件的内容放到一个文件中。

2. 整合多个时，需要使用枚举的方式。

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：内存输出流

概述

1. 该输出流可以向内存中写入数据，它是把内存作为一个缓冲区，写出之后一次性将数据取出，常用于聊天应用。

2. 数组和集合在内存中用完就自动释放了，不像流，跟硬盘有关联，需要手动关闭。

使用方式

1. 创建对象：new ByteArrayOutputStream()

2. 写出数据：write(int),write(byte[])

3. 获取数据：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：内存输出流之黑马面试题

1. 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（序列化、存档）

1. 序列化：将对象写到文件上【类似游戏存档】

2. 反序列化：将对象从文件中读取出来【类似游戏读档】

3. 对象写到文件上会是乱码，但木有关系，能读出来就行。

4. 对象必须是可序列化的，即它必须实现Serializeable接口

5. Serializeable接口中没有任何方法，它就是一个标记而已

6. 若自己不指定，则类的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);
    }
}

对象操作流优化

1. 序列化

   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();
       }
   }
   
   

2. 反序列化

   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号（版本号）

1. 不先存档（序列化）就读档（反序列化），会报错。

2. private static final long serialVersionUID = 1L;