Java教程

JAVA进阶--缓冲流--2022年9月7日

本文主要是介绍JAVA进阶--缓冲流--2022年9月7日,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

第一节  缓冲流概述

  1、缓冲流的作用

    缓冲流自带缓冲区、可以提高原始字节流、字符流读写数据的性能

    

  2、缓冲流有几种?

    字节缓冲流

      字节缓冲输入流:BufferedInputStream

      字节缓冲输出流:BufferedOutputStream

    字符缓冲流

      字符缓冲输入流:BufferedReader

      字符缓冲输出流:BufferedWriter

  

 

 

   

第二节   字节缓冲流

  1、字节缓冲流为什么提高了操作数据的性能

    字节缓冲流自带8KB缓冲区

    可以提高原始字节流、字符流读写数据的性能

  2、字节缓冲流的功能如何调用

    public BufferedOutputStream(OutputStream os)

    public BufferedInputStream(InputStream is)

    功能上并无很大变化,性能提升了

    

 1 package com.itheima.d1_byte_buffer;
 2 
 3 import java.io.*;
 4 
 5 /**
 6     目标:使用字节缓冲流完成数据的读写操作。
 7  */
 8 public class ByteBufferDemo {
 9     public static void main(String[] args) {
10 
11         try (
12                 // 这里面只能放置资源对象,用完会自动关闭:自动调用资源对象的close方法关闭资源(即使出现异常也会做关闭操作)
13                 // 1、创建一个字节输入流管道与原视频接通
14                 InputStream is = new FileInputStream("D:\\resources\\newmeinv.jpeg");
15                 // a.把原始的字节输入流包装成高级的缓冲字节输入流
16                 InputStream bis = new BufferedInputStream(is);
17                 // 2、创建一个字节输出流管道与目标文件接通
18                 OutputStream os = new FileOutputStream("D:\\resources\\newmeinv222.jpeg");
19                 // b.把字节输出流管道包装成高级的缓冲字节输出流管道
20                 OutputStream bos = new BufferedOutputStream(os);
21 
22         ) {
23 
24             // 3、定义一个字节数组转移数据
25             byte[] buffer = new byte[1024];
26             int len; // 记录每次读取的字节数。
27             while ((len = bis.read(buffer)) != -1){
28                 bos.write(buffer, 0 , len);
29             }
30             System.out.println("复制完成了!");
31 
32         } catch (Exception e){
33             e.printStackTrace();
34         }
35 
36     }
37 }
字节缓冲流

  3、推荐使用哪种方式提高字节流读写数据的性能

    建议使用字节缓冲输入流、字节缓冲输出流,结合字节数组的方式,目前来看是性能最优的组合

    

  1 package com.itheima.d2_byte_buffer_time;
  2 
  3 import java.io.*;
  4 
  5 /**
  6     目标:利用字节流的复制统计各种写法形式下缓冲流的性能执行情况。
  7 
  8     复制流:
  9         (1)使用低级的字节流按照一个一个字节的形式复制文件。
 10         (2)使用低级的字节流按照一个一个字节数组的形式复制文件。
 11         (3)使用高级的缓冲字节流按照一个一个字节的形式复制文件。
 12         (4)使用高级的缓冲字节流按照一个一个字节数组的形式复制文件。
 13 
 14     源文件:C:\course\3-视频\18、IO流-文件字节输出流FileOutputStream写字节数据出去.avi
 15     目标文件:C:\course\
 16 
 17     小结:
 18         使用高级的缓冲字节流按照一个一个字节数组的形式复制文件,性能好,建议开发使用!
 19  */
 20 public class ByteBufferTimeDemo {
 21     private static final String SRC_FILE = "D:\\course\\基础加强\\day08-日志框架、阶段项目\\视频\\14、用户购票功能.avi";
 22     private static final String DEST_FILE = "D:\\course\\";
 23 
 24     public static void main(String[] args) {
 25         // copy01(); // 使用低级的字节流按照一个一个字节的形式复制文件:慢的让人简直无法忍受。直接被淘汰。
 26         copy02(); // 使用低级的字节流按照一个一个字节数组的形式复制文件: 比较慢,但是还是可以忍受的!
 27         // copy03(); // 缓冲流一个一个字节复制:很慢,不建议使用。
 28         copy04(); // 缓冲流一个一个字节数组复制:飞快,简直太完美了(推荐使用)
 29     }
 30 
 31     private static void copy04() {
 32         long startTime = System.currentTimeMillis();
 33         try (
 34                 // 1、创建低级的字节输入流与源文件接通
 35                 InputStream is = new FileInputStream(SRC_FILE);
 36                 // a.把原始的字节输入流包装成高级的缓冲字节输入流
 37                 InputStream bis = new BufferedInputStream(is);
 38                 // 2、创建低级的字节输出流与目标文件接通
 39                 OutputStream os = new FileOutputStream(DEST_FILE + "video4.avi");
 40                 // b.把字节输出流管道包装成高级的缓冲字节输出流管道
 41                 OutputStream bos = new BufferedOutputStream(os);
 42         ) {
 43 
 44             // 3、定义一个字节数组转移数据
 45             byte[] buffer = new byte[1024];
 46             int len; // 记录每次读取的字节数。
 47             while ((len = bis.read(buffer)) != -1){
 48                 bos.write(buffer, 0 , len);
 49             }
 50 
 51         } catch (Exception e){
 52             e.printStackTrace();
 53         }
 54         long endTime = System.currentTimeMillis();
 55         System.out.println("使用缓冲的字节流按照一个一个字节数组的形式复制文件耗时:" + (endTime - startTime)/1000.0 + "s");
 56     }
 57 
 58 
 59 
 60     private static void copy03() {
 61         long startTime = System.currentTimeMillis();
 62         try (
 63                 // 1、创建低级的字节输入流与源文件接通
 64                 InputStream is = new FileInputStream(SRC_FILE);
 65                 // a.把原始的字节输入流包装成高级的缓冲字节输入流
 66                 InputStream bis = new BufferedInputStream(is);
 67                 // 2、创建低级的字节输出流与目标文件接通
 68                 OutputStream os = new FileOutputStream(DEST_FILE + "video3.avi");
 69                 // b.把字节输出流管道包装成高级的缓冲字节输出流管道
 70                 OutputStream bos = new BufferedOutputStream(os);
 71         ){
 72 
 73             // 3、定义一个变量记录每次读取的字节(一个一个字节的复制)
 74             int b;
 75             while ((b = bis.read()) != -1){
 76                 bos.write(b);
 77             }
 78         }catch (Exception e){
 79             e.printStackTrace();
 80         }
 81         long endTime = System.currentTimeMillis();
 82         System.out.println("使用缓冲的字节流按照一个一个字节的形式复制文件耗时:" + (endTime - startTime)/1000.0 + "s");
 83     }
 84 
 85 
 86     private static void copy02() {
 87         long startTime = System.currentTimeMillis();
 88         try (
 89                 // 这里面只能放置资源对象,用完会自动关闭:自动调用资源对象的close方法关闭资源(即使出现异常也会做关闭操作)
 90                 // 1、创建一个字节输入流管道与原视频接通
 91                 InputStream is = new FileInputStream(SRC_FILE);
 92                 // 2、创建一个字节输出流管道与目标文件接通
 93                 OutputStream os = new FileOutputStream(DEST_FILE + "video2.avi")
 94         ) {
 95 
 96             // 3、定义一个字节数组转移数据
 97             byte[] buffer = new byte[1024];
 98             int len; // 记录每次读取的字节数。
 99             while ((len = is.read(buffer)) != -1){
100                 os.write(buffer, 0 , len);
101             }
102         } catch (Exception e){
103             e.printStackTrace();
104         }
105         long endTime = System.currentTimeMillis();
106         System.out.println("使用低级的字节流按照一个一个字节数组的形式复制文件耗时:" + (endTime - startTime)/1000.0 + "s");
107     }
108 
109     /**
110       使用低级的字节流按照一个一个字节的形式复制文件
111      */
112     private static void copy01() {
113         long startTime = System.currentTimeMillis();
114         try (
115                 // 1、创建低级的字节输入流与源文件接通
116                 InputStream is = new FileInputStream(SRC_FILE);
117                 // 2、创建低级的字节输出流与目标文件接通
118                 OutputStream os = new FileOutputStream(DEST_FILE + "video1.avi")
119                 ){
120 
121             // 3、定义一个变量记录每次读取的字节(一个一个字节的复制)
122             int b;
123             while ((b = is.read()) != -1){
124                 os.write(b);
125             }
126         }catch (Exception e){
127             e.printStackTrace();
128         }
129         long endTime = System.currentTimeMillis();
130         System.out.println("使用低级的字节流按照一个一个字节的形式复制文件耗时:" + (endTime - startTime)/1000.0 + "s");
131     }
132 
133 }
流之间的性能分析

