【JavaSE】IO流-各种流整理详解（16）

引言

👉猛的发现距离开学还有40天，我还没有底气去应对；
👉加油干；

知识点总结

缓冲流

BufferedStream，缓冲流；也被称作高效流，因为使用起来效率很高；
高效的原因
与之前的流不同，它底层有个专门用来存放数据的缓冲区；就好比快递小哥送快递，之前是用电瓶车送，一次只能送一件；现在换了三轮车，可以一次性拉很多快递；这就是用空间换时间。

字节缓冲流

使用步骤
1.创建普通的文件输入输出流(FileInputStream);
2.把文件输入输出流当参数传递到缓冲流中；
3.调用write/read核心方法输入输出数据
4.关闭流（输出数据时要flush()刷新）；
BufferedOutputStream

import java.io.*;

public class Demo01BI {
    public static void main(String[] args) throws IOException {
        //步骤1
        FileOutputStream fos1=new FileOutputStream("C:\\Users\\Administrator\\Desktop\\Demo01BW.txt");
        //步骤2
        BufferedOutputStream bos1=new BufferedOutputStream(fos1);
        //步骤3
            for(int i='a';i<='z';i++)
                 bos1.write(i);
        //步骤4    
            bos1.flush();
            bos1.close();

    }
}

BufferedInputStream

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class Demo02BO {
    public static void main(String[] args) throws IOException {
         FileInputStream fis1=new FileInputStream("C:\\Users\\Administrator\\Desktop\\Demo01BW.txt");
         BufferedInputStream bis1=new BufferedInputStream(fis1,50);
    int len=0;
       while ((len=bis1.read())!=-1)
           System.out.println((char) len);
    }
}

字符缓冲流

使用步骤
1.创建字符读取/输出流；
2.创建字符缓冲流，把字符流当参数传到缓冲流中；
3.用write/read等核心方法读取/输出数据到缓冲区；
4.关闭流（关闭前会刷新，可不用flush()）;
BufferedWriter

public class Demo01BW {
    public static void main(String[] args) throws IOException {
        FileWriter  fw1=new FileWriter("C:\\Users\\Administrator\\Desktop\\Demo01BW.txt");
        BufferedWriter  bw1=new BufferedWriter(fw1,5);
        bw1.write("12");
        bw1.newLine();
          for(int i=0;i<10;i++)
               bw1.write("无情");
          bw1.newLine();
          String str="i am a happy boy";
          bw1.write(str,3,4);
          bw1.flush();
          bw1.close();
    }
}

BufferedReader

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class Demo02BR {
    public static void main(String[] args) throws IOException {
        FileReader fr1=new FileReader("C:\\Users\\Administrator\\Desktop\\Demo01BW.txt");
        BufferedReader br1=new BufferedReader(fr1);
        int len=0;
        while((len=br1.read())!=-1){
            System.out.println(len);
        }
        br1.close();
    }
}

转换流

编码表是程序把计算机的二进制数据转换为字符的依据；但是编码表有很多种，比如GBK,UTF-8~~；当我们操作的文件默认编码表不一致时，就要用到转换流。

转换输入流

InputStreamReader
构造方法
InputStreamReader(InputStream in, Charset cs)
创建一个使用给定字符集的InputStreamReader。
使用步骤
1.创建字节输入流；
2.创建转换输入流对象，把字节流当参数传递；
3.读取数据；
4.释放资源；

public class Demo05 {
    public static void main(String[] args) throws IOException {
        FileInputStream  fis=new FileInputStream("C:\\Users\\Administrator\\Desktop");
        InputStreamReader isr=new InputStreamReader(fis,"GBK");
        int len=0;
        while((len=isr.read())!=-1)
            System.out.println(len);
        isr.close();
        fis.close();
    }
}

转换输出流

OutputStreamReader
构造方法
OutputStreamReader(InputStream in, Charset cs)
创建一个使用给定字符集的InputStreamReader。

public class Demo06 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos=new FileOutputStream("C:\\Users\\Administrator\\Desktop");
        OutputStreamWriter osw=new OutputStreamWriter(fos,"UTF-8");
        for (int i = 0; i < 10; i++) {
              osw.write(i);
        }
        osw.flush();
        osw.close();
        fos.close();
    }
}

序列化

序列化流&反序列化流

• 序列化，指的是是指将一个任意对象(Object) 以二进制的形式存储到文件中；反序列化就是把文件中的二进制流以对象的形式读取。
• 类的序列化由实现java.io.Serializable接口的类启用。 不实现此接口的类将不会使任何状态序列化或反序列化；序列化接口没有方法或字段，仅用于标识可串行化的语义。
• 作用可以实现对象的持久存储。
  核心方法
  1.Object readObject()
  从ObjectInputStream读取一个对象；会抛出ClassNotFoundException异常。
  2.void writeObject(Object obj)
  将指定的对象写入ObjectOutputStream。

//自己创建的对象
class beauty implements Serializable {
    int age;
    String name;
    public  beauty(String name,int age){
        this.age=age;
        this.name=name;
    }
    @Override
    public String toString() {
        return "beauty{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}
public class Demo01 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
          beauty p1=new beauty("一个月",18);
          ObjectOutputStream  oos=new ObjectOutputStream(new FileOutputStream("C:\\Users\\Administrator\\Desktop\\t1.txt"));
             oos.writeObject(p1);
                       //把对象输出到文本中；
             oos.flush();
             oos.close();
   
             ObjectInputStream  ois=new ObjectInputStream(new FileInputStream("C:\\Users\\Administrator\\Desktop\\t1.txt"));
             Object obj=ois.readObject();
                       //把对象读取出来，返回值是一个对象；
        System.out.println(obj.toString());
    }
}

transient关键字

如果类中有属性不需要可序列化，就可以加上transient修饰符或者static修饰符修饰；

 transient int age;

序列号

当类的性质或其中的属性的性质发生改变时，其序列化锁对应的序列号(SerialVersionUID)会发生改变，会抛出InvalidClassException异常。

解决方法
创建对象时声明序列号始终不变即可。

   private static final long serialVersionUID=1l;

打印流

PrintStream

作用
打印各种数据
构造方法
1.PrintStream(File file)
使用指定的文件创建一个新的打印流，而不需要自动换行。
2.PrintStream(OutputStream out)
创建一个新的打印流。
3.PrintStream(String fileName)
使用指定的文件名创建新的打印流，无需自动换行。
常用方法
1.println() 【不信你们不知道🤷‍】
2.print(String s)
二者都可以打印任意数据类型；
**setout(PrintStream s)** 这是System中的静态方法，可以改变数据的流向

import java.io.FileNotFoundException;
import java.io.PrintStream;

public class Demo02 {
    public static void main(String[] args) throws FileNotFoundException {
        System.out.println("我打印到控制台");
        PrintStream PS=new PrintStream("C:\\Users\\Administrator\\Desktop\\t1.txt");
        System.setOut(PS);
        System.out.println("我打印到文件中了,~~~~~~");
    }
}