Java学习记录之缓冲流、转换流、序列化流

最新推荐文章于 2024-04-04 12:00:00 发布

路～～～

最新推荐文章于 2024-04-04 12:00:00 发布

阅读量114

点赞数

本文链接：https://blog.csdn.net/cxs_123/article/details/106363050

版权

缓冲流也叫高效流，是对应4个基本的Filexxx流的增强，所以也是4个流：
字节缓冲流：BufferedInputStream,BufferedOutputStream
字符缓冲流：BufferedReader,BufferedWriter
缓冲流的基本原理，实在创建流对象时，会创建一个内置的默认大小的缓冲数组，通过缓冲区读写，减少系统IO次数，从而提高读写的效率

字节缓冲输出流
java.io.BufferedOutputStream extends OutputStream
继承自父类的共性成员方法：
public void close() :关闭此输出流并释放与此流相关联的任何系统资源
public void flush() :把内存缓冲区的数据，刷新到文件中
public void write(byte[] b) :将b.length字节从指定的字节数组写入此输出流
public void write(byte[] b,int off,int len) :从指定的字节数组写入len字节，从偏移量off开始输出到此输入流
public abstract void write(int b) : 将指定的字节写入此输出流

构造方法：
public BufferedOutputStream(OutputStream out) :创建一个新的缓冲输出流，以将数据写入指定的底层输出流
public BufferedOutputStream(OutputStream out,int aize) :创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入指定的底层输出流
参数：
OutputStream out :字节输出流
我们可以传递FileOutputStream,缓冲流会给FileOutputStream增加一个缓冲区，提高FileOutputStream的写入效率

int size :指定缓冲流内部缓冲区的大小，不指定默认

public class Demo01BufferedOutputStream{
   public static void main(String[] args) throws IOException{
      //创建FileOutputStream对象，构造方法中绑定要输出的目的地
      FileOutputStream fos = new FileOutputStream("d:\\a.txt");
      //创建BufferedOutputStream对象，构造方法中传递FileOutputStream对象，提高FileOutputStream对象效率
      BufferedOutputStream bos = new BufferedOutputStream(fos);
      //使用BufferedOutputStream对象中的方法write,把数据写入到内部缓冲区
      bos.write("我把数据写入到内部缓冲区".getBytes());
      //使用BufferedOutputStream对象中的方法flush，把内部缓冲区中的数据，刷新到文件中
      bos.flush();
      bos.close();
   }
}

字节缓冲输入流
java.io.BufferedInputStream extends InputStream

继承自父类的成员方法：
int read() 从输入流中读取数据的下一个字节
int read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组b中
void close() 关闭此输入流并释放与该流相关联的所有系统资源

构造方法：
BufferedInputStream(InputStream in) 创建一个BufferedInputStream 并保存其参数，即输入流in,以便将来使用
BufferedInputStream(InputStream in,int size) 创建具有指定缓冲区大小的BufferedInputStream 并保存其参数，即输入流in

参数:
InputStream in 字节输入流
我们可以传递FileInputStream,缓冲流会给FileIbputStream增加一个缓冲区，提高FileInputStream的读取效率

int size ：指定缓冲流内部缓冲区的大小，不指定默认

public class Demo02BufferedInputStream{
   public static void main(String[] args) throws IOException {
       //创建FileInputStream对象，构造方法中绑定要读取的数据源
       FileInputStream fis = new FileInputStream("d:\\a.txt");
       //创建BufferedInputStream对象，构造方法中传递FileInputStream对象，缓冲流会给FileIbputStream增加一个缓冲区，提高FileInputStream的读取效率
       BufferedInputStream bis = new BufferedInputStream(fis);
       //使用BufferedInputStream对象中的方法read，读取文件
       //int read() 从输入流读取数据的下一个字节
       int len = 0;//记录每次读到的字节
       while((len=bis.read())!=-1){
          System.out.println(len);
       }
       bis.close();
   }
}

效率测试
通过复制大文件(375MB)，测试缓冲流的效率

//基本流
public class BufferedDemo{
    public static void main(String[] args) throws FileNotFoundException{
       //记录开始的时间
       long start = System.currentTimeMillis();
       try(
           FileInputStream fis = new FileInputStream("jdk9.exe");
           FileOutputStream fos = new FileOutputStream("copy.exe")
       ){
           //读写数据
           int b;
           while((b=fis.read())!=-1){
             fos.write(b);
           }
         }catch(IOException e){
             e.printStackTrace();
         }
         //记录结束的时间
         long end = System.currentMillis();
         System.out.println("普通流复制的时间："+(end-start)+"毫秒")；//大概需要用十几分钟
    }
}

//缓冲流
public class BufferedDemo02{
   public static void main(String[] args) throws FileNotFoundException{
       long start = System.currentMillis();
       FileInputStream fis = new FileInputStream("jdk9.exe");
       FileOutputStream fos = new FileOutputStream("copy.exe");
       try(
           BufferedInputStream bis = new BufferedInputStream(fis);
           BufferedOutputStream bos = new BufferedOutputStream(fos);
       ){
            int len = 0;
            while((len=bis.read()!=-1)){
               bos.write(len);
            }
       }catch(IOException e){
             e.printStackTrace();
       }
       long end = System.currentMillis();
       System.out.println("普通流复制的时间："+(end-start)+"毫秒")；//仅需要8016毫秒 
   }
}