第三节   字符缓冲流

  1、字符缓冲流为什么提高了操作数据的性能

    字符缓冲流自带8K缓冲区

    可以提高原始字符流读写数据的性能

  2、字符缓冲流的功能如何使用
    public BufferedReader(Reader r)

    性能提升了,多了readLine()按照行读取的功能

    public BufferedWriter(Writer w)

    性能提升了,多了newLine()换行的功能

  

 1 package com.itheima.d3_char_buffer;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.FileReader;
 5 import java.io.IOException;
 6 import java.io.Reader;
 7 
 8 /**
 9     目标:学会使用缓冲字符输入流提高字符输入流的性能,新增了按照行读取的方法(经典代码)
10  */
11 public class BufferedReaderDemo1 {
12     public static void main(String[] args) {
13         try (
14                 // 1、创建一个文件字符输入流与源文件接通。
15                 Reader fr = new FileReader("io-app2/src/data01.txt");
16                 // a、把低级的字符输入流包装成高级的缓冲字符输入流。
17                 BufferedReader br = new BufferedReader(fr);
18                 ){
19 
20             // 2、用循环,每次读取一个字符数组的数据。  1024 + 1024 + 8
21 //            char[] buffer = new char[1024]; // 1K字符
22 //            int len;
23 //            while ((len = br.read(buffer)) != -1) {
24 //                String rs = new String(buffer, 0, len);
25 //                System.out.print(rs);
26 //            }
27 
28               String line;
29               while ((line = br.readLine()) != null){
30                   System.out.println(line);
31               }
32         } catch (IOException e) {
33             e.printStackTrace();
34         }
35     }
36 }
字符输入流

   

 1 package com.itheima.d3_char_buffer;
 2 
 3 import java.io.BufferedWriter;
 4 import java.io.FileWriter;
 5 import java.io.Writer;
 6 
 7 /**
 8      目标:缓冲字符输出流的使用,学会它多出来的一个功能:newLine();
 9  */
