File类和IO流

文章目录

File类和IO流
@[TOC](文章目录)
前言
一、java.io.File类&IO流原理及流的分类
1.1 File类及其API
1.2 IO流原理及分类

二、节点流的介绍（字符/字节）
2.1 Reader\Writer--字符IO`抽象基类`
2.2 FileReader\FileWriter--字符IO`节点流`
2.3 InputStream\OutputStream--字节IO`抽象基类`
2.4 FileInputStream/FileOutputStream--字节IO`节点流`

三、处理流的介绍
3.1 缓冲流Buffered--字符流/字节流
3.2 转换流InputStreamReader/OutputStreamWriter（字符-字节）
3.3 数据流&对象流--字节
3.4 补充：序列化&反序列化机制

四、其他流的使用
4.1 标准输入、输出流
4.2 打印流PrintStream/PrintWriter
4.3 Scanner类
4.4 apache-common包的使用

五、企业真题

前言

File及各种流都在java.io包下

知识补充：绝对路径&相对路径

绝对路径：从盘符开始的路径，这是一个完整的路径。
相对路径：相对于项目目录的路径，这是一个便捷的路径，开发中经常使用。
- IDEA中，main中的文件的相对路径，是相对于"当前工程"
- IDEA中，单元测试方法中的文件的相对路径，是相对于"当前module"

一、java.io.File类&IO流原理及流的分类

1.1 File类及其API

1、File类的理解：——流的端点

File类位于java.io包下，本章中涉及到的相关流也都声明在java.io包下。
File类的一个对象，对应与操作系统下的一个文件或一个文件目录(或文件夹)
File类中声明了新建、删除、获取名称、重命名、删除等操作并没有涉及到文件内容的读写操作——需要使用IO流
File类的对象，通常是作为io流操作的文件的端点出现

2、File的内部构造器&API
（1）构造器——创建File对象

public File(String pathname) ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
public File(String parent, String child) ：以parent为父路径，child为子路径创建File对象。
public File(File parent, String child) ：根据一个父File对象和子文件路径创建File对象

（2）常用方法

获取文件和目录的基本信息：
- public String getName() ：获取名称
- public String getPath() ：获取路径，创建File对象提供的路径
- public String getAbsolutePath()：获取绝对路径（完整）
- public File getAbsoluteFile()：获取绝对路径表示的文件
- public String getParent()：获取上层文件目录路径。若无，返回null
- public long length() ：获取文件长度（即：字节数）。不能获取目录的长度–递归可以。
- public long lastModified() ：获取最后一次的修改时间，毫秒值

File file1 = new File("abc.txt");
String str1 = file.getParent();//相对路径的上层文件目录为空
String str1 = file.getAbsolutePath().getParent();//先得到绝对路径，再根据绝对路径得到当前文件的上层文件路径
File file2 = new File("src/abc.txt");
String str2 = file.getParent();//上层目录为src

列出文件的下一级：
- public String[] list() ：表示该File目录中的所有子文件或目录。——可以添加过滤器FilenameFilter()，需重写方法public boolean accept(File dir, String name)
- public File[] listFiles() ：表示该File目录中的所有的子文件或目录。
File类的重命名功能：
- public boolean renameTo(File dest):把文件重命名为指定的文件路径。
判断功能的方法：
- public boolean exists()、isDirectory()、isFile() 、canRead()、canWrite()、isHidden()：此File表示的文件或目录是否实际存在、是否为目录、是否为文件、可读、可写、隐藏。
创建或者删除：
- public boolean createNewFile()、mkdir()、mkdirs()、delete()：创建文件，如果已存在则不创建返回false；创建文件目录，如果已存在/上层目录不存在则不创建；创建文件，如果上层不存在则一起创建；删除文件或文件夹（不走回收站，如果是文件目录则里面不能包含文件/文件目录）

判断指定目录下是否有后缀名为.jpg的文件。如果有，就输出该文件名称