字符缓冲流
java.io.BufferedReader extends Reader 字符缓冲输入流

java.io.BufferedWriter extends Writer 字符缓冲输出流

构造方法
public BufferedReader(Reader in) ：创建一个新的缓冲输入流
public BufferedWriter(Writer out) :创建一个新的缓冲输出流

字符缓冲流的基本方法与普通字符流调用方式一致，不在阐述，我们来看它们具备的特有方法：
BufferedReader :public String readLine() 读一行文字
BufferedWriter : public void newLine() 写一行行分隔符，由系统属性定义符号

//readLinE方法演示
public class BufferedReaderDemo{
   public static void main(String[] args) throws IOException{
       BufferedReader br = new BufferedReader(new FileReader("in.txt"));
       //定义字符串，保存读取的一行文字
       String line = null;
       //**循环读取，读取到最后返回null**
       while((line=br.readLine())!=null){
           System.out.println(line);
           System.out.println("-----------");
       }
       br.close();
   }
}

//newLine方法演示
public class BufferedWriterDemo{
   public static void main(String[] args) throws IOException{
     BufferedWriter bw = new BufferedWriter(new FileWriter("out.txt"));
     //写出数据
     bw.writer("黑马");
     //**写出换行**
     bw.newLine();
     bw.writer("程序")；
     bw.close();/*输出效果:黑马
                          程序
     */
   }
}

转换流
在IDEA中，使用FileReader读取项目中的文本文件。由于IDEA的设置，都是默认UTF-8编码，所以没有任何问题。但是，当读取Windows系统中创建的文本文件时，由于Windows系统的默认是GBK编码，就会出现乱码

那么如何读取GBK编码的文件呢？
InputStreamReader类
转换流java.io.InputStreamReader ,是Reader的子类，是从字节流到字符流的桥梁。它读取字节，并使用指定的字符集将其解码为字符。它的字符集可以由名称指定，也可以接受平台的默认字符集

构造方法：
InputStreamReader(InputStream in) :创建一个使用默认字符集的字符流
InputStreamReader(InputStream in,String charsetName) :创建一个指定字符集的字符流

//指定编码读取
public class ReaderDemo01{
   public static void main(String[] args) throws IOException{
      //定义文件路径，文件为GBK编码
      String FileName = "E:\\file_gbk.txt";
      //创建流对象，默认UTF-8编码
      InputStreamReader isr = new InputStreamReader(new FileInputStream(FileName));
      //创建流对象，指定GBK编码
      InputStreamReader isr2 = new InputStreamReader(new FileInputStream(FileName),"GBK");
      //定义变量，保存字节
      int read;
      //使用默认编码字节流读取，乱码
      while((read=isr.read())!=-1){
          System.out.println((char)read);//乱码字符
      }
      isr.close();
      //使用指定编码字节流
      while((read=isr2.read())!=-1){
           System.out.println((char)read);//大家好
      }
      isr2.close();
   }
}

OutputStreamWriter类
转换流java.io.OutputStreamWriter ,是Writer的子类，是从字符流到字节流的桥梁，使用指定的字符集将字符编码为字节。它的字符集可以由名称指定，也可以接受平台的默认字符集

构造方法：
OutputStreamWriter(OutputStream in) :创建一个使用默认字符集的字符流
OutputStreamWriter(OutputStream in,String charsetName) :创建一个指定字符集的字符流

//指定编码写出
public class OutputDemo{
   public static void main(String[] args) throws IOException {
      String FileName = "E:\\out.txt";
      //创建流对象，默认UTF-8编码
      OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(FileName));
      //写出数据
      osw.write("你好");//保存为6个字节，因为UTF-8编码用三个字节表示一个汉字
      osw.close();
   
     String FileName2 = "E:\\out2.txt";
     OutputStreamWriter osw2 = new OutputStreamWriter(new OutputStreamWriter((FileName),"GBK");
     osw2.write("你好");//保存为4个字节，因为GBK编码用两个字节表示一个汉字
     osw2.close();
   }
}

序列化
java提供了一种对象序列化的机制。用一个字节序列可以表示一个对象，该字节序列包含该对象的数据、对象的类型、对象中存储的属性等信息。字节序列写出到文件之后，相当于文件中持久保存了一个对象的信息。
反之，该字节序列还可以从文件中读取出来，重构对象，对它进行反序列化。

ObjectOutputStream类
java.io.ObjectOutputStream extends OutputStream
作用：把对象以流的方式写出到文件中保存

构造方法：
public ObjectOutputStream(OutputStream out) :创建一个指定OutputStream的ObjectOutputStream

特有的成员方法：
public final void writeObject(Object obj) :将指定的对象写出到序列化流中 ObjectOutputStream