10 public class BufferedWriterDemo2 {
11     public static void main(String[] args) throws Exception {
12         // 1、创建一个字符输出流管道与目标文件接通
13         Writer fw = new FileWriter("io-app2/src/out02.txt"); // 覆盖管道,每次启动都会清空文件之前的数据
14        //Writer fw = new FileWriter("io-app2/src/out02.txt", true); // 追加数据
15         BufferedWriter bw = new BufferedWriter(fw);
16 
17 //      a.public void write(int c):写一个字符出去
18         bw.write(98);
19         bw.write('a');
20         bw.write('徐'); // 不会出问题了
21         bw.newLine(); // bw.write("\r\n"); // 换行
22 
23 //       b.public void write(String c)写一个字符串出去
24         bw.write("abc我是中国人");
25         bw.newLine(); // bw.write("\r\n"); // 换行
26 
27 
28 //       c.public void write(char[] buffer):写一个字符数组出去
29         char[] chars = "abc我是中国人".toCharArray();
30         bw.write(chars);
31         bw.newLine(); // bw.write("\r\n"); // 换行
32 
33 
34 //       d.public void write(String c ,int pos ,int len):写字符串的一部分出去
35         bw.write("abc我是中国人", 0, 5);
36         bw.newLine(); // bw.write("\r\n"); // 换行
37 
38 //       e.public void write(char[] buffer ,int pos ,int len):写字符数组的一部分出去
39         bw.write(chars, 3, 5);
40         bw.newLine(); // bw.write("\r\n"); // 换行
41 
42 
43         // fw.flush();// 刷新后流可以继续使用
44         bw.close(); // 关闭包含刷线,关闭后流不能使用
45 
46     }
47 }
字符输出流

  3、案例:拷贝输出表

  

 

 

 1 package com.itheima.d3_char_buffer;
 2 
 3 import java.io.*;
 4 import java.util.*;
 5 
 6 /**
 7    目标:完成出师表顺序的恢复,并存入到另一个新文件中去。
 8  */
 9 public class BufferedCharTest3 {
10     public static void main(String[] args) {
11         try(
12                 // 1、创建缓冲字符输入流管道与源文件接通
13                 BufferedReader br = new BufferedReader(new FileReader("io-app2/src/csb.txt"));
14 
15                 // 5、定义缓冲字符输出管道与目标文件接通
16                 BufferedWriter bw = new BufferedWriter(new FileWriter("io-app2/src/new.txt"));
17                 ) {
18 
19             // 2、定义一个List集合存储每行内容
20             List<String> data = new ArrayList<>();
21             // 3、定义循环,按照行读取文章
22             String line;
23             while ((line = br.readLine()) != null){
24                 data.add(line);
25             }
26             System.out.println(data);
27 
28             // 4、排序
29             // 自定义排序规则
30             List<String> sizes = new ArrayList<>();
31             Collections.addAll(sizes, "一","二","三","四","五","陆","柒","八","九","十","十一");
32 
33             Collections.sort(data, new Comparator<String>() {
34                 @Override
35                 public int compare(String o1, String o2) {
36                     // o1   八.,....
37                     // o2   柒.,....
38                     return sizes.indexOf(o1.substring(0, o1.indexOf(".")))
39                             - sizes.indexOf(o2.substring(0, o2.indexOf(".")));
40                 }
41             });
42             System.out.println(data);
43 
44             // 6、遍历集合中的每行文章写出去,且要换行
45             for (String datum : data) {
46                 bw.write(datum);
47                 bw.newLine(); // 换行
48             }
49 
50         } catch (Exception e) {
51             e.printStackTrace();
52         }
53     }
54 }
拷贝出师表
 1 十一.出师未捷身先死,长使英雄泪满襟。
 2 三.侍中、侍郎郭攸之、费祎、董允等,此皆良实,志虑忠纯,是以先帝简拔以遗陛下。愚以为宫中之事,事无大小,悉以咨之,然后施行,必得裨补阙漏,有所广益。
 3 八.愿陛下托臣以讨贼兴复之效,不效,则治臣之罪,以告先帝之灵。若无兴德之言,则责攸之、祎、允等之慢,以彰其咎;陛下亦宜自谋,以咨诹善道,察纳雅言,深追先帝遗诏,臣不胜受恩感激。
 4 四.将军向宠,性行淑均,晓畅军事,试用之于昔日,先帝称之曰能,是以众议举宠为督。愚以为营中之事,悉以咨之,必能使行阵和睦,优劣得所。
 5 二.宫中府中,俱为一体,陟罚臧否,不宜异同。若有作奸犯科及为忠善者,宜付有司论其刑赏,以昭陛下平明之理,不宜偏私,使内外异法也。
 6 一.先帝创业未半而中道崩殂,今天下三分,益州疲弊,此诚危急存亡之秋也。然侍卫之臣不懈于内,忠志之士忘身于外者,盖追先帝之殊遇,欲报之于陛下也。诚宜开张圣听,以光先帝遗德,恢弘志士之气,不宜妄自菲薄,引喻失义,以塞忠谏之路也。
 7 九.今当远离,临表涕零,不知所言。
 8 十.今当远离,临表涕零,不知所言。
 9 陆.臣本布衣,躬耕于南阳,苟全性命于乱世,不求闻达于诸侯。先帝不以臣卑鄙,猥自枉屈,三顾臣于草庐之中,咨臣以当世之事,由是感激,遂许先帝以驱驰。后值倾覆,受任于败军之际,奉命于危难之间,尔来二十有一年矣。
