ICode9

精准搜索请尝试: 精确搜索
首页 > 编程语言> 文章详细

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

2022-09-14 16:32:48  阅读:178  来源: 互联网

标签:字符 JAVA 进阶 -- String io new public 字节


第一节  缓冲流概述

  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,进阶,--,String,io,new,public,字节
来源: https://www.cnblogs.com/Flower--Dance/p/16666712.html

本站声明: 1. iCode9 技术分享网(下文简称本站)提供的所有内容,仅供技术学习、探讨和分享;
2. 关于本站的所有留言、评论、转载及引用,纯属内容发起人的个人观点,与本站观点和立场无关;
3. 关于本站的所有言论和文字,纯属内容发起人的个人观点,与本站观点和立场无关;
4. 本站文章均是网友提供,不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属;如您发现该文章侵犯了您的权益,可联系我们第一时间进行删除;
5. 本站为非盈利性的个人网站,所有内容不会用来进行牟利,也不会利用任何形式的广告来间接获益,纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

专注分享技术,共同学习,共同进步。侵权联系[[email protected]]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有