装饰设计模式&缓冲流&转换流&序列化与反序列化

- 能够使用字节缓冲流读取数据到程序1.创建BufferedInputStream对象,构造方法中传递FileInputStream对象2.使用BufferedInputStream对象中的方法read,以字节的方式读取文件3.释放资源
- 能够使用字节缓冲流写出数据到文件1.创建BufferedOutputStream对象,构造方法中传递FileOutputStream对象2.使用BufferedOutputStream对象中的方法write,把数据以字节的方式写入到内存缓冲区中3.使用BufferedOutputStream对象中的方法flush,把内存缓冲区中的数据刷新到文件中4.释放资源
- 能够明确字符缓冲流的作用和基本用法1.创建BufferedReader对象,构造方法中传递FileReader对象2.使用BufferedReader对象中的方法read|readLine,以字符的方式读取文件3.释放资源1.创建BufferedWriter对象,构造方法中传递FileWriter对象2.使用BufferedWriter对象中的方法write,把数据写到内存缓冲区中3.使用BufferedWriter对象中的方法flush,把内存缓冲区中的数据刷新到文件中4.释放资源(会先调用flush方法刷新数据)
- 能够使用缓冲流的特殊功能BufferedReader:String readLine() 读取一个文本行。BufferedWriter:void newLine() 写入一个行分隔符。写换行,会根据系统的不同写不同的换行符号
- 能够阐述编码表的意义(记住)//编码表就是一个生活中文字和计算机存储字节的一个对应关系表ASCII: 0:48  A:65 a:97GBK:中文码表,一个中文占用2个字节UTF-8:万国表,一个中文占用3个字节编码:字符转换为字节(生活中的文字==>计算机存储的)解码:字节转换为字符(计算机存储==>生活中的)
- 能够使用转换流读取指定编码的文本文件1.创建InputStreamReader对象,构造方法中传递FileInputStream对象和指定的编码表名称2.使用InputStreamReader对象中的方法read,以字符的形式读取文件3.释放资源
- 能够使用转换流写入指定编码的文本文件1.创建OutputStreamWriter对象,构造方法中传递FileOutputStream对象和指定的编码表名称2.使用OutputStreamWriter对象中方法write,把数据写入到内存缓冲区中3.使用OutputStreamWriter对象中方法flush,把内存缓冲区中的数据刷新到文件中4.释放资源(会先调用flush方法刷新数据)
- 能够使用序列化流写出对象到文件1.创建ObjectOutputStream对象,构造方法中传递FileOutputStream对象2.使用ObjectOutputStream对象中的方法writeObject,把对象写入到文件中保存3.释放资源
- 能够使用反序列化流读取文件到程序中1.创建ObjectInputStream对象,构造方法中传递FileInputStream对象2.使用ObjectInputStream对象中方法readObject,读取文件中保存的对象3.释放资源
- 能够理解装饰模式的实现步骤1. 装饰类和被装饰类必须实现相同的接口和继承相同的类2. 在装饰类中必须传入被装饰类的引用3. 在装饰类中对需要扩展的方法进行扩展4. 在装饰类中对不需要扩展的方法调用被装饰类中的同名方法
- 能够使用commons-io工具包必须掌握:导包方法IOUtilsstatic int copy(InputStream in, OutputStream out) 复制文件,并返回文件的大小(字节)static long copyLarge(InputStream in, OutputStream out)复制文件,并返回文件的大小(字节)FileUtilsstatic String readFileToString(File file) 读取一个文件,把读取的内容放在一个字符串中返回static void writeStringToFile(File file, String data) 把字符串写到一个文件中保存static void copyFile(File srcFile, File destFile) 复制文件static void copyFileToDirectory(final File srcFile, final File destFile) 复制文件到另外一个目录下。static void copyDirectoryToDirectory( file1 , file2 );复制文件夹

第一章缓冲流

1.概述

作用:可以提高读写文件的效率(速度)

2.BufferedInputStream:字节缓冲输入流(重点)

java.io.BufferedInputStream:字节缓冲输入流 extends InputStream
继续自父类的共性成员方法:int read() 从输入流中读取数据的下一个字节。int read(byte[] b)从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。void close() 关闭此输入流并释放与该流关联的所有系统资源。
构造方法:BufferedInputStream(InputStream in) 创建具有默认缓冲区大小的BufferedInputStream对象BufferedInputStream(InputStream in, int size) 创建具有指定缓冲区大小的 BufferedInputStream 对象参数:InputStream in:传递字节输入流,可以传递InputStream的任意的子类对象我们可以传递FileInputStream对象,缓冲流会给FileInputStream对象增加一个缓冲区(字节数组)提供FileInputStream读取文件的效率int size:指定缓冲区的大小(数组的长度),不指定使用默认值private static int DEFAULT_BUFFER_SIZE = 8192;