10 柒.先帝知臣谨慎,故临崩寄臣以大事也。受命以来,夙夜忧叹,恐付托不效,以伤先帝之明,故五月渡泸,深入不毛。今南方已定,兵甲已足,当奖率三军,北定中原,庶竭驽钝,攘除奸凶,兴复汉室,还于旧都。此臣所以报先帝而忠陛下之职分也。至于斟酌损益,进尽忠言,则攸之、祎、允之任也。
11 五.亲贤臣,远小人,此先汉所以兴隆也;亲小人,远贤臣,此后汉所以倾颓也。先帝在时,每与臣论此事,未尝不叹息痛恨于桓、灵也。侍中、尚书、长史、参军,此悉贞良死节之臣,愿陛下亲之信之,则汉室之隆,可计日而待也。
出师表

第四节   转换流

  1、字符流直接读取文本内容,不同编码读取乱码问题

    必须文件和代码编码一致才不会乱码

    如果文件和代码编码不一致,读取将出现乱码

    

   2、字符输入转换流

    A、字符输入转换流InputStreamReader作用

      可以解决字符流读取不同编码乱码的问题

      public InputStreamReader(InputStream is,String charset);

      可以指定编码把原始字节流转换成字符流,如此字符流中的字符不乱码

    

 

 

     

 1 package com.itheima.d4_transfer_stream;
 2 
 3 import java.io.*;
 4 
 5 /**
 6      目标:字符输入转换流InputStreamReader的使用。
 7 
 8              字节流                                     字符流
 9      字节输入流               字节输出流              字符输入流            字符输出流
10      InputStream             OutputStream          Reader               Writer   (抽象类)
11      FileInputStream         FileOutputStream      FileReader           FileWriter(实现类)
12      BufferedInputStream     BufferedOutputStream  BufferedReader       BufferedWriter(实现类,缓冲流)
13                                                    InputStreamReader    OutputStreamWriter
14      字符输入转换流InputStreamReader:
15           -- 作用:可以解决字符流读取不同编码乱码的问题。
16                   也可以把原始的字节流按照指定编码转换成字符输入流
17 
18           -- 构造器:
19                 public InputStreamReader(InputStream is):可以使用当前代码默认编码转换成字符流,几乎不用!
20                 public InputStreamReader(InputStream is,String charset):可以指定编码把字节流转换成字符流(核心)
21 
22      小结:
23         字符输入转换流InputStreamReader:作用:可以解决字符流读取不同编码乱码的问题。
24         public InputStreamReader(InputStream is,String charset):可以指定编码把字节流转换成字符流(核心)
25  */
26 public class InputStreamReaderDemo01 {
27     public static void main(String[] args) throws Exception {
28         // 代码UTF-8   文件 GBK  "D:\\resources\\data.txt"
29         // 1、提取GBK文件的原始字节流。   abc 我
30         //                            ooo oo
31         InputStream is = new FileInputStream("D:\\resources\\data.txt");
32         // 2、把原始字节流转换成字符输入流
33         // Reader isr = new InputStreamReader(is); // 默认以UTF-8的方式转换成字符流。 还是会乱码的  跟直接使用FileReader是一样的
34         Reader isr = new InputStreamReader(is , "GBK"); // 以指定的GBK编码转换成字符输入流  完美的解决了乱码问题
35 
36         BufferedReader br = new BufferedReader(isr);
37         String line;
38         while ((line = br.readLine()) != null){
39             System.out.println(line);
40         }
41     }
42 }
字符输入转换流

  3、字符输出转换流

    A、如果需要控制写出去的字符使用的编码,怎么办

      可以把字符以指定编码获取字节后再使用字节输出流写出去

        “我爱你中国”.getBytes(编码)

      也可以使用字符输出转换流实现

    B、字符输出转换流OutputStreamWriter的作用

      public OutputStreamWriter(OutputStream os,String charset)

      可以指定编码把字节输出流转换成字符输出流,从而可以指定写出去的字符编码!

    

 1 package com.itheima.d4_transfer_stream;
 2 
 3 import java.io.*;
 4 import java.nio.Buffer;
 5 
 6 /**
 7      目标:字符输出转换OutputStreamWriter流的使用。
 8 
 9                 字节流                                         字符流
10      字节输入流               字节输出流              字符输入流            字符输出流
11      InputStream             OutputStream          Reader               Writer   (抽象类)
12      FileInputStream         FileOutputStream      FileReader           FileWriter(实现类)
13      BufferedInputStream     BufferedOutputStream  BufferedReader       BufferedWriter(实现类,缓冲流)
14                                                    InputStreamReader    OutputStreamWriter
15 
16      字符输出转换流:OutputStreamWriter
17            -- 作用:可以指定编码把字节输出流转换成字符输出流。
18                    可以指定写出去的字符的编码。
19            -- 构造器:
20                 public OutputStreamWriter(OutputStream os) :   用当前默认编码UTF-8把字节输出流转换成字符输出流
21                 public OutputStreamWriter(OutputStream os , String charset):指定编码把字节输出流转换成字符输出流
22      小结:
23         字符输出转换流OutputStreamWriter可以指定编码把字节输出流转换成字符输出流。
24         从而实现指定写出去的字符编码!
25  */
26 public class OutputStreamWriterDemo02 {
27     public static void main(String[] args) throws Exception {
28         // 1、定义一个字节输出流
29         OutputStream os = new FileOutputStream("io-app2/src/out03.txt");
30 
31         // 2、把原始的字节输出流转换成字符输出流
32         // Writer osw = new OutputStreamWriter(os); // 以默认的UTF-8写字符出去 跟直接写FileWriter一样
33         Writer osw = new OutputStreamWriter(os , "GBK"); // 指定GBK的方式写字符出去
34 
35         // 3、把低级的字符输出流包装成高级的缓冲字符输出流。
36         BufferedWriter bw = new BufferedWriter(osw);
37 
38         bw.write("我爱中国1~~");
39         bw.write("我爱中国2~~");
40         bw.write("我爱中国3~~");
41 
42         bw.close();
43     }
44 }
字符输出转换流