public class FindJPGFileTest {//方法1：@Testpublic void test1(){File srcFile = new File("d:\\code");String[] fileNames = srcFile.list();for(String fileName : fileNames){if(fileName.endsWith(".jpg")){System.out.println(fileName);}}}//方法2：@Testpublic void test2(){File srcFile = new File("d:\\code");File[] listFiles = srcFile.listFiles();for(File file : listFiles){if(file.getName().endsWith(".jpg")){System.out.println(file.getAbsolutePath());}}}//方法3：/** File类提供了两个文件过滤器方法* public String[] list(FilenameFilter filter)* public File[] listFiles(FileFilter filter)*/@Testpublic void test3(){File srcFile = new File("d:\\code");File[] subFiles = srcFile.listFiles(new FilenameFilter() {@Overridepublic boolean accept(File dir, String name) {return name.endsWith(".jpg");}});for(File file : subFiles){System.out.println(file.getAbsolutePath());}}}

遍历指定目录所有文件名称，包括子文件目录中的文件。
拓展1：并计算指定目录占用空间的大小
拓展2：删除指定文件目录及其下的所有文件

public class ListFilesTest {//练习3：(方式1)public static void printSubFile(File dir) {// 打印目录的子文件File[] subfiles = dir.listFiles();for (File f : subfiles) {if (f.isDirectory()) {// 文件目录printSubFile(f);} else {// 文件System.out.println(f.getAbsolutePath());//输出绝对路径}}}// //练习3：(方式2)public void listAllSubFiles(File file) {if (file.isFile()) {System.out.println(file);} else {File[] all = file.listFiles();// 如果all[i]是文件，直接打印// 如果all[i]是目录，接着再获取它的下一级for (File f : all) {listAllSubFiles(f);// 递归调用：自己调用自己就叫递归}}}@Testpublic void testListAllFiles(){// 1.创建目录对象File dir = new File("E:\\teach\\01_javaSE\\_尚硅谷Java编程语言\\3_软件");// 2.打印目录的子文件printSubFile(dir);}// 拓展1：求指定目录所在空间的大小public long getDirectorySize(File file) {// file是文件，那么直接返回file.length()// file是目录，把它的下一级的所有file大小加起来就是它的总大小long size = 0;if (file.isFile()) {size = file.length();} else {File[] all = file.listFiles();// 获取file的下一级// 累加all[i]的大小for (File f : all) {size += getDirectorySize(f);// f的大小;}}return size;}// 拓展2：删除指定的目录public void deleteDirectory(File file) {// 如果file是文件，直接delete// 如果file是目录，先把它的下一级干掉，然后删除自己if (file.isDirectory()) {File[] all = file.listFiles();// 循环删除的是file的下一级for (File f : all) {// f代表file的每一个下级deleteDirectory(f);}}// 删除自己file.delete();}
}

1.2 IO流原理及分类

1、Java IO流原理：
Java程序中，对于数据的输入/输出操作以“流(stream)” 的方式进行，可以看做是一种数据的流动。
I/O流中的I/O是Input/Output的缩写， I/O技术是非常实用的技术，用于处理设备之间的数据传输。如读/写文件，网络通讯等。

输入input：读取外部数据（磁盘、光盘等存储设备的数据）到程序（内存）中。
输出output：将程序（内存）数据输出到磁盘、光盘等存储设备中。

IO流的场景
2、流的分类

按数据的流向不同分为：输入流和输出流。
- 输入流 ：把数据从其他设备上读取到内存中的流。
- 输出流 ：把数据从内存 中写出到其他设备上的流。
按操作数据单位的不同分为：字节流（8bit）和字符流（16bit）。
- 字节流 ：以字节为单位，读写数据的流。
- 字符流 ：以字符为单位，读写数据的流。
根据IO流的角色不同分为：节点流和处理流。
- 节点流：直接从数据源或目的地读写数据
- 处理流：不直接连接到数据源或目的地，而是“连接”在已存在的流（节点流或处理流）之上，通过对数据的处理为程序提供更为强大的读写功能。

3、流的API
流的API理解：字符流可以是输入/输出流，也可以是节点流/处理流，字节流同样也是。
节点流可以是字符流/字节流，处理流也是

4个抽象基类：以其父类名作为子类名后缀

抽象基类	抽象基类	节点流	缓冲流(处理流的一种)	转换流	对象流
字节输入	InputStream	FileInputStream	BufferedInputStream		ObjectInputStream
字节输出	OutputStream	FileOutputStream	BufferedOutputStream		ObjecOutputStream
字符输入	Reader	FileReader	BufferedReader	InputStreamReader
字符输出	Writer	FileWriter	BufferedWriter	OutputStreamWriter

上述处理流连接每一行对应的节点流/处理流。

常用的节点流：
- 文件流： FileInputStream、FileOutputStrean、FileReader、FileWriter
- 字节/字符数组流： ByteArrayInputStream、ByteArrayOutputStream、CharArrayReader、CharArrayWriter
- 对数组进行处理的节点流（对应的不再是文件，而是内存中的一个数组）。
常用处理流：
- 缓冲流：BufferedInputStream、BufferedOutputStream、BufferedReader、BufferedWriter
  - 作用：增加缓冲功能，避免频繁读写硬盘，进而提升读写效率。
- 转换流：InputStreamReader、OutputStreamReader
  - 作用：实现字节流和字符流之间的转换。
- 对象流：ObjectInputStream、ObjectOutputStream
  - 作用：提供直接读写Java对象功能

二、节点流的介绍（字符/字节）

1、字符流说明：Java提供一些字符流类，以字符为单位读写数据，专门用于处理文本文件。不能操作图片，视频等非文本文件。
常见的文本文件有如下的格式：.txt、.java、.c、.cpp、.py等。注意：.doc、.xls、.ppt这些都不是文本文件。
2、字节流说明：非文本文件，必须使用字节流。如图片

FileReader、FileWriter本质上调用的还是FileInputStream、FileOutputStream字节流

2.1 Reader\Writer–字符IO`抽象基类`

1、java.io.Reader抽象类：用于读取字符流的所有类的父类，可以读取字符信息到内存中。定义了字符输入流的基本共性功能方法。

public int read()：从输入流读取一个字符。虽然读取了一个字符，但是会自动提升为int类型。返回该字符的Unicode编码值。如果已经到达流末尾了，则返回-1。
public int read(char[] cbuf)：从输入流中读取一些字符，并将它们存储到字符数组 cbuf中。每次最多读取cbuf.length个字符。返回实际读取的字符个数。如果已经到达流末尾，没有数据可读，则返回-1。
public int read(char[] cbuf,int off,int len)：从输入流中读取一些字符，并将它们存储到字符数组 cbuf中，从cbuf[off]开始的位置存储。每次最多读取len个字符。返回实际读取的字符个数。如果已经到达流末尾，没有数据可读，则返回-1。
public void close() ：关闭此流并释放与此流相关联的任何系统资源。释放系统资源，否则会造成内存泄漏。

2、java.io.Writer 抽象类：用于写出字符流的所有类的超类，将指定的字符信息写出到目的地。定义了字节输出流的基本共性功能方法。

public void write(int c) ：写出单个字符。
public void write(char[] cbuf) ：写出字符数组。
public void write(char[] cbuf, int off, int len) ：写出字符数组的某一部分。off：数组的开始索引；len：写出的字符个数。
public void write(String str) ：写出字符串。
public void write(String str, int off, int len) ：写出字符串的某一部分。off：字符串的开始索引；len：写出的字符个数。
public void flush() ：刷新该流的缓冲。
public void close() ：关闭此流。

2.2 FileReader\FileWriter–字符IO`节点流`

FileReader：文件不存在读取不了
FileWriter：文件不存在会自动创建一个写入，如果已经存在-追加？覆盖？——可以设置

1、执行步骤：

第1步：创建读取或写出的File类的对象
第2步：创建输入流或输出流
第3步：具体的读入或写出的过程。
- 读入：read(char[] cbuffer)//造小车 / read()//一个一个读
- 写出：write(string str) / write(char[] cbuffer,0,len)
第四步：关闭流资源，避免内存泄漏

2、注意点

因为涉及到流资源的关闭操作，所以出现异常的话，需要使用try-catch-finally的方式来处理异常
对于输入流来讲，要求File类的对象对应的物理磁盘上的文件必须存在。否则，会报FileNotFoundException
对于输出流来讲，File类的对象对应的物理磁盘上的文件可以不存在。
- 如果此文件不存在，则在输出的过程中，会自动创建此文件，并写出数据到此文件中。
- 如果此文件存在，使用 FileWriter(File file)或 FileWriter(File file,false)：输出数据过程中，会新建同名的文件对现有的文件进行覆盖。FileWriter(File file,true)：输出数据过程中，会在现有的文件的末尾追加写出内容

3、Java.io.FileReader & java.io.FileWriter的API

java.io.FileReader 类用于读取字符文件，构造时使用系统默认的字符编码和默认字节缓冲区。
- FileReader(File file)：创建一个新的 FileReader ，给定要读取的File对象。
- FileReader(String fileName)：创建一个新的 FileReader ，给定要读取的文件的名称。
java.io.FileWriter：写出字符到文件，构造时使用系统默认的字符编码和默认字节缓冲区。
- FileWriter(File file)：创建一个新的 FileWriter，给定要读取的File对象。
- FileWriter(String fileName)：创建一个新的 FileWriter，给定要读取的文件的名称。
- FileWriter(File file,boolean append)：创建一个新的 FileWriter，指明是否在现有文件末尾追加内容。

4、flush（刷新）
内置缓冲区，FileWriter只有关闭输出流，才可将写字符写出到文件中。flush()方法可以实现既不关闭流，又可以写出数据。

flush() ：刷新缓冲区，流对象可以继续使用。
close()：先刷新缓冲区，然后通知系统释放资源。流对象不可以再被使用了。

读取hello.txt文件中的字符数据，并显示在控制台上——小车是每次读取/输出覆盖，最后每次读取/输出指定当前轮次的长度，避免最后覆盖不了
写入字符数据

public class FileReaderWriterTest {
//实现方式3：调用read(char[] cbuf),每次从文件中读取多个字符@Testpublic void test3() {FileReader fr = null;//避免文件不存在得到的是nul对象try {//1. 创建File类的对象，对应着物理磁盘上的某个文件File file = new File("hello.txt");//2. 创建FileReader流对象，将File类的对象作为参数传递到FileReader的构造器中fr = new FileReader(file);//3. 通过相关流的方法，读取文件中的数据char[] cbuf = new char[5];//造小车，每次读取5个字符/** read(char[] cbuf) : 每次将文件中的数据读入到cbuf数组中，并返回读入到数组中的* 字符的个数。* */int len; //记录每次读入的字符的个数while ((len = fr.read(cbuf)) != -1) {//处理char[]数组即可//错误：最后不足5个字符的小车没有完全覆盖前5个
//                for(int i = 0;i < cbuf.length;i++){
//                    System.out.print(cbuf[i]);
//                }//错误：同样的道理
//                String str = new String(cbuf);
//                System.out.print(str);//正确：长度使用当前循环轮次read的长度
//                for(int i = 0;i < len;i++){
//                    System.out.print(cbuf[i]);
//                }//正确：和上面是一样的String str = new String(cbuf, 0, len);System.out.print(str);}} catch (IOException e) {e.printStackTrace();} finally {//4. 关闭相关的流资源，避免出现内存泄漏try {if (fr != null)fr.close();} catch (IOException e) {e.printStackTrace();}}}@Testpublic void test04(){FileWriter fw = null;try {//1. 创建File的对象File file = new File("personinfo.txt");//2. 创建FileWriter的对象，将File对象作为参数传递到FileWriter的构造器中//如果输出的文件已存在，则会对现有的文件进行覆盖fw = new FileWriter(file);
//            fw = new FileWriter(file,false);//如果输出的文件已存在，则会在现有的文件末尾写入数据
//            fw = new FileWriter(file,true);//3. 调用相关的方法，实现数据的写出操作//write(String str) / write(char[] cbuf)fw.write("I love you,");fw.write("you love him.");fw.write("so sad".toCharArray());} catch (IOException e) {e.printStackTrace();} finally {//4. 关闭资源，避免内存泄漏try {if (fw != null)fw.close();} catch (IOException e) {throw new RuntimeException(e);}}}
}

2.3 InputStream\OutputStream–字节IO`抽象基类`

1、java.io.InputStream 抽象类：字节输入流的所有类的超类，读取字节信息到内存中。它定义了字节输入流的基本共性功能方法。

public int read()：从输入流读取一个字节。返回读取的字节值。虽然读取了一个字节，但是会自动提升为int类型。如果已经到达流末尾，没有数据可读，则返回-1。
public int read(byte[] b)：从输入流中读取一些字节数，并将它们存储到字节数组 b中。每次最多读取b.length个字节。返回实际读取的字节个数。如果已经到达流末尾，没有数据可读，则返回-1。
public int read(byte[] b,int off,int len)：从输入流中读取一些字节数，并将它们存储到字节数组 b中，从b[off]开始存储，每次最多读取len个字节。返回实际读取的字节个数。如果已经到达流末尾，没有数据可读，则返回-1。
public void close() ：关闭此输入流并释放与此流相关联的任何系统资源。

2、java.io.OutputStream 抽象类：字节输出流的所有类的超类，将指定的字节信息写出到目的地。它定义了字节输出流的基本共性功能方法。

public void write(int b) ：将指定的字节输出流。虽然参数为int类型四个字节，但是只会保留一个字节的信息写出。
public void write(byte[] b)：将 b.length字节从指定的字节数组写入此输出流。
public void write(byte[] b, int off, int len) ：从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。
public void flush() ：刷新此输出流并强制任何缓冲的输出字节被写出。
public void close()：关闭此输出流并释放与此流相关联的任何系统资源。

2.4 FileInputStream/FileOutputStream–字节IO`节点流`

1、执行步骤

第1步：创建读取或写出的File类的对象
第2步：创建输入流或输出流
第3步：具体的读入或写出的过程。读入:read(byte[] buffer)写出:write(byte[] buffer,0,len)
第4步：关闭流资源，避免内存泄漏

2、注意点：和FileReader、FileWriter基础之上

字符流只能处理文本文件，非文本文件不行
字节流通常用来处理非文本文件，但是如果涉及到文本文件的复制也可以。

3、输入/输出节点流的API：

java.io.FileInputStream ：文件输入流，从文件中读取字节。
- FileInputStream(File file)`：通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的 File对象 file命名。
- FileInputStream(String name)：通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名 name命名。
java.io.FileOutputStream ：文件输出流，用于将数据写出到文件。
- public FileOutputStream(File file)：创建文件输出流，写出由指定的 File对象表示的文件。
- public FileOutputStream(String name)：创建文件输出流，指定的名称为写出文件。
- public FileOutputStream(File file, boolean append)：创建文件输出流，指明是否在现有文件末尾追加内容。

使用FileInputStream\FileOutputStream，实现对文件txt的复制
问题：如果读取/写入编码不一样，可能存在乱码。下面这个复制没有问题，但是如果输出到控制台上就可能会出现乱码

public class FOSWrite {@Testpublic void test05() {FileInputStream fis = null;FileOutputStream fos = null;try {//1. 造文件-造流//复制图片：成功
//            fis = new FileInputStream(new File("pony.jpg"));
//            fos = new FileOutputStream(new File("pony_copy1.jpg"));//复制文本文件：成功fis = new FileInputStream(new File("hello.txt"));fos = new FileOutputStream(new File("hello1.txt"));//2. 复制操作（读、写）byte[] buffer = new byte[1024];int len;//每次读入到buffer中字节的个数while ((len = fis.read(buffer)) != -1) {fos.write(buffer, 0, len);
//                String str = new String(buffer,0,len);
//                System.out.print(str);}System.out.println("复制成功");} catch (IOException e) {throw new RuntimeException(e);} finally {//3. 关闭资源try {if (fos != null)fos.close();} catch (IOException e) {throw new RuntimeException(e);}try {if (fis != null)fis.close();} catch (IOException e) {throw new RuntimeException(e);}}}
}

三、处理流的介绍

3.1 缓冲流Buffered–字符流/字节流

1、缓冲流介绍：不直接连接到数据源或目的地，而是“连接”在已存在的流（节点流或处理流）之上，通过对数据的处理为程序提供更为强大的读写功能。
针对字符/字节有不同的分类处理方式。
提升文件读写的效率，减少与磁盘交互的次数。

2、缓冲流分类

处理非文本文件的字节流：如：FileInputStream、FileOutputStream
- BufferedInputStream：read(bytel] buffer)
- BufferedOutputStream：write(bytel] buffer,0,len)
处理文本文件的字符流：如：FileReader、FileWriter
- BufferedReader：read(char[] cBuffer)、readLine()//返回字符串–每次读取一行文本中数据，返回的字符串不包含换行符
- BufferedWriter：write(char[] cBuffer,0,len)、public void newLine()// 写一行行分隔符,由系统属性定义符号。

3、构造器：处理现有流（如：节点流，不是File对象！！！）

public BufferedInputStream(InputStream in) ：创建一个新的字节型的缓冲输入流。
public BufferedOutputStream(OutputStream out)：创建一个新的字节型的缓冲输出流。
public BufferedReader(Reader in) ：创建一个新的字符型的缓冲输入流。
public BufferedWriter(Writer out)：创建一个新的字符型的缓冲输出流。

4、实现步骤

第1步：创建File的对象、流的对象(包括文件流、缓冲流)
第2步:使用缓冲流实现读取数据或写出数据的过程(重点)
- 读取：int read(char[] cbuf / byte[] buffer)：每次将数据读入到cbuf / buffer数组中，并返回读入到数组中
- 写出：void write(string str) / write(char[] cbuf)：将str或cbuf写出到文件中
  void write(byte[] buffer)将byte[]写出到文件中
第3步：关闭资源。
说明：处理流（外层流）的关闭会自动对内层流的关闭操作，因此只需要关闭外层流即可。

测试缓冲流的效率提升：查询API，缓冲流读写方法与基本的流是一致的，我们通过复制大文件（375MB），测试它的效率。
FileInputStream\FileOutputStream及BufferedInputStream\BufferedOuputStream

//方法1：使用FileInputStream\FileOutputStream实现非文本文件的复制
public void copyFileWithFileStream(String srcPath,String destPath){FileInputStream fis = null;FileOutputStream fos = null;try {//1. 造文件-造流fis = new FileInputStream(new File(srcPath));fos = new FileOutputStream(new File(destPath));//2. 复制操作（读、写）byte[] buffer = new byte[100];int len;//每次读入到buffer中字节的个数while ((len = fis.read(buffer)) != -1) {fos.write(buffer, 0, len);}System.out.println("复制成功");} catch (IOException e) {throw new RuntimeException(e);} finally {//3. 关闭资源try {if (fos != null)fos.close();} catch (IOException e) {throw new RuntimeException(e);}try {if (fis != null)fis.close();} catch (IOException e) {throw new RuntimeException(e);}}
}@Test
public void test1(){String srcPath = "C:\\Users\\shkstart\\Desktop\\01-复习.mp4";String destPath = "C:\\Users\\shkstart\\Desktop\\01-复习2.mp4";long start = System.currentTimeMillis();copyFileWithFileStream(srcPath,destPath);long end = System.currentTimeMillis();System.out.println("花费的时间为：" + (end - start));//7677毫秒}//方法2：使用BufferedInputStream\BufferedOuputStream实现非文本文件的复制
public void copyFileWithBufferedStream(String srcPath,String destPath){FileInputStream fis = null;FileOutputStream fos = null;BufferedInputStream bis = null;BufferedOutputStream bos = null;try {//1. 造文件File srcFile = new File(srcPath);File destFile = new File(destPath);//2. 造流fis = new FileInputStream(srcFile);fos = new FileOutputStream(destFile);bis = new BufferedInputStream(fis);bos = new BufferedOutputStream(fos);//3. 读写操作int len;byte[] buffer = new byte[100];while ((len = bis.read(buffer)) != -1) {bos.write(buffer, 0, len);//先暂存，一次性write到文件中}System.out.println("复制成功");} catch (IOException e) {e.printStackTrace();} finally {//4. 关闭资源(如果有多个流，我们需要先关闭外面的流，再关闭内部的流)try {if (bos != null)bos.close();} catch (IOException e) {throw new RuntimeException(e);}try {if (bis != null)bis.close();} catch (IOException e) {throw new RuntimeException(e);}}
}
@Test
public void test2(){String srcPath = "C:\\Users\\shkstart\\Desktop\\01-复习.mp4";String destPath = "C:\\Users\\shkstart\\Desktop\\01-复习2.mp4";long start = System.currentTimeMillis();copyFileWithBufferedStream(srcPath,destPath);long end = System.currentTimeMillis();System.out.println("花费的时间为：" + (end - start));//415毫秒}

3.2 转换流InputStreamReader/OutputStreamWriter（字符-字节）

回顾编码知识：
字符编码：字符、字符串、字符数组——>字节、字节数组（看得懂——>看不懂）
字符节码：字节、字节数组——>字符、字符串、字符数组（看不懂——>看得懂）
存储在文件中：UTF-8英文1字节，中文3字节；GBK中文2字节；ASCII全部1字节，其他字符集都兼容。

在内存中的字符：
char占用2个字节。在内存中使用的字符集是Unidoce字符集——统一码，万国码
注意：这里所说的占用几个字节？
编码方式指的是存储在文件中时占用的字节。而对于内存中的占用几个字节和这个又不一样 —— 一个字符（char）占用2个字节，举例：‘a’、‘中’：都表示一个字符在内存中都是占用2个字节，当存储到文件中时就根据编码方式占用n个字节（所有编码方式兼容ASCII字符集，因此对于所有的英文字母占1个字节，对于中文采用GBK占用2个字节，采用UTF-8占用3个字节）。

问题：
idea项目编码UTF-8，windows创建的文本文件编码GBK，导入内存就会乱码
使用字节流读入文本文件，数据显示在控制台上（也有自己的编码方式），此时会出现乱码
——解码使用的字符集必须与当初编码时使用的字符集的相同。

字符-字节的转换
1、转换流介绍及其构造器

InputStreamReader：Reader的子类，输入型的字节流—指定解码方式—>输入型的字符流。指定字符集方式：指定名称、接受平台的默认字符集。
- InputStreamReader(InputStream in)：创建一个使用默认字符集的字符流。
- InputStreamReader(InputStream in, String charsetName)：创建一个指定字符集的字符流。
OutputStreamWriter：Writer的子类，输出型的字符流—指定编码方式—>输出型的字节流。
- OutputStreamWriter(OutputStream in)：创建一个使用默认字符集的字符流。
- OutputStreamWriter(OutputStream in,String charsetName)：创建一个指定字符集的字符流。

转换流InputStreamReader/OutputStreamWriter的使用示例
解码方式必须和文件编码方式一致，即采用字节方式读取，然后解码为字符。

//使用默认字符集——idea指定的
InputStreamReader isr1 = new InputStreamReader(new FileInputStream("in.txt"));
//使用指定字符集：字节流方式读取文件，使用GBK解码字节，得到输入型的字符流
InputStreamReader isr2 = new InputStreamReader(new FileInputStream("in.txt") , "GBK");//使用默认字符集
OutputStreamWriter isr = new OutputStreamWriter(new FileOutputStream("out.txt"));
//使用指定的字符集
OutputStreamWriter isr2 = new OutputStreamWriter(new FileOutputStream("out.txt") , "GBK");

把当前module下的《康师傅的话.txt》字符编码为GBK，复制到电脑桌面目录下的《寄语.txt》，字符编码为UTF-8。
思路：以字节流的方式读取gbk格式文件，使用InputStreamReader指定解码格式gbk得到输入型的字符流，再使用OutputStreamWriter将字符流以指定编码uft-8格式转换为字节流存储文件.

/*** @author 尚硅谷-宋红康* @create 9:06*/
public class InputStreamReaderDemo {@Testpublic void test() {InputStreamReader isr = null;OutputStreamWriter osw = null;try {isr = new InputStreamReader(new FileInputStream("康师傅的话.txt"),"gbk");osw = new OutputStreamWriter(new FileOutputStream("C:\\Users\\shkstart\\Desktop\\寄语.txt"),"utf-8");char[] cbuf = new char[1024];int len;while ((len = isr.read(cbuf)) != -1) {osw.write(cbuf, 0, len);osw.flush();}System.out.println("文件复制完成");} catch (IOException e) {e.printStackTrace();} finally {try {if (isr != null)isr.close();} catch (IOException e) {e.printStackTrace();}try {if (osw != null)osw.close();} catch (IOException e) {e.printStackTrace();}}}}

3.3 数据流&对象流–字节

为什么需要数据流、对象流？将内存中定义的变量（包括基本数据类型或引用数据类型）保存在文件中。

Student stu = new Student("张三",23,89);

1、数据流、对象流介绍

数据流：缺点：支持基本数据类型、字符串，不支持其它Java对象的类型。
- DataInputStream：文件中保存的数据还原为内存中的基本数据类型、String类型的变量。
- DataOutputStream：内存中的变量——》输出流中
对象流：可以把Java中的对象写入到数据源中，也能把对象从数据源中还原回来。
- ObjectInputStream：还原之前写出的基本数据类型的数据和对象进行读入操作，保存在内存中。——反序列化
- ObjectOutputStream：将 Java 基本数据类型和对象写入字节输出流中。——序列化

2、对象流构造器&API
public ObjectInputStream(InputStream in) ：创建一个指定的ObjectInputStream。
public ObjectOutputStream(OutputStream out) ：创建一个指定的ObjectOutputStream。

ObjectInputStream中的方法：

public boolean readBoolean()：读取一个 boolean 值
public byte readByte()：读取一个 8 位的字节
public short readShort()：读取一个 16 位的 short 值
public char readChar()：读取一个 16 位的 char 值
public int readInt()：读取一个 32 位的 int 值
public long readLong()：读取一个 64 位的 long 值
public float readFloat()：读取一个 32 位的 float 值
public double readDouble()：读取一个 64 位的 double 值
public String readUTF()：读取 UTF-8 修改版格式的 String
public void readObject(Object obj)：读入一个obj对象
public void close() ：关闭此输入流并释放与此流相关联的任何系统资源

ObjectOutputStream中的方法：

public void writeBoolean(boolean val)：写出一个 boolean 值。
public void writeByte(int val)：写出一个8位字节
public void writeShort(int val)：写出一个16位的 short 值
public void writeChar(int val)：写出一个16位的 char 值
public void writeInt(int val)：写出一个32位的 int 值
public void writeLong(long val)：写出一个64位的 long 值
public void writeFloat(float val)：写出一个32位的 float 值。
public void writeDouble(double val)：写出一个64位的 double 值
public void writeUTF(String str)：将表示长度信息的两个字节写入输出流，后跟字符串 s 中每个字符的 UTF-8 修改版表示形式。根据字符的值，将字符串 s 中每个字符转换成一个字节、两个字节或三个字节的字节组。注意，将 String 作为基本数据写入流中与将它作为 Object 写入流中明显不同。 如果 s 为 null，则抛出 NullPointerException。
public void writeObject(Object obj)：写出一个obj对象
public void close() ：关闭此输出流并释放与此流相关联的任何系统资源

3.4 补充：序列化&反序列化机制

1、对象序列化机制：使用ObjectOutputStream实现，将内存中的java对象保存在文件中或者通过网络传输出去。
把内存中的Java对象转换成平台无关的二进制流，从而允许把这种二进制流持久地保存在磁盘上，或通过网络将这种二进制流传输到另一个网络节点。//当其它程序获取了这种二进制流，就可以恢复成原来的Java对象。

序列化过程：用一个字节序列可以表示一个对象，该字节序列包含该对象的类型和对象中存储的属性等信息。字节序列写出到文件之后，相当于文件中持久保存了一个对象的信息。
实现方式：用ObjectOutputStream类保存基本类型数据或对象的机制。方法为：public final void writeObject (Object obj) : 将指定的对象写出。
反序列化过程：该字节序列还可以从文件中读取回来，重构对象，对它进行反序列化。对象的数据、对象的类型和对象中存储的数据信息，都可以用来在内存中创建对象。
实现方式：反序列化：用ObjectInputStream类读取基本类型数据或对象的机制。方法为：public final Object readObject ()：读取一个对象。

序列化-反序列化过程
序列化-反序列化实现原理

2、为什么需要序列化？
序列化是 RMI（Remote Method Invoke、远程方法调用）过程的参数和返回值都必须实现的机制，而 RMI 是 JavaEE 的基础。因此序列化机制是 JavaEE 平台的基础。
序列化的好处，在于可将任何实现了Serializable接口的对象转化为字节数据，使其在保存和传输时可被还原。

Serializable：是一个标记接口，不实现此接口的类将不会使任何状态序列化或反序列化，会抛出NotSerializableException。

3、自定义类实现序列化机制需要满足的条件？

类必须实现java.io.Serializable 接口，使得对象所属的类及其属性是可序列化，即对象支持序列化机制；
要求自定义类声明一个全局常量：static final long serialVersionUID = 42234234L；——唯一标识当前的类。
要求自定义类的各个属性也必须是可序列化的：
- 基本数据类型的属性默认是可序列化的，无需序列化就是瞬态的，使用transient关键字修饰。
- 引用类型的属性：实现Serializable 接口。
- 静态（static）变量的值不会序列化。因为静态变量的值不属于某个对象。

4、反序列化失败问题

如果不声明全局常量serialVersionUID ，系统会自动生成一个针对于当前类的serialVersionUID ，如果修改此类会导致serialVersionUID发生改变，进而导致反序列化时，出现InvalidClassException异常。
解决方法：显式声明serialVersionUID，如果声明了serialVersionUID，即使在序列化完成之后修改了类导致类重新编译，则原来的数据也能正常反序列化，只是新增的字段值是默认值而已。
对于JVM可以反序列化对象，它必须是能够找到class文件的类。如果找不到该类的class文件，则抛出一个 ClassNotFoundException 异常。

5、使用场景：
网络中的数据传输：要求对象可序列化。
一般情况不会传输自定义的类，而是json字符串（特殊格式的字符串）
只要涉及到对象就需要序列化、反序列化。

四、其他流的使用

4.1 标准输入、输出流

1、系统标准的输入和输出设备：

System.in：键盘(默认)——》内存，类型InputStream
System.out：内存——》显示器(默认)，类型PrintStream，OutputStream的子类FilterOutputStream 的子类。

2、修改默认设备：System类的setIn，setOut方法

public static void setIn(InputStream in)
public static void setOut(PrintStream out)——结合打印流可以改变

3、System类中有三个常量对象：System.out、System.in、System.err
提问：final声明的常量一旦赋值就不能修改，那么null会空指针异常吗？为什么要小写？set是如何修改这三个的值的？
答：final声明的常量在java的语法体系中不能修改，但是他们是由c/c++等系统函数进行初始化和修改的，所以没有大写，也有set方法。

public final static InputStream in = null;
public final static PrintStream out = null;
public final static PrintStream err = null;

源码解析：常量能修改的原因

public static void setOut(PrintStream out) {checkIO();setOut0(out);
}
public static void setErr(PrintStream err) {checkIO();setErr0(err);
}
public static void setIn(InputStream in) {checkIO();setIn0(in);
}
private static void checkIO() {SecurityManager sm = getSecurityManager();if (sm != null) {sm.checkPermission(new RuntimePermission("setIO"));}
}
private static native void setIn0(InputStream in);
private static native void setOut0(PrintStream out);
private static native void setErr0(PrintStream err);

从键盘输入字符串，要求将读取到的整行字符串转成大写输出。然后继续进行输入操作，直至当输入“e”或者“exit”时，退出程序。

System.out.println("请输入信息(退出输入e或exit):");
// 把"标准"输入流(键盘输入——读入到内存中的流)这个字节流包装成字符流(处理流之转换流),再包装成缓冲流
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String s = null;
try {while ((s = br.readLine()) != null) { // 读取用户输入的一行数据 --> 阻塞程序if ("e".equalsIgnoreCase(s) || "exit".equalsIgnoreCase(s)) {System.out.println("安全退出!!");break;}// 将读取到的整行字符串转成大写输出System.out.println("-->:" + s.toUpperCase());System.out.println("继续输入信息");}
} catch (IOException e) {e.printStackTrace();
} finally {try {if (br != null) {br.close(); // 关闭过滤流时,会自动关闭它包装的底层节点流}} catch (IOException e) {e.printStackTrace();}
}

4.2 打印流PrintStream/PrintWriter

1、打印流作用：基本数据类型——》字符串输出

可以输出多种数据类型：提供了一系列重载的print()和println()方法
PrintStream和PrintWriter的输出不会抛出IOException异常
PrintStream和PrintWriter有自动flush功能
PrintStream 打印的所有字符都使用平台的默认字符编码转换为字节。在需要写入字符而不是写入字节的情况下，应该使用 PrintWriter 类。
System.out返回的是PrintStream的实例

2、打印流的构造器

PrintStream(File file) ：创建具有指定文件且不带自动行刷新的新打印流。
PrintStream(File file, String csn)：创建具有指定文件名称和字符集且不带自动行刷新的新打印流。
PrintStream(OutputStream out) ：创建新的打印流。
PrintStream(OutputStream out, boolean autoFlush)：创建新的打印流。 autoFlush如果为 true，则每当写入 byte 数组、调用其中一个 println 方法或写入换行符或字节 (‘\n’) 时都会刷新输出缓冲区。
PrintStream(OutputStream out, boolean autoFlush, String encoding) ：创建新的打印流。
PrintStream(String fileName)：创建具有指定文件名称且不带自动行刷新的新打印流。
PrintStream(String fileName, String csn) ：创建具有指定文件名称和字符集且不带自动行刷新的新打印流。

使用示例：自定义一个日志工具

/*
日志工具*/
public class Logger {/*记录日志的方法。*/public static void log(String msg) {try {// 指向一个日志文件PrintStream out = new PrintStream(new FileOutputStream("log.txt", true));// 改变输出方向System.setOut(out);// 日期当前时间Date nowTime = new Date();SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");String strTime = sdf.format(nowTime);System.out.println(strTime + ": " + msg);} catch (FileNotFoundException e) {e.printStackTrace();}}
}

测试日志工具

public class LogTest {public static void main(String[] args) {//测试工具类是否好用Logger.log("调用了System类的gc()方法，建议启动垃圾回收");Logger.log("调用了TeamView的addMember()方法");Logger.log("用户尝试进行登录，验证失败");}
}

4.3 Scanner类

1、构造方法

Scanner(File source) ：构造一个新的 Scanner，它生成的值是从指定文件扫描的。
Scanner(File source, String charsetName) ：构造一个新的 Scanner，它生成的值是从指定文件扫描的。
Scanner(InputStream source) ：构造一个新的 Scanner，它生成的值是从指定的输入流扫描的。
Scanner(InputStream source, String charsetName) ：构造一个新的 Scanner，它生成的值是从指定的输入流扫描的。

2、常用方法：

boolean hasNextXxx()：如果通过使用nextXxx()方法，此扫描器输入信息中的下一个标记可以解释为默认基数中的一个 Xxx 值，则返回 true。
Xxx nextXxx()：将输入信息的下一个标记扫描为一个Xxx

package com.atguigu.systemio;import org.junit.Test;import java.io.*;
import java.util.Scanner;public class TestScanner {@Testpublic void test01() throws IOException {Scanner input = new Scanner(System.in);PrintStream ps = new PrintStream("1.txt");while(true){System.out.print("请输入一个单词：");String str = input.nextLine();if("stop".equals(str)){break;}ps.println(str);}input.close();ps.close();}@Testpublic void test2() throws IOException {Scanner input = new Scanner(new FileInputStream("1.txt"));while(input.hasNextLine()){String str = input.nextLine();System.out.println(str);}input.close();}
}

4.4 apache-common包的使用

1、作用：IO技术的工具类commonsIO，简化IO开发。
Oracle第一方，我们自己第二方，其他都是第卅安防

2、使用方式：导入commons-io-2.5.jar包，使用内部的API。

IOUtils类的使用
- 静态方法：IOUtils.copy(InputStream in,OutputStream out)传递字节流，实现文件复制。
- 静态方法：IOUtils.closeQuietly(任意流对象)悄悄的释放资源，自动处理close()方法抛出的异常。
FileUtils类的使用
- 静态方法：void copyDirectoryToDirectory(File src,File dest)：整个目录的复制，自动进行递归遍历
  参数：
  src：要复制的文件夹路径
  dest：要将文件夹粘贴到哪里去
- 静态方法：void writeStringToFile(File file,String content)：将内容content写入到file中
- 静态方法：String readFileToString(File file)：读取文件内容，并返回一个String
- 静态方法：void copyFile(File srcFile,File destFile)：文件复制

IOUtils类的使用

public class Test01 {public static void main(String[] args)throws Exception {//- 静态方法：IOUtils.copy(InputStream in,OutputStream out)传递字节流，实现文件复制。IOUtils.copy(new FileInputStream("E:\\Idea\\io\\1.jpg"),new FileOutputStream("E:\\Idea\\io\\file\\柳岩.jpg"));//- 静态方法：IOUtils.closeQuietly(任意流对象)悄悄的释放资源，自动处理close()方法抛出的异常。/* FileWriter fw = null;try {fw = new FileWriter("day21\\io\\writer.txt");fw.write("hahah");} catch (IOException e) {e.printStackTrace();}finally {IOUtils.closeQuietly(fw);}*/}
}

FileUtils类的使用

public class Test02 {public static void main(String[] args) {try {//- 静态方法：void copyDirectoryToDirectory(File src,File dest);FileUtils.copyDirectoryToDirectory(new File("E:\\Idea\\io\\aa"),new File("E:\\Idea\\io\\file"));//- 静态方法：writeStringToFile(File file,String str)FileUtils.writeStringToFile(new File("day21\\io\\commons.txt"),"柳岩你好");//- 静态方法：String readFileToString(File file)String s = FileUtils.readFileToString(new File("day21\\io\\commons.txt"));System.out.println(s);//- 静态方法：void copyFile(File srcFile,File destFile)FileUtils.copyFile(new File("io\\yangm.png"),new File("io\\yangm2.png"));System.out.println("复制成功");} catch (IOException e) {e.printStackTrace();}}
}