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