第五节   序列化对象

  1、对象序列化

    A、对象序列化的含义是什么

      把对象数据存入到文件中去

      

    B、对象序列化用到了哪个流

      对象字节输出流ObjectOutputStream

      public void writeObject(Object obj)

      

 

 

       

    C、序列化对象的要求是怎么样的?

      对象必须实现序列化接口

 1 package com.itheima.d5_serializable;
 2 
 3 import java.io.Serializable;
 4 
 5 /**
 6   对象如果要序列化,必须实现Serializable序列化接口。
 7  */
 8 public class Student implements Serializable {
 9     // 申明序列化的版本号码
10     // 序列化的版本号与反序列化的版本号必须一致才不会出错!
11     private static final long serialVersionUID = 1;
12     private String name;
13     private String loginName;
14     // transient修饰的成员变量不参与序列化了
15     private transient String passWord;
16     private int age ;
17 
18     public Student(){
19     }
20 
21     public Student(String name, String loginName, String passWord, int age) {
22         this.name = name;
23         this.loginName = loginName;
24         this.passWord = passWord;
25         this.age = age;
26     }
27 
28     public String getName() {
29         return name;
30     }
31 
32     public void setName(String name) {
33         this.name = name;
34     }
35 
36     public String getLoginName() {
37         return loginName;
38     }
39 
40     public void setLoginName(String loginName) {
41         this.loginName = loginName;
42     }
43 
44     public String getPassWord() {
45         return passWord;
46     }
47 
48     public void setPassWord(String passWord) {
49         this.passWord = passWord;
50     }
51 
52     public int getAge() {
53         return age;
54     }
55 
56     public void setAge(int age) {
57         this.age = age;
58     }
59 
60     @Override
61     public String toString() {
62         return "Student{" +
63                 "name='" + name + '\'' +
64                 ", loginName='" + loginName + '\'' +
65                 ", passWord='" + passWord + '\'' +
66                 ", age=" + age +
67                 '}';
68     }
69 }
Student
 1 package com.itheima.d5_serializable;
 2 import java.io.FileOutputStream;
 3 import java.io.ObjectOutputStream;
 4 import java.io.PrintStream;
 5 
 6 /**
 7      目标:学会对象序列化,使用 ObjectOutputStream 把内存中的对象存入到磁盘文件中。
 8 
 9      transient修饰的成员变量不参与序列化了
10      对象如果要序列化,必须实现Serializable序列化接口。
11 
12      申明序列化的版本号码
13      序列化的版本号与反序列化的版本号必须一致才不会出错!
14      private static final long serialVersionUID = 1;
15  */
16 public class ObjectOutputStreamDemo1 {
17     public static void main(String[] args) throws Exception {
18         // 1、创建学生对象
19         Student s = new Student("陈磊", "chenlei","1314520", 21);
20 
21         // 2、对象序列化:使用对象字节输出流包装字节输出流管道
22         ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("io-app2/src/obj.txt"));
23 
24         // 3、直接调用序列化方法
25         oos.writeObject(s);
26 
27         // 4、释放资源
28         oos.close();
29         System.out.println("序列化完成了~~");
30 
31     }
32 }
对象序列化

  2、对象反序列化

    A、对象序列化的含义是什么?

      把磁盘中的对象数据恢复到内存的Java对象中

      

      

    B、对象反序列化用到了哪个流

      对象字节输入流ObjectInputStream

      public Object readObject()

      

 1 package com.itheima.d5_serializable;
 2 
 3 import java.io.FileInputStream;
 4 import java.io.FileNotFoundException;
 5 import java.io.ObjectInputStream;
 6 
 7 /**
 8     目标:学会进行对象反序列化:使用对象字节输入流把文件中的对象数据恢复成内存中的Java对象。
 9  */