注意点
一个对象要想序列化，必须满足两个条件：
1.该类必须实现java.io.Serializable接口，Serializable就是一个标记接口，没有任何方法。不实现此接口的类将不会使任何状态序列化或者反序列化，会抛出NotSerializableException异常
2.该类所有属性必须是可序列化的，如果有一个属性不需要可序列化，则该属性必须注明是瞬态的，使用transient关键字修饰

tip:
static 关键字：静态关键字
静态优先于非静态加载到内存中(静态优先于对象进入到内存中)
被staitc 修饰的成员变量不能被序列化，序列化的都是对象

//Employee类
public class Employee implements Serializable{
   public String name;
   public String address;
   public transient int age;//transient瞬态修饰成员，不会被序列化
   
   public void addressCheck(){
       System.out.println("Address check :"+name+"--"+address);
   }
}

//测试类
public class SerializableDemo{
   public static void main(String[] args){
       Employee e = new Employee();
       e.name="zhangsan";
       e.address="beijinglu";
       e.age=20;
       try(
           //创建序列化流对象
           ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("employee.txt"));
           //写出对象
           out.writeObject(e)；
           //释放资源
           out.close();
           System.out.println("Serialized data is saved");//姓名、地址被序列化，年龄没有被序列化
       ){

       }catch(IOException i){
          i.printStackTrace();
       }
   }
}

ObjectInputStream类
java.io.ObjectInputStream extends InputStream
ObjectInputStream反序列化流，将ObjectOutputStream序列化的原始数据恢复为对象

构造方法：
public ObjectInputStream(InputStream in) :创建一个指定InputStream的ObjectInputStream

1、如果能找到一个对象的class文件，我们就可以进行反序列化操作,如果找不到该类的class文件，则抛出一个ClassNotFoundException异常

调用ObjectInputStream读取对象的方法：
public final Object readObject() :读取一个对象

public class DeserializeDemo{
   public static void main(String[] args){
     Employee e = null;
     try{
         //创建反序列化流
         FileInputStream fileIn = new FileInputStream("employee.txt");
         ObjectInputStream in = new ObjectInputStream(fileIn);
         //读取一个对象
         e = (Employee) in.readObject();
         in.close();
         fileIn.close();
     }catch(IOException i){
            //捕获其它异常
            i.printStrackTrace();
            return ;
     }catch(ClassNotFoundException c){
           //捕获类找不到异常
           System.out.println("Employee class not found");
           c.printStackTrace();
           return ;
     }
     //无异常，直接打印输出
      System.out.println("Name:"+e.name);
      System.out.println("Address:"+e.address);
      System.out.println("age:"+e.age);
   }
}

2、当JVM反序列化时，能够找到class文件，但是class文件在序列化对象之后发生了修改，那么反序列化操作也会失败，抛出一个InvalidClassException异常。发生这个异常的原因如下：

该类的序列版本号与从流中读取的类描述符的版本号不匹配
该类包含未知数据类型
该类没有可访问的无参数构造方法

Serializable接口给需要序列化的类，提供一个序列版本号。serialVersionUID该版本号的目的在于验证序列化的对象和对应类是否版本匹配，

public class Employee implements Serializable{
   //加入序列版本号，这样即是class文件在序列化对象之后发生了修改，也不会出现异常
   private static final long serialVersionUID = 1L;
   public String name;
   public String address;
   //添加新属性，重新编译，可以反序列化，该属性为默认值
   public int eid;
   public void addressCheck(){
        System.out.println("Address check:"+name+"--"+address);
   }
}

打印流
平时我们在控制台打印输出，是调用print方法和println方法完成的，这两个方法都来自于java.io.PrintStream类，该类能够方便地打印各种数据类型的值，是一种便捷的输出方式。

PrintStream类
PrintStream extends OutputStream 当然继承了父类OutputStream中所有的方法
PrintStream 为其他输出流添加了功能，使他们能够方便地打印各种数据值表示形式

PrintStream 特点：
1.只负责数据地输出，不负责数据额读取
2.与其他输出流不同，PrintStream不会抛出IOException
3.有特有的方法，print、println

构造方法：
PrintStream(File file) :输出的目的地是一个文件
PrintStream(OutputStream out) ;输出的目的地是一个字节输出流
PrintStream(String fileName) :输出目的地是一个文件路径

注意：如果使用继承自父类的方法write方法写数据，那么查看数据的时候会查询编码表 97–>a
如果使用自己特有的方法print/println方法写数据，写的数据原样输出 97–>97

改变打印流向
System.out就是PrintStream类型的，只不过它的流向是系统规定的，打印在控制台上。不过，既然是流对象，就可以改变它的流向

public class PrintDemo{
   public static void main(String[] args) throws IOException{
      //调用系统的打印流，控制台直接输出97
      System.out.println(97);
      //创建打印流，指定文件名称
      PrintStream ps = new PrintStream("ps.txt");
      //设置系统的打印流流向，输出到ps.txt
      System.setOut(ps);
      //调用系统的打印流，ps.txt中写入97
      Sytem.out.println(97);
   }
}