18、IO流：

这一章很枯燥无聊~

文件：

什么是文件：

文件，对我们并不陌生，文件时保存数据的地方，比如我们经常使用的word文档，txt文档，excel文档…都是文件。它既可以保存一张图片，也可以保持视频，声音。

文件流：

文件在程序中是以流的形式操作的。

• 流：数据从数据源（文件）和程序（内存）之间经历的路径；
• 输入流：数据从数据源（文件）到程序（内存）的路径；
• 输出流：数据从程序（内存）到数据源（文件）的路径。

---

常用的文件操作：

创建文件对象相关构造器和方法：

相关方法：

• new File(String pathname); // 根据路径构建一个File对象
• new File(File parent, String child); // 根据父目录文件 + 子路径构建
• new File(String parent, String child); // 根据父目录 + 子路径构建
• File_Object.creatNewFile(); // 创建新文件。

new File()是在内存中创建出了文件，但是没有将这个文件创建到磁盘中，我们需要使用creatNewFile()来将文件创建到磁盘中。

案例代码：

package com.jiangxian;import org.junit.jupiter.api.Test;import java.io.*;/*** @author JiangXian~* @version 1.0*/public class FileCreate {public static void main(String[] args) {}@Test // Test一开始会是红色，光标挪至此处，然后按下Alt + Enter，将需要的下载Junit下来。// 方式1 new File(String pathname)public void creat01(){String filepath = "e:\\news1.txt";File file = new File(filepath);try {file.createNewFile();} catch (IOException e) {e.printStackTrace();}}@Testpublic void creat02(){File parentFile = new File("e:\\");String fileName = "news2.txt";File file = new File(parentFile, fileName);try {file.createNewFile();} catch (IOException e) {e.printStackTrace();}}@Testpublic void creat03(){String parentPath = "e:\\";String fileName = "news3.txt";File file = new File(parentPath, fileName);try {file.createNewFile();} catch (IOException e) {e.printStackTrace();}}}

获取文件的相关信息：

getName（获取文件名）、getAbsolutePath（获取绝对路径）、getParent（获取父目录）、length、exists、isFile（是否是文件）、isDirectory（是否是目录——文件夹）

应用案例：

package com.jiangxian;import org.junit.jupiter.api.Test;
import java.io.*;/*** @author JiangXian~* @version 1.0* 演示如何获取文件的大小，文件名，路径，父File，是文件还是目录（目录本质也是文件），是否存在**/public class FileInformation {public static void main(String[] args) {}@Testpublic void info(){// 先创建文件对象：File file =  new File("e:\\news1.txt");// 调用相应的方法，得到对应信息；System.out.println("文件名为：" + file.getName());System.out.println("文件绝对路径为：" + file.getAbsolutePath());System.out.println("文件父级目录：" + file.getParent());System.out.println("文件大小（字节）：" + file.length());System.out.println("文件是否存在：" + file.exists());System.out.println("是否是一个文件：" + file.isFile());System.out.println("是否是一个目录：" + file.isDirectory());}
}

目录操作和文件删除：

• mkdir 创建一级目录；
• mkdirs 创建多级目录；
• delete 删除空目录或文件（若要删除目录，其必须是空的，若由内容必须先删除里面的文件）。

应用案例演示：

package com.jiangxian;import org.junit.jupiter.api.Test;import java.io.File;/*** @author JiangXian~* @version 1.0*/public class FileDirectory {public static void main(String[] args) {}@Testpublic void Directory_1(){File file = new File("e:\\news1.txt");if(file.exists()){file.delete();System.out.println("删除成功！");}}@Testpublic void Directory_2(){File file = new File("e:\\demo02.txt");if(file.exists()){file.delete();System.out.println("文件删除成功！");}else {System.out.println(file.getName() + "文件不存在。");}}@Testpublic void Directory_3(){String directoryPath = "e:\\demo\\a\\b\\c";File file = new File(directoryPath);if(file.exists()){System.out.println(file.getName() + "目录已经存在");}else{file.mkdirs();// 输出的是最后一个目录名。System.out.println(file.getName() + "目录不存在，现已创建！");}}
}

---

IO流原理及流的分类：

Java IO流原理：

1. I/O是Input/Output的缩写，I/O技术是非常实用的技术，用于处理数据传输。如读/写文件，网络通讯等；
2. Java程序中，对于数据的输入/输出操作以“流（stream）”的方式进行；
3. java.io包下提供了各种“流”类和接口，用以获取不同种类的数据，并通过方法输入或输出数据；
4. 输入input：读取外部数据（磁盘、光盘等存储设备的数据）到程序（内存）中；
5. 输出output：将程序（内存）数据输出到磁盘、光盘等存储设备中。

流的分类：

• 按操作数据单位不同分为：字节流（8bit=1Byte）擅长读写二进制文件；字符流（按字符） 擅长读写文本文件；
• 按数据流的流向不同分为：输入流，输出流；
• 按流的角色的不同分为：节点流，处理流/包装流。

（抽象基类）	字节流	字符流
输入流	InputStream	Reader
输出流	OutputStream	Writer

1. Java 的 IO流共设计40多个类，实际上非常规则，都是从如上四个抽象基类派生的；
2. 由这四个类派生出来的子类名称都是以其父类名作为子类名后缀的。

怎么去理解流：

程序（内存）：可以理解为我们！假设我们在网上买了东西；

文件（磁盘）：可以理解为我们买东西的网店；

流：可以理解为快递员。（网店需要通过快递员才能把物品交给我们~）。

---

FileInputStream 介绍：

是抽象类 InputStream 的子类

构造方法：

• FileInputStream(File file)：通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定；
• FileInputStream(fileDescriptor fdObj)：通过使用文件描述符 fdObj 创建一个 FileInputStream，该文件描述表示到文件系统中某个实际文件的现有连接；
• FileInputStream(String name)：通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 推定。

当文件和一个 FileInputStream 对象（流）关联起来后，我们就使用这个对象去操作这个文明。

方法概要：

• read()：从输入流中读取一个字节；若读到文件末尾返回-1，返回的值是当前字母对应的ASCII值
• read(byte[] b)：从输入流中一次性读取最多b.length的字节到数组b中；若到文件末尾返回-1，否则返回的值是读取的字节长度
• read(byte[] b, int off, int len)：从输入流中一次性将最多len个的字节读取到数组b中。
• close()：关闭此文件输入流并释放与此流相关的所有系统资源。

案例：

原始：

忘记添加close()

package com.jiangxian.InputStream_;import org.junit.jupiter.api.Test;import java.io.*;/*** @author JiangXian~* @version 1.0*/
public class FileInputStream_ {public static void main(String[] args) {}@Testpublic void input_(){String filePath = "D:\\Code\\Project\\javacode\\chapter18\\src\\com\\jiangxian\\hello.txt";File file = new File(filePath);int read = 0;try {FileInputStream fileInputStream = new FileInputStream(file);// 从该输入流中每次读取一个字节的数据，若没有输入可用，此方法将终止// 若返回-1表示读取完毕，否则返回的是ASCII码while((read = fileInputStream.read()) != -1){System.out.print((char)read);}} catch (IOException e) {e.printStackTrace();}}
}

修改后：

package com.jiangxian.InputStream_;import org.junit.jupiter.api.Test;import java.io.*;/*** @author JiangXian~* @version 1.0*/
public class FileInputStream_ {public static void main(String[] args) {}@Testpublic void input_(){String filePath = "D:\\Code\\Project\\javacode\\chapter18\\src\\com\\jiangxian\\hello.txt";File file = new File(filePath);int read = 0;// 让其为空不会报错FileInputStream fileInputStream = null;try {// 此处会执行修改// FileInputStream fileInputStream = new FileInputStream(file);fileInputStream = new FileInputStream(file);// 从该输入流中每次读取一个字节的数据，若没有输入可用，此方法将终止// 若返回-1表示读取完毕，否则返回的是ASCII码while((read = fileInputStream.read()) != -1){System.out.print((char)read);}} catch (IOException e) {e.printStackTrace();}finally{ // 无论操作如何，都要保证关闭一次！// 当我们完成读写后，要关闭文件流，释放资源// 但是我们发现，我们定义的fileInputStream是在try代码块内的，// 作用域到不了finally，怎么办呢，在try外定义，让其为空try {fileInputStream.close();} catch (IOException e) {e.printStackTrace();}}}
}

但是此处要是文件里是汉字，会是乱码，为什么呢？因为我们使用的是UTF-8编码，字母是1个字节，但是汉字是3个字节，所以会是乱码（想要读取汉字得要使用字符流处理！）

多字节读取：

    @Testpublic void input_2(){ // 这样读取效率高String filePath = "D:\\Code\\Project\\javacode\\chapter18\\src\\com\\jiangxian\\hello.txt";File file = new File(filePath);// 字节数组byte[] buffer = new byte[8];// 定义实际接受的长度int len = 0;FileInputStream fileInputStream = null;try {// 此处会执行修改// FileInputStream fileInputStream = new FileInputStream(file);fileInputStream = new FileInputStream(file);// 从该输入流中每次读取一个字节的数据，若没有输入可用，此方法将终止// 若返回-1表示读取完毕，否则返回的是ASCII码while((len = fileInputStream.read(buffer)) != -1){System.out.print(new String(buffer,0,len)); // 将byte数组转换为String// 为什么不直接toSting呢？buffer中的数据每次不会清空，而是覆盖// 当最后读入的数据<buffer.length的时候，会有一段数据是无用的// 将其也转换为字符串是不正确的答案// 所以需要对转换的末尾位置做一个确定。}} catch (IOException e) {e.printStackTrace();}finally{ // 无论操作如何，都要保证关闭一次！// 当我们完成读写后，要关闭文件流，释放资源// 但是我们发现，我们定义的fileInputStream是在try代码块内的，// 作用域到不了finally，怎么办呢，在try外定义，让其为空try {fileInputStream.close();} catch (IOException e) {e.printStackTrace();}}}

---

FileOutputStream介绍：

构造方法：

• FileOutputStream(File file);
  • 创建一个指向 File 对象表示的文件输出流。
• FileOutputStream(String name);
  • 创建一个指向具有指定名称文件的写入输入流。
• FileOutputStream(File file, boolean append);
  • 创建一个指向 File 对象表示的文件输出流，此时的模式是追加，而不是覆盖（光标在文件末尾而不是开头）。
• FileOutputStream(String name, boolean append);
  • 创建一个指向具有指定名称文件的写入输入流，此时的模式是追加，而不是覆盖（光标在文件末尾而不是开头）。
• FileOutputStream(FileDescriptor fdObj);

方法概述：

• close()：关闭此文件输出流并释放与此有关的所有系统资源（只有使用完close才真正写入到文件，否则只是写入了文件输出流中）；
• write(int b)：将指定字节写入此文件输出流中；
• write(byte[] b)：将b，length个字节从指定数组中写入
• write(byte[] b,int off, int len)：将指定b从偏移off处开始的len个字节写入文件输出流。

案例：

import org.junit.jupiter.api.Test;import java.io.*;public class FileOutputStream_ {public static void main(String[] args) {}/*演示如何使用FileOutputStream 将输入写到文件中若文件不存在，就创建它*/@Testpublic void out_(){ // 写入单个字符FileOutputStream fos = null;String filePath = "d:\\a.txt";try {fos = new FileOutputStream(filePath);fos.write('a'); // char 会自动地转换为 int// fos.write('H')，此时会覆盖之前的a} catch (IOException e) {e.printStackTrace();}finally{try {fos.close();} catch (IOException e) {e.printStackTrace();}}}@Testpublic void out2(){ // 写入字符串FileOutputStream fos = null;String filePath = "d:\\a.txt";try {fos = new FileOutputStream(filePath);String str = "Hello,World!";// str.getBytes可以把字符串转换成一个字节数组。fos.write(str.getBytes());} catch (IOException e) {e.printStackTrace();}finally{try {fos.close();} catch (IOException e) {e.printStackTrace();}}}@Testpublic void out3(){ // 不覆盖，在后面追加FileOutputStream fos = null;String filePath = "d:\\a.txt";try {fos = new FileOutputStream(filePath,true);String str = "\nHello,World!";// str.getBytes可以把字符串转换成一个字节数组。fos.write(str.getBytes());} catch (IOException e) {e.printStackTrace();}finally{try {fos.close();} catch (IOException e) {e.printStackTrace();}}}
}

---

文件拷贝：

案例：

import org.junit.jupiter.api.Test;import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;public class FileCopy_ {public static void main(String[] args) {}@Testpublic void copy(){String srcPath = "e:\\self_study\\NoteBook\\mg.png";String destPath = "e:\\self_study\\NoteBook\\Java\\mg.png";// 创建输入流，是为了将文件读入到程序FileInputStream fis = null;// 创建输出流，为了将文件输出到指定位置FileOutputStream fos = null;byte[] buffer = new byte[1024];int len = 0;// 应该是一边读取，一边写入try {fis = new FileInputStream(srcPath);fos = new FileOutputStream(destPath);while((len = fis.read(buffer)) != -1){fos.write(buffer, 0, len);}} catch (Exception e) {e.printStackTrace();}finally{try {fis.close();fos.close();} catch (IOException e) {e.printStackTrace();}}}
}

可能有人会理解不了，不是说write会覆盖吗，为什么能把整个图片拷贝过去呀！我们要明白，覆盖是对流的，而流是整个对象，而不是write这个方法，所以只要我们没有.close那么在同一个输出流中就不会覆盖。

---

FileReader 和 FileWriter

FileReader：

继承的是InputStreamReader，而InputStreamReader则继承了抽象类Reader。

相关方法：

1. 构造器：new FileReader(String/File);
2. read()：每次读取单个字符，返回该字符（char和int能自动转换），若到文件末尾返回-1；
3. read(char[])：批量读取多个字符到数组，返回读取到的字符数，若到文件末尾返回-1；

相关API：

1. new String(char[])：将char[]转换成字符串；
2. new String(char[], off, len)：将char[]的指定部分转换成String。

案例：

import org.junit.jupiter.api.Test;import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;public class FileReader_ {public static void main(String[] args) {}@Testpublic void read_1(){ // 一次读取单个字符FileReader fr = null;int len = 0;String filePath = "e:\\self_study\\NoteBook\\Java\\story.txt";try {fr = new FileReader(filePath);while((len = fr.read()) != -1){System.out.print((char)len);}} catch (Exception e) {e.printStackTrace();} finally {try {fr.close();} catch (IOException e) {e.printStackTrace();}}}@Testpublic void read_2(){ // 一次读取多个字符FileReader fr = null;int len = 0;char[] buf = new char[8];String filePath = "e:\\self_study\\NoteBook\\Java\\story.txt";try {fr = new FileReader(filePath);while((len = fr.read(buf)) != -1){System.out.print(new String(buf, 0, len));}} catch (Exception e) {e.printStackTrace();} finally {try {fr.close();} catch (IOException e) {e.printStackTrace();}}}}

FileWriter：

直接父类是OutStreamWriter，OutputStreamWriter继承了抽象类Writer。

相关方法：

1. 构造器：new FileWriter(String/File)——覆盖模式，相当于光标在文件开头；
2. 构造器：new FileWriter(String/File, true)——添加模式，相当于光标在文件末尾；
3. write(int)：写入单个字符；
4. write(char[])：写入指定数组；
5. write(char[], off ,len)：写入指定数组的指定部分；
6. write(String)：写入整个字符串；
7. write(String,off,len)：写入指定字符串的指定部分。

相关API：

String类：toCharArray——将String转换为Char[]

在我们使用过FileWriter后，必须要关闭(close)或刷新(flush)，否则无法写入指定文件中。

案例：

import org.junit.jupiter.api.Test;import java.io.FileWriter;
import java.io.IOException;public class FileWriter_ {public static void main(String[] args) {}@Testpublic void write_1() {String dstPath = "E:\\self_study\\NoteBook\\Java\\write_1.txt";String wirte = "风雨之后，总见彩虹！";FileWriter fw = null;try {fw = new FileWriter(dstPath);fw.write(wirte);} catch (IOException e) {e.printStackTrace();} finally {try {fw.close();} catch (IOException e) {e.printStackTrace();}}}@Testpublic void write_2() {String dstPath = "E:\\self_study\\NoteBook\\Java\\write_1.txt";String wirte = "风雨之后，总见彩虹！";FileWriter fw = null;try {fw = new FileWriter(dstPath);fw.write(wirte.toCharArray());} catch (IOException e) {e.printStackTrace();} finally {try {fw.close();} catch (IOException e) {e.printStackTrace();}}}
}

---

节点流和处理流：

基本介绍：

1. 节点流：可以从一个特定的数据源读写数据，如 FileReader、FileWriter；（专人做专事。）
2. 处理流（包装流）：其是“连接”在已存在的流（节点流或处理流）之上，为程序提供更为强大的读写功能，也更加灵活，如BufferedReader、BufferedWriter（其不像节点，比方说FileReader只能读取文件，但是BufferedReader却能够读取文件、数组等等！因为其内部有个属性的类型为顶层的抽象类，所以可以接受属于其的众多的子类，即封装一个节点流）。
   1. 这种模式就叫做修饰器模式

节点流和处理流的区别和联系：

1. 节点流是底层流/低级流（不是说它不好），直接跟数据源相连接；

2. 处理流（包装流）包装节点流，既可以消除不同节点流的实现差异，也可以提供更方便的方法来完成输入输出；

3. 处理流（包装流）对节点流进行包装，使用了修饰器设计模式，不会直接与数据源相连。

   public abstract class Reader_ { // 抽象类public abstract void read();
   }/*** Filereader_ 和 StringReader_ 可以看作就是节点流*/
   class Filereader_ extends Reader_ { // 对文件进行读取操作public void read(){System.out.println("Reading file");}
   }class StringReader_ extends Reader_ { // 对字符串进行读取读取public void read(){System.out.println("read String");}
   }/*** 下面写一个处理流：*/class BufferedReader_ extends Reader_ {private Reader_ reader; // 有一个私有属性是Reader_类型public BufferedReader_(Reader_ reader) {this.reader = reader;}public void read(){this.reader.read();}
   }

   public class Test {public static void main(String[] args) {// 这里我一开始有点迷糊，后来发现new StringReader_()只是作为参数传入了 BufferedReader// 其运行类型还是BufferedReader_哦！BufferedReader_ bufferedReader = new BufferedReader_(new StringReader_());bufferedReader.read(); }
   }
   

处理流的功能主要体现在以下两个方面：

1. 性能的提高：主要以增加缓冲的方式来提高输入输出的效率；
2. 操作更加便捷：处理流可能提供了一系列便捷的方法来一次输入输出大批量的数据，使用更加灵活方便。

处理流——BufferedReader和BufferedWriter：

• BufferedReader 和 BufferedWriter 属于字符流，是按照字符来读取数据的；
• 关闭处理流，只需要关闭外层流即可，不用再关闭我们包装的节点流（实际上真正读取的仍然是节点流，处理流只是做了一个包装）。

案例：

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;public class BufferedReader_1 {public static void main(String[] args) throws Exception {String filePath = "d:\\b.txt";BufferedReader br = new BufferedReader(new FileReader(filePath));String line;while ((line = br.readLine()) != null) { // readline会读取完整的一行，当读到文件末尾时，返回空System.out.println(line);}br.close();}
}

package com.jiangxian.buffered;import java.io.*;/*** @author JiangXian~* @version 1.0* 演示BufferedWriter的使用*/public class BufferedWriter_ {public static void main(String[] args) throws IOException {String filePath = "E:\\news2.txt";BufferedWriter bw = new BufferedWriter(new FileWriter(filePath));// 若想要追加，在节点流的构造器中加入true即可。bw.write("hello,韩顺平教育！");// 建议若后续还有文本时，建议插入换行bw.newLine(); // 这就是插入一个换行，且会根据当前系统决定换行符是什么bw.close();}
}

拷贝：

package com.jiangxian.buffered;import java.io.*;/*** @author JiangXian~* @version 1.0*/
public class Copy {public static void main(String[] args) throws IOException {BufferedReader br = new BufferedReader(new FileReader("e:\\news2.txt"));BufferedWriter bw = new BufferedWriter(new FileWriter("e:\\news3.txt"));String line;while((line = br.readLine()) != null){bw.write(line);bw.newLine();}br.close();bw.close();}
}

处理流——BufferedInputStream和BufferedOutputStream：

• BufferedInputStream：其是字节流，在创建 BufferedInputStream 时，会创建一个内部缓冲区数组。
• BufferedOutputStream：其是字节流，实现缓冲的输出流，可以将多个字节写入底层输出流中，而不必对每次字节写入调用底层系统。

案例：

package com.jiangxian.buffered;import java.io.*;/*** @author JiangXian~* @version 1.0*/public class Copy_2 {public static void main(String[] args) throws IOException {String srcPath = "e:\\hello1.txt";String dstPath = "e:\\hello2.txt";int res = 0;byte[] buf = new byte[8];BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcPath));BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(dstPath));while((res = bis.read(buf)) != -1){bos.write(buf, 0, res);}bis.close();bos.close();}
}

对象流——ObjectInputStream和ObjectOutputStream：

为什么要有：

在保存文件的时候，希望把数据的类型保存下来（比如我们保存的100到底是int类型还是String类型呢），所以其需要能够保存值和数据类型。

介绍：

• 功能：提供了对基本类型或对象类型的序列化和反序列化的方法；
• ObjectInputStream：提供序列化功能；（在保存数据时，保存数据的值和数据类型）
• ObjectOutputStream：提供反序列化功能。（在恢复数据时，恢复数据的值和数据类型）
• 若我们想要让某个类支持序列化机制，则必须让其类是可序列化的，为了让这个类是可序列化的，该类必须实现以下两个接口之一：
  • Serializable——标记接口（仅做标记，没有任何方法）推荐；
  • Externalizable——该接口有方法需要实现，因此一般推荐使用上面的。

案例：

package com.jiangxian.object_;import java.io.Serializable;/*** @author JiangXian~* @version 1.0*/
public class Dog implements Serializable {private String name;private int age;public Dog(String name, int age) {this.name = name;this.age = age;}@Overridepublic String toString() {return "Dog{" +"name='" + name + '\'' +", age=" + age +'}';}
}

package com.jiangxian.object_;import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.Serializable;/*** @author JiangXian~* @version 1.0*/
public class ObjectOutStream_ {public static void main(String[] args) throws IOException {// 序列化后，保存的文件格式，不是存放文本，而是按照他的格式来保存String filePath = "e:\\data.dat";ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filePath));// 序列化数据到 e:\data.datoos.writeInt(100); // 此处发生了自动装箱，int -> Integer(实现了Serializable)oos.writeBoolean(true); // boolean -> Boolean(实现了Serializable)oos.writeChar('a'); // char -> Character(实现了Serializable)oos.writeDouble(3.14); // double -> Doubleoos.writeUTF("江弦凤歌"); // String// 保存一个Dog对象oos.writeObject(new Dog("旺财", 5));oos.close();System.out.println("序列化保存文件完成。");}
}

package com.jiangxian.InputStream_;import com.jiangxian.object_.Dog;import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;/*** @author JiangXian~* @version 1.0*/
public class ObjectInputStream_ {public static void main(String[] args) throws IOException, ClassNotFoundException {// 指定反序列化的文件String filePath = "e:\\data.dat";ObjectInputStream ois = new ObjectInputStream(new FileInputStream(filePath));// 读取// 1.读取（反序列化）的顺序需要和保存（序列化）数据一致// 2.否则会报异常System.out.println(ois.readInt());System.out.println(ois.readBoolean());System.out.println(ois.readChar());System.out.println(ois.readDouble());System.out.println(ois.readUTF());Object dog = ois.readObject(); // 底层 Object -> Dog，需要抛出异常// dog的编译类型是Object，运行类型为DogSystem.out.println("运行类型：" + dog.getClass());System.out.println("dog信息 = " + dog);// 特别重要的细节：// 1. 若我们希望调用Dog的方法，我们需要向下转型，但我们发现，此时我们没有这个类// 2. 所以我们需要引入这个类。Dog dog1 = (Dog) dog;ois.close();}
}

注意事项和处理细节：

1. 读写顺序要一致；
2. 要求实现序列化或反序列化的对象，需要实现Serializable；
3. 序列化的类中建议添加SerialVersionUID，为了提高版本的兼容性；
4. 序列化对象时，默认将里面所有属性都进行序列化，但除了static 或 transient 修饰的成员（这两个是不会序列化的，及存储的内容中没有这两种信息，要是重写过toString，这两个成员的部分会是null）；
5. 序列化对象，要求在里面的属性的类型也都要实现Serializable接口（除了static 和 transient修饰的）；
6. 序列化具有可继承性，要是某类已经实现了可序列化，其子类都可以实现序列化。

标准输入输出流：

	类型	默认设备
System.in	InputStream	键盘
System.out	OutputStream	显示器

package com.jiangxian.standard_;import java.util.Scanner;/*** @author JiangXian~* @version 1.0*/
public class InputAndOutput {public static void main(String[] args) {// System.in：// 1.编译类型：InputStream// 2.运行类型：BufferedInputStream// 表示标准输入，就是键盘System.out.println(System.in.getClass());// System.out:// 1.编译类型：PrintStream// 2.运行类型: PrintStream// 表示标准输出，就是我们的显示器System.out.println(System.out.getClass());Scanner sc = new Scanner(System.in);}
}

转换流——InputStreamReader 和 OutputStreamWriter：

作用：将字节流转换成字符流。

为什么需要转换流呢？

因为我们Java中使用的编码是UTF-8，但是又可能我们的文件并不是UTF-8的格式，而我们的字节流是可以设置文件编码格式的，然后再将我们的字节流转换成字符流，我们就解决了我们的文件编码问题。

介绍：

1. InputStreamReader：Reader的子类，可以将InputStream（字节流）包装成Reader（字符流）；
   • 构造器：InputStreamReader(InputStream, Charset);——传入一个字节流和编码格式
2. OutputStreamWriter：Writer的子类，可以将OutputStream（字节流）包装成Writer（字符流）；
   • 构造器：OutputStreamReader(OutputStream, Charset);——传入一个字节流和编码格式
3. 当处理纯文本文件的时候，若使用字符流效率更高，并且可以有效地解决中文问题，所以建议将字节流转换成字符流；
4. 可以在使用时指定编码格式（UTF-8，gbk等等）。

案例：

package com.jiangxian.transformation_;import java.io.*;/*** @author JiangXian~* @version 1.0* 中文乱码问题*/
public class CodeQuestion {public static void main(String[] args) throws IOException {FileInputStream fis = new FileInputStream("E:\\self_study\\NoteBook\\Java\\story.txt");InputStreamReader isr = new InputStreamReader(fis,"gbk");BufferedReader br = new BufferedReader(isr);String line = null;while ((line = br.readLine()) != null) {System.out.println(line);}br.close();}
}

package com.jiangxian.transformation_;import java.io.*;/*** @author JiangXian~* @version 1.0*/
public class Output_ {public static void main(String[] args) throws Exception {String filePath = "E:\\self_study\\NoteBook\\Java\\story.txt";BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(filePath,true),"gbk"));bw.write("庙里有个老和尚");bw.newLine();bw.close();}
}

打印流——PrintStream 和 PrintWriter：

打印流只有输出流没有输入流。

• PrintStream：继承了FilterOutputStream，是字节流。

  package com.jiangxian.printstream_;import java.io.FileNotFoundException;
  import java.io.PrintStream;/*** @author JiangXian~* @version 1.0* 演示PrintStream，字节打印流*/
  public class PrintStream_ {public static void main(String[] args) throws Exception {// 经典用法，在默认情况下，打印到的位置是标准输出——屏幕/*public void print(String s) {if (s == null) {s = "null";}write(s);}*/PrintStream out = System.out;out.print("Hello World");// print的底层使用的是write，所以我们可以直接使用write来代替printout.print("\nJiangXian");out.close();// 我们可以修改打印流输出的位置/设备// 现在我们修改到了story.txtSystem.setOut(new PrintStream("E:\\self_study\\NoteBook\\Java\\story.txt"));System.out.println("hello,JiangXian!");}
  }

• PrintWriter：继承了Writer，是字符流。

  package com.jiangxian.printwriter_;import java.io.FileWriter;
  import java.io.IOException;
  import java.io.PrintWriter;/*** @author JiangXian~* @version 1.0*/
  public class PrintWriter_ {public static void main(String[] args) throws IOException {// 我们可以根据自己的需求调整位置// PrintWriter printWriter = new PrintWriter(System.out);PrintWriter printWriter = new PrintWriter(new FileWriter("e:\\f2.txt"));printWriter.print("Hello World");printWriter.close();}
  }

---

Properties类：

在集合中讲过（Map的子类）~但是没有提及主要的应用。

看一个需求：

如下一个配置文件：mysql.properties

• ip = 192.168.0.13;
• user = root;
• pwd = 12345。

请问编程读取ip、user 和 pwd的值是多少？

配置文件是我们程序需要读取的，或者是我们的程序对配置文件进行了修改需要写入的。

传统方法：

package com.jiangxian.properties_;import java.io.*;/*** @author JiangXian~* @version 1.0*/
public class Properties01 {public static void main(String[] args) throws Exception {// 读取mysql.properties文件，并获取相关的信息BufferedReader br = new BufferedReader(new FileReader("src\\mysql.properties")); // 这里写的是相对路径，src为根目录String line;while ((line = br.readLine()) != null) {String[] str = line.split("="); // 以'='号为界分割为两个String数组System.out.println(str[0] + "值是：" + str[1]);}br.close();}
}

传统方案可以解决，但是不是特别方便，我们需要遍历出来，然后判断是不是我们要的值再输出（代码只实现了遍历哦）。

基本介绍：

1. 专门用于读写配置文件的集合类；
2. 配置文件的格式：键=值；
3. 键值对之间不要有空格，值不需要使用引号括起来，默认是String

常见方法：

• load：加载配置文件的键值对到Properties对象；
• list：将数据显示到指定设备/流对象；
• getProperties(key)：根据键获取值；
• setProperties(key, value)：设置键值对到Properties对象；
• store：将Properties中的键值对存储到配置文件中（若已经存在，则覆盖），在idea中，保存信息到配置文件，若含有中文，会存储为unicode码。

案例：

读取：

package com.jiangxian.properties_;import java.io.FileNotFoundException;
import java.io.FileReader;
import java.util.Properties;/*** @author JiangXian~* @version 1.0* 使用Properties类来读取文件*/
public class Properties02 {public static void main(String[] args) throws Exception {// 1.创建对象Properties prop = new Properties();// 2.load加载文件prop.load(new FileReader("src\\mysql.properties"));// 3.list显示到屏幕prop.list(System.out);// 4.根据key获取对应的值System.out.println("用户名：" + prop.getProperty("user"));}
}

添加：

package com.jiangxian.properties_;import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;/*** @author JiangXian~* @version 1.0*/
public class Properties03 {public static void main(String[] args) throws IOException {// 使用Properties 类来创建配置文件，修改配置文件内容Properties prop = new Properties();// 创建键值对：// 若该文件没有，就创建，有就是覆盖。prop.setProperty("charset","utf8");prop.setProperty("user","汤姆");prop.setProperty("password","123456");// 将键值对存储到文件中即可，若你使用Writer存储，会出现乱码，因为你传进去的是Utf-8，将文件格式设置下也能正常显示汉字了// null代表什么呢？代表一个注释prop.store(new FileOutputStream("src\\mysql2.properties"), null);System.out.println("创建配置文件成功！");}
}

ngxian.properties_;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.util.Properties;

/**

• @author JiangXian~
• @version 1.0
• 使用Properties类来读取文件
  */
  public class Properties02 {
  public static void main(String[] args) throws Exception {
  // 1.创建对象
  Properties prop = new Properties();
  // 2.load加载文件
  prop.load(new FileReader(“src\mysql.properties”));
  // 3.list显示到屏幕
  prop.list(System.out);
  // 4.根据key获取对应的值
  System.out.println(“用户名：” + prop.getProperty(“user”));
  }
  }

### 添加：```java
package com.jiangxian.properties_;import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;/*** @author JiangXian~* @version 1.0*/
public class Properties03 {public static void main(String[] args) throws IOException {// 使用Properties 类来创建配置文件，修改配置文件内容Properties prop = new Properties();// 创建键值对：// 若该文件没有，就创建，有就是覆盖。prop.setProperty("charset","utf8");prop.setProperty("user","汤姆");prop.setProperty("password","123456");// 将键值对存储到文件中即可，若你使用Writer存储，会出现乱码，因为你传进去的是Utf-8，将文件格式设置下也能正常显示汉字了// null代表什么呢？代表一个注释prop.store(new FileOutputStream("src\\mysql2.properties"), null);System.out.println("创建配置文件成功！");}
}