10 public class ObjectInputStreamDemo2 {
11     public static void main(String[] args) throws Exception {
12         // 1、创建对象字节输入流管道包装低级的字节输入流管道
13         ObjectInputStream is = new ObjectInputStream(new FileInputStream("io-app2/src/obj.txt"));
14 
15         // 2、调用对象字节输入流的反序列化方法
16         Student s = (Student) is.readObject();
17 
18         System.out.println(s);
19     }
20 }
对象反序列化

      C、序列化版本号的作用

        序列化的版本号与反序列化的版本号必须一致才不会出错!
        private static final long serialVersionUID = 1;

      D、transient修饰的成员变量不参与序列化了,比如像用户密码这种东西

第六节   打印流

  1、打印流有几种?各有什么特点

    打印流一般是指:PrintStream,PrintWriter两个类

    打印功能2者是一样的使用方式

    PrintStream继承自字节输出流OutputStream,支持写字节

    PrintWriter继承自字符输出流Writer,支持写字符

    

 

 

     

 

 

     

  2、打印流的优势是什么?

    两者在打印功能上都是使用方便,性能高效(核心优势)

 1 package com.itheima.d6_printStream;
 2 
 3 import java.io.FileNotFoundException;
 4 import java.io.FileOutputStream;
 5 import java.io.PrintStream;
 6 import java.io.PrintWriter;
 7 
 8 /**
 9     目标:学会使用打印流 高效  方便写数据到文件。
10  */
11 public class PrintDemo1 {
12     public static void main(String[] args) throws Exception {
13         // 1、创建一个打印流对象
14 //        PrintStream ps = new PrintStream(new FileOutputStream("io-app2/src/ps.txt"));
15 //        PrintStream ps = new PrintStream(new FileOutputStream("io-app2/src/ps.txt" , true)); // 追加数据,在低级管道后面加True
16 //        PrintStream ps = new PrintStream("io-app2/src/ps.txt" );
17         PrintWriter ps = new PrintWriter("io-app2/src/ps.txt"); // 打印功能上与PrintStream的使用没有区别
18 
19         ps.println(97);
20         ps.println('a');
21         ps.println(23.3);
22         ps.println(true);
23         ps.println("我是打印流输出的,我是啥就打印啥");
24 
25         ps.close();
26     }
27 }
View Code
 1 package com.itheima.d6_printStream;
 2 
 3 import java.io.FileOutputStream;
 4 import java.io.PrintStream;
 5 
 6 /**
 7     目标:了解改变输出语句的位置到文件
 8  */
 9 public class PrintDemo2 {
10     public static void main(String[] args) throws Exception {
11         System.out.println("锦瑟无端五十弦");
12         System.out.println("一弦一柱思华年");
13 
14         // 改变输出语句的位置(重定向)
15         PrintStream ps = new PrintStream("io-app2/src/log.txt");
16         System.setOut(ps); // 把系统打印流改成我们自己的打印流
17 
18         System.out.println("庄生晓梦迷蝴蝶");
19         System.out.println("望帝春心托杜鹃");
20     }
21 }
View Code