package com.itheima.demo01BufferedStream;import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;/*BufferedInputStream:字节缓冲输入流使用步骤:1.创建BufferedInputStream对象,构造方法中传递FileInputStream对象2.使用BufferedInputStream对象中的方法read,以字节的方式读取文件3.释放资源*/
public class Demo01BufferedInputStream {public static void main(String[] args) throws IOException {//1.创建BufferedInputStream对象,构造方法中传递FileInputStream对象BufferedInputStream bis = new BufferedInputStream(new FileInputStream("day17\\a.txt"));//2.使用BufferedInputStream对象中的方法read,以字节的方式读取文件//int read() 一次读取一个字节并返回/*int len = 0;while ((len=bis.read())!=-1){System.out.print((char)len);}*///int read(byte[] b) 一次读取多个字节到数组中byte[] bytes = new byte[1024];int len = 0;while ((len=bis.read(bytes))!=-1){System.out.println(new String(bytes,0,len));}//3.释放资源bis.close();}
}

3.BufferedOutputStream:字节缓冲输出流(重点)

java.io.BufferedOutputStream:字节缓冲输出流 extends OutputStream
继续自父类的共性成员方法: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 void flush() 刷新此输出流并强制写出所有缓冲的输出字节。public void close() ：关闭此输出流并释放与此流相关联的任何系统资源。
构造方法:BufferedOutputStream(OutputStream out) 创建一个新的缓冲输出流,具有默认缓冲区大小BufferedOutputStream(OutputStream out, int size) 创建一个新的缓冲输出流,具有指定缓冲区大小参数:OutputStream out:传递字节输出流,可以传递OutputStream任意的子类对象我们可以传递FileOutputStream对象,缓冲流就会给FileOutputStream对象增加一个缓冲区,提高FileOutputStream对象写入数据的效率int size:指定缓冲区的大小(数组的长度),不指定使用默认值

package com.itheima.demo01BufferedStream;import java.io.BufferedOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;/*BufferedOutputStream:字节缓冲输出流使用步骤:1.创建BufferedOutputStream对象,构造方法中传递FileOutputStream对象2.使用BufferedOutputStream对象中的方法write,把数据写入到内存缓冲区中3.使用BufferedOutputStream对象中的方法flush,把内存缓冲区中的数据刷新到文件中4.释放资源(在释放资源前,也会自动调用flush方法刷新数据)*/
public class Demo02BufferedOutputStream {public static void main(String[] args) throws IOException {//1.创建BufferedOutputStream对象,构造方法中传递FileOutputStream对象BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("day17\\b.txt"));//2.使用BufferedOutputStream对象中的方法write,把数据写入到内存缓冲区中bos.write("你好".getBytes());//3.使用BufferedOutputStream对象中的方法flush,把内存缓冲区中的数据刷新到文件中bos.flush();//4.释放资源(在释放资源前,也会自动调用flush方法刷新数据)bos.close();}
}

4.复制文件测试缓冲流的效率

package com.itheima.demo01BufferedStream;import java.io.*;/*复制文件测试缓冲流的效率*/
public class Demo03CopyFile {public static void main(String[] args) {long s = System.currentTimeMillis();//copyFile01();copyFile02();long e = System.currentTimeMillis();System.out.println("复制文件共耗时:"+(e-s)+"毫秒!");}/*使用缓冲的字节流BufferedInputStream一次读取一个字节,使用BufferedOutputStream一次写入一个字节复制文件全球通史.txt 5,155,785 字节 复制文件共耗时:314毫秒!*/private static void copyFile02() {try(BufferedInputStream bis = new BufferedInputStream(new FileInputStream("c:\\全球通史.txt"));BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("d:\\全球通史.txt"));) {int len =0;while ((len=bis.read())!=-1){bos.write(len);}} catch (IOException e) {e.printStackTrace();}}/*使用基本的字节流FileInputStream一次读取一个字节,使用FileOutputStream一次写入一个字节复制文件全球通史.txt 5,155,785 字节 复制文件共耗时:40890毫秒!*/private static void copyFile01() {try(FileInputStream fis = new FileInputStream("c:\\全球通史.txt");FileOutputStream fos = new FileOutputStream("d:\\全球通史.txt");) {int len = 0;while ((len=fis.read())!=-1){fos.write(len);}} catch (IOException e) {e.printStackTrace();}}
}

5.BufferedReader:字符缓冲输入流(重点)

java.io.BufferedReader:字符缓冲输入流 extends Reader
继续自父类的共性成员方法:int read()读取单个字符。int read(char[] cbuf)将字符读入数组。void close() 关闭该流并释放与之关联的所有资源。
构造方法:BufferedReader(Reader in) 创建一个使用默认大小输入缓冲区的缓冲字符输入流。BufferedReader(Reader in, int sz) 创建一个使用指定大小输入缓冲区的缓冲字符输入流。参数:Reader in:传递字符输入流,可以传递Reader的任意的子类对象我们可以传递FileReader,缓冲流就会给FileReader增加一个缓冲区提高FileReader读取数据的效率int sz:指定缓冲区的大小(数组的长度),不指定使用默认值
特有的成员方法:String readLine() 读取一个文本行。 一次读取一行数据通过下列字符之一即可认为某行已终止：换行 ('\n')、回车 ('\r') 或回车后直接跟着换行(\r\n)。返回:包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null

package com.itheima.demo01BufferedStream;import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;/*BufferedReader:字符缓冲输入流使用步骤:1.创建BufferedReader对象,构造方法中传递FileReader对象2.使用BufferedReader对象中的方法read,以字符的方式读取文件3.释放资源*/
public class Demo04BufferedReader {public static void main(String[] args) throws IOException {//1.创建BufferedReader对象,构造方法中传递FileReader对象BufferedReader br = new BufferedReader(new FileReader("day17\\c.txt"));//2.使用BufferedReader对象中的方法read,以字符的方式读取文件/*int read() 读取单个字符。 会读取每行结尾的回车换行符号hello1(\r\n)hello2(\r\n)hello3*/int len = 0;while ((len=br.read())!=-1){System.out.print((char)len);}//3.释放资源br.close();}
}

package com.itheima.demo01BufferedStream;import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;/*使用BufferedReader特有的方法String readLine() 读取一个文本行。通过下列字符之一即可认为某行已终止：换行 ('\n')、回车 ('\r') 或回车后直接跟着换行(\r\n)。返回：包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null使用步骤:1.创建BufferedReader对象,构造方法中传递FileReader对象2.使用BufferedReader对象中的方法readLine,以行的方式读取文件3.释放资源*/
public class Demo05BufferedReader {public static void main(String[] args) throws IOException {//1.创建BufferedReader对象,构造方法中传递FileReader对象BufferedReader br = new BufferedReader(new FileReader("day17\\c.txt"));//2.使用BufferedReader对象中的方法readLine,以行的方式读取文件/*我们发现使用readLine读取文件,是一个重复的过程,所以我们可以使用循环优化不知道文件中有多少行数据,也不知道读取多少次,使用while循环while循环结束的条件readLine方法返回nullString readLine() 读取一个文本行。 不会给返回每行结尾的回车换行符号hello1hello2hello3问题:文件中有null,能读取出来null后边的内容吗?hello1hello2nullhello3可以读取出来,文件中null不是默认值null,是字符串"null"*/String line;while ((line=br.readLine())!=null){System.out.print(line);}//3.释放资源br.close();}/*String line = br.readLine();System.out.println(line);//hello1line = br.readLine();System.out.println(line);//hello2line = br.readLine();System.out.println(line);//hello3line = br.readLine();System.out.println(line);//null*/
}

6.BufferedWriter:字符缓冲输出流(重点)

java.io.BufferedWriter:字符缓冲输出流 extends Writer
继续自父类的共性成员方法:public abstract void close() ：关闭此输出流并释放与此流相关联的任何系统资源。public abstract void flush() ：刷新此输出流并强制任何缓冲的输出字符被写出。public void write(int c) ：写出一个字符。public void write(char[] cbuf) ：将 b.length字符从指定的字符数组写出此输出流。public abstract void write(char[] b, int off, int len) ：从指定的字符数组写出 len字符，从偏移量 off开始输出到此输出流。public void write(String str) ：写出一个字符串。public void write(String str, int off, int len) 写入字符串的某一部分。
构造方法:BufferedWriter(Writer out) 创建一个使用默认大小输出缓冲区的缓冲字符输出流。BufferedWriter(Writer out, int sz) 创建一个使用给定大小输出缓冲区的新缓冲字符输出流。参数:Writer out:传递字符输出流,可以传递Writer的任意的子类对象我们可以传递FileWriter,缓冲流就会给FileWriter增加一个缓冲区提高FileWriter写入数据的效率int sz:指定缓冲区的大小(数组的长度),不指定使用默认值
特有的成员方法:void newLine() 写入一个行分隔符。写一个换行,根据系统不同,而写不同的换行符号windows: \r\nlinux: /nmac: /r Mac OS X开始与Linux统一

package com.itheima.demo01BufferedStream;import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;/*BufferedWriter:字符缓冲输出流使用步骤:1.创建BufferedWriter对象,构造方法传递FileWriter对象2.使用BufferedWriter对象中的方法write,把数据写入到内存缓冲区中3.使用BufferedWriter对象中的方法flush,把内存缓冲区中的数据刷新到文件中4.释放资源(会先调用flush方法刷新数据)特有的方法:void newLine() 写入一个行分隔符。写一个回车换行符号根据不同的系统,写不同的换行符号windows:\r\nlinux:\nmac:\r*/
public class Demo06BufferedWriter {public static void main(String[] args) throws IOException {//1.创建BufferedWriter对象,构造方法传递FileWriter对象BufferedWriter bw = new BufferedWriter(new FileWriter("day17\\d.txt",true));//2.使用BufferedWriter对象中的方法write,把数据写入到内存缓冲区中for (int i = 1; i <= 3; i++) {bw.write("你好"+i);//bw.write("\r\n");bw.newLine();//写一个回车换行符号}//3.使用BufferedWriter对象中的方法flush,把内存缓冲区中的数据刷新到文件中//bw.flush();//4.释放资源(会先调用flush方法刷新数据)bw.close();}
}

7.练习:文本排序

package com.itheima.demo01BufferedStream;import java.io.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;/*练习:文本排序需求:把出师表按照1,2,3,4...9顺序进行一个排序分析:1.创建一个ArrayList集合,泛型使用String类型2.创建BufferedReader对象,构造方法中传递FileReader对象3.创建BufferedWriter对象,构造方法中传递FileWriter对象4.使用BufferedReader对象中的方法readLine,以行的方式读取文件5.把读取的每行数据,添加到ArrayList集合中6.使用集合工具类Collections中的方法sort,根据比较器写的规则对集合进行排序7.遍历ArrayList集合,获取每一个元素8.使用BufferedWriter对象中的方法write,把遍历得到的每一行元素,写入到内存缓冲区中9.使用BufferedWriter对象中的方法newLine,每写一行文本,写一个换行10.释放资源*/
public class Demo07Test {public static void main(String[] args) throws IOException {//1.创建一个ArrayList集合,泛型使用String类型ArrayList<String> list = new ArrayList<>();//2.创建BufferedReader对象,构造方法中传递FileReader对象BufferedReader br = new BufferedReader(new FileReader("day17\\csblx.txt"));//3.创建BufferedWriter对象,构造方法中传递FileWriter对象BufferedWriter bw = new BufferedWriter(new FileWriter("day17\\csbzx.txt"));//4.使用BufferedReader对象中的方法readLine,以行的方式读取文件String line;while ((line=br.readLine())!=null){//5.把读取的每行数据,添加到ArrayList集合中list.add(line);}//6.使用集合工具类Collections中的方法sort,根据比较器写的规则对集合进行排序Collections.sort(list, new Comparator<String>() {@Overridepublic int compare(String o1, String o2) {//按照首字母升序排序//return o1.charAt(0)-o2.charAt(0);//按照.前边的数字进行升序排序return Integer.parseInt(o1.split("\\.")[0])-Integer.parseInt(o2.split("\\.")[0]);}});//7.遍历ArrayList集合,获取每一个元素for (String s : list) {//8.使用BufferedWriter对象中的方法write,把遍历得到的每一行元素,写入到内存缓冲区中bw.write(s);//9.使用BufferedWriter对象中的方法newLine,每写一行文本,写一个换行bw.newLine();}//10.释放资源bw.close();br.close();}
}

要排序的文本:

3.侍中、侍郎郭攸之、费祎、董允等，此皆良实，志虑忠纯，是以先帝简拔以遗陛下。愚以为宫中之事，事无大小，悉以咨之，然后施行，必得裨补阙漏，有所广益。
8.愿陛下托臣以讨贼兴复之效，不效，则治臣之罪，以告先帝之灵。若无兴德之言，则责攸之、祎、允等之慢，以彰其咎；陛下亦宜自谋，以咨诹善道，察纳雅言，深追先帝遗诏，臣不胜受恩感激。
4.将军向宠，性行淑均，晓畅军事，试用之于昔日，先帝称之曰能，是以众议举宠为督。愚以为营中之事，悉以咨之，必能使行阵和睦，优劣得所。
2.宫中府中，俱为一体，陟罚臧否，不宜异同。若有作奸犯科及为忠善者，宜付有司论其刑赏，以昭陛下平明之理，不宜偏私，使内外异法也。
1.先帝创业未半而中道崩殂，今天下三分，益州疲弊，此诚危急存亡之秋也。然侍卫之臣不懈于内，忠志之士忘身于外者，盖追先帝之殊遇，欲报之于陛下也。诚宜开张圣听，以光先帝遗德，恢弘志士之气，不宜妄自菲薄，引喻失义，以塞忠谏之路也。
9.今当远离，临表涕零，不知所言。
6.臣本布衣，躬耕于南阳，苟全性命于乱世，不求闻达于诸侯。先帝不以臣卑鄙，猥自枉屈，三顾臣于草庐之中，咨臣以当世之事，由是感激，遂许先帝以驱驰。后值倾覆，受任于败军之际，奉命于危难之间，尔来二十有一年矣。
7.先帝知臣谨慎，故临崩寄臣以大事也。受命以来，夙夜忧叹，恐付托不效，以伤先帝之明，故五月渡泸，深入不毛。今南方已定，兵甲已足，当奖率三军，北定中原，庶竭驽钝，攘除奸凶，兴复汉室，还于旧都。此臣所以报先帝而忠陛下之职分也。至于斟酌损益，进尽忠言，则攸之、祎、允之任也。
5.亲贤臣，远小人，此先汉所以兴隆也；亲小人，远贤臣，此后汉所以倾颓也。先帝在时，每与臣论此事，未尝不叹息痛恨于桓、灵也。侍中、尚书、长史、参军，此悉贞良死节之臣，愿陛下亲之信之，则汉室之隆，可计日而待也。

package com.itheima.demo01BufferedStream;import java.util.Arrays;public class Demo08String {public static void main(String[] args) {String s = "10.结束";String[] arr = s.split("\\.");System.out.println(arr.length);System.out.println(Arrays.toString(arr));//把获取到字符串"10",转换为int类型int a = Integer.parseInt(arr[0]);System.out.println(a);System.out.println(Integer.parseInt(s.split("\\.")[0]));}
}

第二章转换流

1.编码表

就是生活中的文字和计算机中文字的对应关系表

a–>97–>01100001==>存储到计算机中

中–>20013–>‭0010000000001011‬==>存储到计算机中

编码:把能看懂的文字,转换为看不懂的文字(字符==>字节)

解码:把看不懂的文字,转换为能看懂的文字(字节==>字符)

常用的编码表:

ASCII字符集 ：英文,数字,标点符号和计算机中文字的对应关系

0–>48 A–>65 a–>97

ISO-8859-1字符集：拉丁码表

拉丁码表，别名Latin-1，用于显示欧洲使用的语言，包括荷兰、丹麦、德语、意大利语、西班牙语等。
ISO-8859-1使用单字节编码，兼容ASCII编码。不支持中文

GBxxx字符集：国标

GB就是国标的意思，是为了显示中文而设计的一套字符集。兼容ASCII表
GB2312：简体中文码表。 7000多个简体汉字
GBK:目前操作系统默认中文码表(简体,繁体),存储一个中文使用2个字节,21003个汉字
GB18030：最新的中文码表。包含的文字最全(简体,繁体,少数民族,日韩文字)

Unicode字符集 ：万国码

UTF-8:最常用的万国表,兼容所有国家的文字
编码规则:
- 128个US-ASCII字符，只需一个字节编码。
- 拉丁文等字符，需要二个字节编码。
- 大部分常用字（含中文），使用三个字节编码。
- 其他极少使用的Unicode辅助字符，使用四字节编码。

2. 编码引出的问题

使用FileReader读取GBK编码的文件:会出现乱码,编码和解码不一致导致

package com.itheima.demo02reverseStream;import java.io.FileReader;
import java.io.IOException;/*使用FileReader读取GBK编码的文件:会出现乱码,编码和解码不一致导致GBK编码(中文编码):一个中文占用2个字节UTF-8编码(万国码):一个中文占用3个字节*/
public class Demo01FileReader {public static void main(String[] args) throws IOException {FileReader fr = new FileReader("day17\\gbk.txt");int len = 0;while ((len=fr.read())!=-1){System.out.print((char)len);//��� 乱码 }fr.close();}
}

3.转换流的原理(扩展-了解)

4.InputStreamReader:字符转换输入流(重点)

java.io.InputStreamReader:字符转换输入流 extends Reader
作用:InputStreamReader 是字节流通向字符流的桥梁：它使用指定的 charset 读取字节并将其解码为字符。解码:字节==>字符
继续自父类的共性成员方法:int read()读取单个字符。int read(char[] cbuf)将字符读入数组。void close() 关闭该流并释放与之关联的所有资源。
构造方法:InputStreamReader(InputStream in) 创建一个使用默认字符集的 InputStreamReader。InputStreamReader(InputStream in, String charsetName) 创建使用指定字符集的 InputStreamReader。参数:InputStream in:传递字节输入流,可以传递InputStream的任意的子类对象(读取文件中的字节)String charsetName:传递编码表名称,不区分大小写,可以传递GBK(gbk),UTF-8(utf-8),...,不写默认使用IDEA的编码UTF-8

package com.itheima.demo02reverseStream;import java.io.*;/*InputStreamReader:字符转换输入流(重点)作用:可以读取任意编码的文件解码:字节==>字符使用步骤:1.创建InputStreamReader对象,构造方法中传递FileInputStream对象和指定的编码表名称2.使用InputStreamReader对象中的方法read,以指定的编码读取文件3.释放资源注意:构造方法中指定的编码表名称必须和文件的编码一致,否则读取的数据就是乱码*/
public class Demo02InputStreamReader {public static void main(String[] args) throws IOException {//read_gbk();read_utf8();}/*使用InputStreamReader读取UTF-8编码的文件*/private static void read_utf8() throws IOException {//1.创建InputStreamReader对象,构造方法中传递FileInputStream对象和指定的编码表名称//InputStreamReader isr = new InputStreamReader(new FileInputStream("day17\\utf8.txt"),"GBK");//浣犲ソ//InputStreamReader isr = new InputStreamReader(new FileInputStream("day17\\utf8.txt"),"UTF-8");//你好InputStreamReader isr = new InputStreamReader(new FileInputStream("day17\\utf8.txt"));//你好 不写编码表名称默认UTF-8//2.使用InputStreamReader对象中的方法read,以指定的编码读取文件//int read()读取单个字符。int len = 0;while ((len = isr.read())!=-1){System.out.print((char)len);}//3.释放资源isr.close();}/*使用InputStreamReader读取GBK编码的文件*/private static void read_gbk() throws IOException {//1.创建InputStreamReader对象,构造方法中传递FileInputStream对象和指定的编码表名称InputStreamReader isr = new InputStreamReader(new FileInputStream("day17\\gbk.txt"),"GBK");//2.使用InputStreamReader对象中的方法read,以指定的编码读取文件//int read()读取单个字符。int len = 0;while ((len = isr.read())!=-1){System.out.print((char)len);}//3.释放资源isr.close();}
}

5.OutputStreamWriter:字符转换输出流(重点)

java.io.OutputStreamWriter:字符转换输出流 extends Writer
作用:OutputStreamWriter 是字符流通向字节流的桥梁：可使用指定的 charset 将要写入流中的字符编码成字节。编码:字符==>字节
继续自父类的共性成员方法:public abstract void close() ：关闭此输出流并释放与此流相关联的任何系统资源。public abstract void flush() ：刷新此输出流并强制任何缓冲的输出字符被写出。public void write(int c) ：写出一个字符。public void write(char[] cbuf) ：将 b.length字符从指定的字符数组写出此输出流。public abstract void write(char[] b, int off, int len) ：从指定的字符数组写出 len字符，从偏移量 off开始输出到此输出流。public void write(String str) ：写出一个字符串。public void write(String str, int off, int len) 写入字符串的某一部分。
构造方法:OutputStreamWriter(OutputStream out) 创建使用默认字符编码的 OutputStreamWriter。OutputStreamWriter(OutputStream out, String charsetName) 创建使用指定字符集的 OutputStreamWriter。参数:OutputStream out:传递字节输出流,可以传递OutputStream的任意子类对象(把字符转换之后的字节写入到文件中)String charsetName:传递编码表名称,不区分大小写,可以传递GBK(gbk),UTF-8(utf-8),...,不写默认使用IDEA的编码UTF-8

package com.itheima.demo02reverseStream;import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;/*OutputStreamWriter:字符转换输出流(重点)作用:可以写任意编码的文件编码:字符==>字节使用步骤:1.创建OutputStreamWriter对象,构造方法中传递FileOutputStream对象和指定的编码表名称2.使用OutputStreamWriter对象中的方法write,以指定编码把数据写入到内存缓冲区中(编码:字符==>字节)3.使用OutputStreamWriter对象中的方法flush,把内存缓冲区中的数据刷新到文件中(使用字节输出流写字节到文件中)4.释放资源(会先调用flush方法刷新数据)*/
public class Demo03OutputStreamWriter {public static void main(String[] args) throws IOException {//write_GBK();write_UTF8();}/*使用OutputStreamWriter写UTF-8编码的文件*/private static void write_UTF8() throws IOException {//1.创建OutputStreamWriter对象,构造方法中传递FileOutputStream对象和指定的编码表名称//OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("day17\\utf82.txt"),"utf-8");OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("day17\\utf83.txt"));//不写编码表名称,默认IDEA的UTF-8//2.使用OutputStreamWriter对象中的方法write,以指定编码把数据写入到内存缓冲区中(编码:字符==>字节)osw.write("你好");//3.使用OutputStreamWriter对象中的方法flush,把内存缓冲区中的数据刷新到文件中(使用字节输出流写字节到文件中)osw.flush();//4.释放资源(会先调用flush方法刷新数据)osw.close();}/*使用OutputStreamWriter写GBK编码的文件*/private static void write_GBK() throws IOException {//1.创建OutputStreamWriter对象,构造方法中传递FileOutputStream对象和指定的编码表名称OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("day17\\gbk2.txt"),"gbk");//2.使用OutputStreamWriter对象中的方法write,以指定编码把数据写入到内存缓冲区中(编码:字符==>字节)osw.write("你好");//3.使用OutputStreamWriter对象中的方法flush,把内存缓冲区中的数据刷新到文件中(使用字节输出流写字节到文件中)osw.flush();//4.释放资源(会先调用flush方法刷新数据)osw.close();}
}

6.练习：转换文件编码

将GBK编码的文本文件，转换为UTF-8编码的文本文件。

package com.itheima.demo02reverseStream;import java.io.*;/*练习：转换文件编码将GBK编码的文本文件，转换为UTF-8编码的文本文件。分析:1.创建InputStreamReader对象,构造方法中传递FileInputStream对象和GBK编码名称2.创建OutputStreamWriter对象,构造方法中传递FileOutputStream对象和UTF-8编码名称3.使用InputStreamReader对象中的方法read,以GBK编码读取文件4.使用OutputStreamWriter对象中的方法write,以UTF-8编码写入数据5.释放资源*/
public class Demo04Test {public static void main(String[] args) throws IOException {//1.创建InputStreamReader对象,构造方法中传递FileInputStream对象和GBK编码名称InputStreamReader isr = new InputStreamReader(new FileInputStream("day17\\gbk.txt"),"GBK");//2.创建OutputStreamWriter对象,构造方法中传递FileOutputStream对象和UTF-8编码名称//OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("day17\\utf84.txt"),"UTF-8");//OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("day17\\utf85.txt"));//不写编码表名称默认UTF-8FileWriter osw = new FileWriter("day17\\utf86.txt");//3.使用InputStreamReader对象中的方法read,以GBK编码读取文件int len = 0;while ((len = isr.read())!=-1){//你好//4.使用OutputStreamWriter对象中的方法write,以UTF-8编码写入数据osw.write(len);//你好}//5.释放资源osw.close();isr.close();}
}

总结:

什么时候使用FileReader和FileWriter(读取字符的便捷类):读写的文件都是IDEA默认编码utf-8的文件
什么时候使用InputStreamReader和OutputStreamWriter:读写的文件不是IDEA默认编码utf-8的文件

第三章序列化流

1.序列化流和反序列流的概述

2.ObjectOutputStream:对象的序列化流(重点)

package com.itheima.demo03SerializableStream;import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;/*java.io.ObjectOutputStream:对象的序列化流 extends OutputStream:字节输出流作用:写对象把对象以流的方式写入到文件中保存(网络编程:把对象在客户端和服务器之间写)构造方法:ObjectOutputStream(OutputStream out) 创建写入指定 OutputStream 的 ObjectOutputStream。参数:OutputStream out:传递OutputStream字节输出流,可以传递OutputStream的任意的子类对象特有的方法:void writeObject(Object obj) 将指定的对象写入 ObjectOutputStream。使用步骤:1.创建ObjectOutputStream对象,构造方法中传递FileOutputStream对象2.使用ObjectOutputStream对象中的方法writeObject,把对象写入到文件中3.释放资源*/
public class Demo01ObjectOutputStream {public static void main(String[] args) throws IOException {//1.创建ObjectOutputStream对象,构造方法中传递FileOutputStream对象ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("day17\\person.txt"));//2.使用ObjectOutputStream对象中的方法writeObject,把对象写入到文件中oos.writeObject(new Person("小美女",18));//3.释放资源oos.close();}
}

package com.itheima.demo03SerializableStream;import java.io.Serializable;/*在进行序列化的时候,程序抛出了NotSerializableException:没有序列化异常类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。Serializable接口我们称之为是一个标记型接口,类(Person)实现类Serializable接口,接口就会给类(Person)添加一个标记(序列号)当我们在进行序列化和反序列化的时候,会检查类(Person)上是否有标记有:可以进行序列化和反序列化没有:抛出NotSerializableException异常*/
public class Person implements Serializable{private String name;private int age;public Person() {}public Person(String name, int age) {this.name = name;this.age = age;}@Overridepublic String toString() {return "Person{" +"name='" + name + '\'' +", age=" + age +'}';}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}
}

3.ObjectInputStream:对象的反序列化流(重点)

package com.itheima.demo03SerializableStream;import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;/*java.io.ObjectInputStream:对象的反序列化流作用:读对象把保存在文件中的对象,以流的方式读取出来(网络编程:可以在客户端和服务器之间读取对象)构造方法:ObjectInputStream(InputStream in) 创建从指定 InputStream 读取的 ObjectInputStream。参数:InputStream in:传递字节输入流,可以传递InputStream的任意的子类对象特有的成员方法:Object readObject() 从 ObjectInputStream 读取对象。使用步骤:1.创建ObjectInputStream对象,构造方法中传递FileInputStream对象2.使用ObjectInputStream对象中的放readObject,读取文件中保存的对象3.释放资源-----------------------------------------------------------------------public final Object readObject()throws IOException, ClassNotFoundExceptionreadObject方法声明抛出了两个异常ClassNotFoundException:class文件找不到异常注意:反序列化有两个前提 1.类(Person)实现了Serializable接口 2.存在Person.class文件*/
public class Demo02ObjectInputStream {public static void main(String[] args) throws IOException, ClassNotFoundException {//1.创建ObjectInputStream对象,构造方法中传递FileInputStream对象ObjectInputStream ois = new ObjectInputStream(new FileInputStream("day17\\person.txt"));//2.使用ObjectInputStream对象中的放readObject,读取文件中保存的对象Object obj = ois.readObject();System.out.println(obj);//向下转型Person p = (Person)obj;System.out.println(p.getName()+"\t"+p.getAge());//3.释放资源ois.close();}
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-c4LAY6JQ-1645715173198)(img/1639122708283.png)]

4.transient:瞬态关键字

transient:瞬态关键字被transient关键修饰的变量不能被序列化private transient int age;oos.writeObject(new Person("小美女",18)); 不会把18写入到文件中Object obj = ois.readObject();  Person{name='小美女', age=0}

5.序列号冲突异常(扩展-了解)

/*Serializable接口规定:可序列化类可以通过声明名为 "serialVersionUID" 的字段（该字段必须是静态 (static)、最终 (final) 的 long 型字段）显式声明其自己的 serialVersionUID：static final long serialVersionUID = 任意值L;在类中手动添加了一个序列号,无论类是否有修改,序列号都固定为我们写的常量值,值是不会改变的,也不会抛出异常了例如:public final class String implements java.io.Serializable    private static final long serialVersionUID = -6849794470754667710L;*/
public class Person implements Serializable{private static final long serialVersionUID = 1L;private String name;//private transient int age;//private int age;public int age;
}

6.练习:序列化集合

package com.itheima.demo03SerializableStream;import java.io.*;
import java.util.ArrayList;/*练习:序列化集合*/
public class Demo03Test {public static void main(String[] args) throws IOException, ClassNotFoundException {show02();}/*把多个对象存储到一个集合中,集合也是一个对象使用序列化流把集合写入到文件中使用返回序列化流把文件中的集合对象读取出来*/private static void show02() throws IOException, ClassNotFoundException {//把多个对象存储到一个集合中,集合也是一个对象ArrayList<Person> list = new ArrayList<>();list.add(new Person("张三",18));list.add(new Person("李四",18));list.add(new Person("王五",18));list.add(new Person("赵六",18));list.add(new Person("田七",18));//使用序列化流把集合写入到文件中ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("day17\\list02.txt"));oos.writeObject(list);oos.close();//使用返回序列化流把文件中的集合对象读取出来ObjectInputStream ois = new ObjectInputStream(new FileInputStream("day17\\list02.txt"));Object obj = ois.readObject();//想遍历集合,可以向下转型ArrayList<Person> list2 = (ArrayList<Person>)obj;for (Person p : list2) {System.out.println(p);}}/*使用序列化流写多个对象到文件中使用反序列化读取文件中保存的多个对象*/private static void show01() throws IOException, ClassNotFoundException {//使用序列化流写多个对象到文件中ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("day17\\list01.txt"));oos.writeObject(new Person("张三",18));oos.writeObject(new Person("李四",18));oos.writeObject(new Person("王五",18));oos.writeObject(new Person("赵六",18));oos.writeObject(new Person("田七",18));oos.close();//使用反序列化读取文件中保存的多个对象ObjectInputStream ois = new ObjectInputStream(new FileInputStream("day17\\list01.txt"));Object obj = ois.readObject();System.out.println(obj);//Person{name='张三', age=18}System.out.println(ois.readObject());//Person{name='李四', age=18}System.out.println(ois.readObject());//Person{name='王五', age=18}System.out.println(ois.readObject());//Person{name='赵六', age=18}System.out.println(ois.readObject());//Person{name='田七', age=18}//System.out.println(ois.readObject());//EOFException 当输入过程中意外到达文件或流的末尾时，抛出此异常。//read方法读取到文件末尾返回-1  readLine读取到文件末尾返回nullois.close();}
}

第四章打印流

1.介绍

java.io.PrintStream:字节打印流 extends OutputStream
特点:1.PrintStream 为其他输出流添加了功能，使它们能够方便地打印各种数据值表示形式。PrintStream流中有两个特有的方法:print,println2.与其他输出流不同，PrintStream 永远不会抛出 IOException;创建对象的时候,可能会抛出文件找不到异常3.PrintStream是打印流,值负责打印(输出),不能读取
构造方法:PrintStream(File file) 打印流的目的地是一个文件PrintStream(OutputStream out) 打印流的目的地是一个字节输出流PrintStream(String fileName) 打印流的目的地是一个文件路径
成员方法:1.继承自父类的共性成员方法write:使用write写数据,查看的时候,会查询编码表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 void flush() 刷新此输出流并强制写出所有缓冲的输出字节。public void close() ：关闭此输出流并释放与此流相关联的任何系统资源。2.自己特有的成员方法:print,println写数据,原样输出void print(Object obj)   可以写任意类型的数据,不换行void println(Object obj)  可以写任意类型的数据,换行

2.基本使用(重点)

package com.itheima.demo04PrintStream;import java.io.FileNotFoundException;
import java.io.PrintStream;/*java.io.PrintStream:字节打印流 extends OutputStream使用步骤:1.创建PrintStream对象,构造方法中绑定指定的目的地2.使用PrintStream对象中的方法write,print,println,把数据写入到文件中3.释放资源*/
public class Demo01PrintStream {public static void main(String[] args) throws FileNotFoundException {//1.创建PrintStream对象,构造方法中绑定指定的目的地PrintStream ps = new PrintStream("day17\\1.txt");//2.使用PrintStream对象中的方法write,print,println,把数据写入到文件中//1.继承自父类的共性成员方法write:使用write写数据,查看的时候,会查询编码表ps.write(97);//a//2.自己特有的成员方法:print,println写数据,原样输出ps.println(97);//97ps.println("你好");//你好ps.println('#');//#ps.println(1.1);//1.1ps.println(true);//true//3.释放资源ps.close();}
}

3.修改输出语句的目的地为打印流的目的地(了解)

package com.itheima.demo04PrintStream;import java.io.FileNotFoundException;
import java.io.PrintStream;/*修改输出语句的目的地为打印流的目的地(了解)输出语句:使用的就是打印流,把数据打印在控制台java.lang.System类静态方法setOutstatic void setOut(PrintStream out) 修改输出语句的目的地为打印流的目的地不在控制台输出数据*/
public class Demo02PrintStream {public static void main(String[] args) throws FileNotFoundException {System.out.println("输出语句的目的地,默认就是控制台!");//创建一个打印流对象PrintStream ps = new PrintStream("day17\\2.txt");System.setOut(ps);//修改输出语句的目的地(控制台)为打印流的目的地System.out.println(1);System.out.println(2);System.out.println(3);System.out.println("输出语句的目的地,就不是控制台了,是2.txt文件!");}
}

2.txt

1
2
3
输出语句的目的地,就不是控制台了,是2.txt文件!

第五章装饰设计模式(重点)

1.代码实现

package com.itheima.demo05Wapper;import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;/*装饰者设计模式设计一个手机类打电话的功能发短信的功能需求变更:对打电话的功能进行增强,打电话之前听彩铃但是有的人喜欢彩铃,有的人不喜欢不能在打电话的原有的功能上进行修改,一旦修改了,所有的手机都必须听彩铃解决:可以使用装饰者设计模式对手机对象进行装饰,让喜欢听彩铃的人,打电话之前听彩铃使用一个类对手机对象进行装饰==>对打电话的方法进行装饰==>打电话之前听彩铃没有装饰者的手机==>调用原来打电话的功能*/
public class Demo01Wapper {public static void main(String[] args) throws IOException {FirstPhone fp1 = new FirstPhone();fp1.call();fp1.sendMessage();System.out.println("-----------------------------");//使用装饰者对FirstPhone对象进行装饰PhoneWapper pw = new PhoneWapper(fp1);pw.call();pw.sendMessage();System.out.println("-----------------------------");//在java中有很多的装饰者案例FileReader fr = new FileReader("day17\\1.txt");int len = fr.read();//一次读取一个字符,效率低下//BufferedReader就是一个装饰者类,给FileReader进行装饰,给FileReader增加了一个缓冲区,提高FileReader读取文件的效率BufferedReader br = new BufferedReader(fr);int len2 = br.read();//把读取的字符存储到缓冲区中,可以提高效率}
}

package com.itheima.demo05Wapper;public abstract class Phone {public abstract void call();public abstract void sendMessage();
}

package com.itheima.demo05Wapper;public class FirstPhone extends Phone{@Overridepublic void call() {System.out.println("使用手机打电话!");}@Overridepublic void sendMessage() {System.out.println("使用手机发发短信!");}
}

package com.itheima.demo05Wapper;/*手机的装饰者类要求:1.把要装饰的手机对象传递类中,对手机对象进行装饰可以定义一个Phone类型的成员变量,使用构造方法给变量赋值2.装饰者类必须和被装饰的类有同一个父类,或者实现同一个接口*/
public class PhoneWapper extends Phone{//定义一个Phone类型的成员变量private Phone phone;//使用构造方法给变量赋值public PhoneWapper(Phone phone) {this.phone = phone;}@Overridepublic void call() {//对打电话方法进行装饰System.out.println("打电话之前先听彩铃");phone.call();}@Overridepublic void sendMessage() {//发短信的功能不变phone.sendMessage();}
}

2.装饰模式小结

装饰模式可以在不改变原类的基础上对类中的方法进行扩展增强,实现原则为:

装饰类和被装饰类必须实现相同的接口,继承相同的父类
在装饰类中必须传入被装饰类的对象,使用构造方法传递
在装饰类中对需要扩展的方法进行扩展
在装饰类中对不需要扩展的方法调用被装饰类中的同名方法

第六章 commons-io工具包

1.概述

commons-io是apache开源基金组织提供的一组有关IO操作的类库，可以挺提高IO功能开发的效率。commons-io工具包提供了很多有关io操作的类，见下表：

包	功能描述
org.apache.commons.io	有关Streams、Readers、Writers、Files的工具类
org.apache.commons.io.input	输入流相关的实现类，包含Reader和InputStream
org.apache.commons.io.output	输出流相关的实现类，包含Writer和OutputStream
org.apache.commons.io.serialization	序列化相关的类

2.添加第三方jar包到模块中(重点中的重点)

步骤：

步骤：
1. 下载commons-io相关jar包；http://commons.apache.org/proper/commons-io/
2. 把commons-io-2.6.jar包复制到指定的Module的lib目录中

将commons-io-2.6.jar加入到classpath中

![请添加图片描述](https://img-blog.csdnimg.cn/b7151c2845c1403c8614f120bb60932e.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA54Gw54Gw5piv5pyo5pyo,size_13,color_FFFFFF,t_70,g_se,x_16)

3.IOUtils基本使用

package com.itheima.demo06commonsIO;import org.apache.commons.io.IOUtils;import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;/*org.apache.commons.io.IOUtils:操作IO流的工具类1. public static int copy(InputStream in, OutputStream out)；把input输入流中的内容拷贝到output输出流中，返回拷贝的字节个数(适合文件大小为2GB以下)2. public static long copyLarge(InputStream in, OutputStream out)；把input输入流中的内容拷贝到output输出流中，返回拷贝的字节个数(适合文件大小为2GB以上)*/
public class Demo01IOUtils {public static void main(String[] args) throws IOException {//使用IOUtils工具类中的方法copy复制文件//int l1 = IOUtils.copy(new FileInputStream("c:\\1.jpg"), new FileOutputStream("d:\\1.jpg"));//System.out.println(l1);//161,548 字节//使用IOUtils工具类中的方法copyLarge复制文件long l2 = IOUtils.copyLarge(new FileInputStream("c:\\748m.rar"), new FileOutputStream("d:\\748m.rar"));System.out.println(l2);//785042177字节}
}

4.FileUtils基本使用

package com.itheima.demo06commonsIO;import org.apache.commons.io.FileUtils;import java.io.File;
import java.io.IOException;/*org.apache.commons.io.FileUtils:操作文件的工具类static String readFileToString(File file) 读取一个文件以字符串的形式返回static void writeStringToFile(File file, String data)  把字符串写到一个文件中static void copyFile(File srcFile, File destFile)  文件复制static void copyFileToDirectory(File srcFile, File destDir)  把一个文件复制到一个文件夹static void copyDirectoryToDirectory(File srcDir, File destDir)  文件夹复制注意:以上5个方法参数全是File对象*/
public class Demo01FileUtils {public static void main(String[] args) throws IOException {show05();}/*static void copyDirectoryToDirectory(File srcDir, File destDir)  文件夹复制*/private static void show05() throws IOException {FileUtils.copyDirectoryToDirectory(new File("c:\\demo"),new File("d:\\"));}/*static void copyFileToDirectory(File srcFile, File destDir)  把一个文件复制到一个文件夹*/private static void show04() throws IOException {FileUtils.copyFileToDirectory(new File("c:\\2.jpg"),new File("d:\\aaa"));}/*static void copyFile(File srcFile, File destFile)  文件复制*/private static void show03() throws IOException {FileUtils.copyFile(new File("c:\\2.jpg"),new File("d:\\2.jpg"));}/*static void writeStringToFile(File file, String data)  把字符串写到一个文件中*/private static void show02() throws IOException {FileUtils.writeStringToFile(new File("day17\\3.txt"),"你好");}/*static String readFileToString(File file) 读取一个文件以字符串的形式返回*/private static void show01() throws IOException {String s = FileUtils.readFileToString(new File("day17\\csbzx.txt"));System.out.println(s);}
}

总结:

1.缓冲流的作用:给基本的流增加缓冲区,提高基本的流的读写的效率

2.转换流:可以指定编码表,来读写任意编码的文件

3.序列化流:可以读写对象

4.打印流:有一些特有的print,println方法,可以打印(输出)任意类型的数据

5.装饰者设计模式:装饰模式可以在不改变原类的基础上对类中的方法进行扩展增强

6.commons-io工具包:简化IO的操作