第七节   Properties

  1、Properties的作用

    可以存储Properties属性集的键值对数据到属性文件中去:void store(Writer writer,String comments)

    可以加载属性文件中的数据到Properties对象中来:void load(Reader reader)

  

 

     

 

     

 1 package com.itheima.d7_properties;
 2 
 3 import java.io.FileWriter;
 4 import java.util.Map;
 5 import java.util.Properties;
 6 import java.util.Scanner;
 7 
 8 /**
 9     目标:Properties的概述和使用(框架底层使用,了解这个技术即可)(保存数据到属性文件)
10 
11     Properties: 属性集对象。
12          其实就是一个Map集合。也就是一个键值对集合,但是我们一般不会当集合使用,
13          因为有HashMap。
14 
15     Properties核心作用:
16          Properties代表的是一个属性文件,可以把键值对的数据存入到一个属性文件中去。
17          属性文件:后缀是.properties结尾的文件,里面的内容都是 key=value。
18 
19     大家在后期学的很多大型框架技术中,属性文件都是很重要的系统配置文件。
20         users.properties
21                 admin=123456
22                 dlei=dlei
23 
24      需求:使用Properties对象生成一个属性文件,里面存入用户名和密码信息。
25 
26      Properties的方法:
27          -- public Object setProperty(String key, String value) : 保存一对属性。  (put)
28          -- public String getProperty(String key) : 使用此属性列表中指定的键搜索属性值 (get)
29          -- public Set<String> stringPropertyNames() : 所有键的名称的集合  (keySet())
30          -- public void store(OutputStream out, String comments): 保存数据到属性文件中去
31          -- public void store(Writer fw, String comments): 保存数据到属性文件中去
32 
33      小结:
34             Properties可以保存键值对数据到属性文件
35 
36  */
37 public class PropertiesDemo01 {
38     public static void main(String[] args) throws Exception {
39         // 需求:使用Properties把键值对信息存入到属性文件中去。
40         Properties properties = new Properties();
41         properties.setProperty("admin", "123456");
42         properties.setProperty("dlei", "003197");
43         properties.setProperty("heima", "itcast");
44         System.out.println(properties);
45 
46         /**
47            参数一:保存管道 字符输出流管道
48            参数二:保存心得
49          */
50         properties.store(new FileWriter("io-app2/src/users.properties")
51                 , "this is users!! i am very happy! give me 100!");
52 
53     }
54 }
View Code
 1 package com.itheima.d7_properties;
 2 
 3 import java.io.FileReader;
 4 import java.util.Properties;
 5 import java.util.Set;
 6 
 7 /**
 8     目标:Properties读取属性文件中的键值对信息。(读取)
 9     Properties的方法:
10         -- public Object setProperty(String key, String value) : 保存一对属性。
11         -- public String getProperty(String key) :使用此属性列表中指定的键搜索属性值
12         -- public Set<String> stringPropertyNames() :所有键的名称的集合
13         -- public void store(OutputStream out, String comments):保存数据到属性文件中去
14         -- public synchronized void load(InputStream inStream):加载属性文件的数据到属性集对象中去
15         -- public synchronized void load(Reader fr):加载属性文件的数据到属性集对象中去
16     小结:
17         属性集对象可以加载读取属性文件中的数据!!
18  */
19 public class PropertiesDemo02 {
20     public static void main(String[] args) throws Exception {
21         // 需求:Properties读取属性文件中的键值对信息。(读取)
22         Properties properties = new Properties();
23         System.out.println(properties);
24 
25         // 加载属性文件中的键值对数据到属性对象properties中去
26         properties.load(new FileReader("io-app2/src/users.properties"));
27 
28         System.out.println(properties);
29         String rs = properties.getProperty("dlei");
30         System.out.println(rs);
31         String rs1 = properties.getProperty("admin");
32         System.out.println(rs1);
33     }
34 }
View Code

第八节   IO框架

  1、

  2、

这篇关于JAVA进阶--缓冲流--2022年9月7日的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!