猿创征文｜Java中的IO流大家族 （两万字详解）
目录
- IO流
-
- 概述
-
- 分类
- 四大家族
- 需要掌握的16个流
- 文件专属
-
- FileInputstream（读 字节）
-
- FileInputStream类的其他常用方法
- FileOutputStream (写 字节)
- 文件复制
- FileReader（读 字符）
- FileWriter （写 字符）
- 复制普通文本文件
- 缓冲流专属和转换流
-
- BufferedReader读，和InputStreamReader转换流联合使用
- BufferedWriter写，和OutputStreamWriter转换流联合使用
- 数据流专属
-
- DataOutputStream 写
- DataInputStream 读
- 标准输出流
-
- 利用标准输出流做一个记录日志工具
- File类
-
- 14个常用方法
- 序列化和反序列化
-
- 单个对象序列化（ObjectOutputStream）
-
- 反序列化（ObjectInputStream）
- 集合序列化和反序列化
-
- 序列化多个对象集合（ObjectOutputStream ）
- 反序列化集合（ObjectInputStream ）
- 序列化版本号
-
- IDEA工具生成版本号快捷键
- IO和Properties属性类的联合应用
IO流
概述
IO流，什么是IO？
I:Input
O:Output
通过IO可以完成硬盘文件的读和写。
分类
IO流有多种分类方式:
一种方式是按照流的方向进行分类:
以内存作为参照物，
往内存中去，叫做输入(Input)。或者叫做读(Read)。
从内存中出来，叫做输出(Output)。或者叫做写(Write)
另一种方式是按照读取数据方式不同进行分类:
有的流是按照字节的方式读取数据，一次读取1个字节byte，等同于一次读取8个二进制，这种流是万能的，什么类型的文件都可以读取。包括:文本文件，图片，声音文件，视频。
假设文件file1.txt，采用字节流的话是这样读的:
a中国bc张三fe
第一次读:一个字节，正好读到’a’
第二次读:一个字节，正好读到’中’字符的一半。
第三次读:一个字节，正好读到’中’字符的另外一半。
有的流是按照字符的方式读取数据的，一次读取一个字符，这种流是为了方便读取普通文本文件而存在的，这种流不能读取:图片、声音、视频等文件。只能读取纯文本文件，连word文件都无法读取。
假设文件filel.txt，采用字符流的话是这样读的:
a中国bc张三fe
第一次读:'a’字符(a字符在windows系统中占用1个字节。)
第二次读:'中’字符(中字符在windows系统中占用2个字节。)
综上所述：流的分类是输入流、输出流、字节流、字符流。
四大家族
java IO流这块有四大家族:
四大家族的首领:
java.io.Inputstream字节输入流
java.io.Outputstream字节输出流
java.io.Reader 字符输入流
java.io.Writer 字符输出流
四大家族的首领都是抽象类。(abstract class)
所有的流都实现了:
java.io.closeable接口，都是可关闭的，都有close()方法。
流毕竟是一个管道，这个是内存和硬盘之间的通道，用完之后一定要关闭，不然会耗费(占用)很多资源。养成好习惯，用完流一定要关闭。
所有的输出流都实现了:
java.io.Flushable接口，都是可刷新的，都有flush()方法。
养成一个好习惯，输出流在最终输出之后，一定要记得flush()刷新一下。这个刷新表示将通道/管道当中剩余未输出的数据强行输出完(清空管道!)刷新的作用就是清空管道。注意:如果没有flush()可能会导致丢失数据。
注意:在java中只要"类名"以stream结尾的都是字节流。以“Reader/Writer”结尾的都是字符流。
需要掌握的16个流
Java中的IO流都已经写好了，我们程序员不需要关心，我们最主要还是掌握，在java中已经提供了哪些流，每个流的特点是什么，每个流对象上的常用方法有哪些???
java中所有的流都是在:java.io.*;下。
java中主要还是研究:
怎么new流对象。
调用流对象的哪个方法是读，哪个方法是写。
java.io包下需要掌握的流有16个:
文件专属:
java.io.FileInputstream
java.io.FileOutputstream
java.io.FileReader
java.io.FileWriter
转换流:(将字节流转换成字符流)
java.io.InputStreamReader
java.io.OutputStreamWriter
缓冲流专属:
java.io.BufferedReader
java.io.BufferedWriter
java.io.BufferedInputStream
java.io.BufferedOutputStream
数据流专属:
java.io.DataInputStream
java.io.DataOutputStream
标准输出流:
java.io.PrintWriter
java.io.PrintStream
对象专属流:
java.io.ObjectInputStream
java.io.ObiectOutputStream
文件专属
FileInputstream（读 字节）
java.io.FileInputStream:
1、文件字节输入流，万能的，任何类型的文件都可以采用这个流来读。
2、字节的方式，完成输入的操作，完成读的操作(硬盘—>内存)
Read()方法:读取内容，返回值是读到几个数量，就返回几，当读完的时候，返回-1，就代表没有了
public class FileInputStream读 {
public static void main(String[] args) throws IOException {
FileInputStream fis = null;
try {
//创建文件字节流输入对象
fis = new FileInputStream("D:\\AJava\\新建文件夹\\aaa");
/* while (true){
int rea = fis.read(); //read（）:读文件
if (rea == -1 ){
break;
}
System.out.println(rea);
}*/
//改造while
int aaa = 0;
while ((aaa= fis.read())!=-1){
System.out.println(aaa);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
}finally {
//关闭流的前提是流不是空，流是空没有必要关
if (fis != null) {
fis.close();
}
}
}
}
分析以上程序的缺点:
一次读取一个字节byte，这样内存和硬盘交互太频繁，基本上时间/资源都耗费在交互上面了。能不能一次读取多个字节呢?可以。
public class FileInputStream读最终版 {
public static void main(String[] args) {
FileInputStream fil = null;
try {
//创建文件字节输入流
fil = new FileInputStream("JAVAse进阶/src/IO流/aa");
//开始读，采用byte数组，一次读取多个字节。最多读取“数组.length”个字节
byte[] bytes= new byte[4];//准备一个4个长度的byte数组，一次最多读取4个字节
/* while (true){
int rea = fil.read(bytes);
if (rea==-1){
break;
}
System.out.print(new String(bytes,0,rea));
}*/
int aaa=0; //提前准备一个变量
while ((aaa=fil.read(bytes))!=-1){
//使用String构造方法，将byte转换为字符串，从0开始，到aaa结束，转换这么多
//aaa返回的是读取字节数量。
System.out.print(new String(bytes,0, aaa));
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fil != null) {
try {
fil.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
FileInputStream类的其他常用方法
FileInputstream类的其它常用方法:
int available():返回流当中剩余的没有读到的字节数量
Long skip(long n):跳过几个字节不读。
public class FileInputStream类的其他常用方法 {
public static void main(String[] args) {
FileInputStream fil = null;
try {
fil = new FileInputStream("JAVAse进阶/src/IO流/aa");
System.out.println(fil.available());
//准备一个长度为fil.available长度的数组，一次最多读fil.available()个字节
byte[] bytes = new byte[fil.available()];// 这种方式不太适合太大文件，因为byte数组不能太大
//不需要循环了，直接读一次就行了，返回的是一次读到的字节
int read = fil.read(bytes);
//读取到的字节转换为字符串输出
System.out.println(new String(bytes));
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fil != null) {
try {
fil.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
FileOutputStream (写 字节)
文件字节输出流，负责写。从内存到硬盘。
public class FileOutputStream写 {
public static void main(String[] args) {
FileOutputStream fos=null;
try {
//如果没有这个文件，会自动创建一个
//这种构造方法会将原文件清空，然后重新写入
//fos = new FileOutputStream("JAVAse进阶/src/IO流/aa");
//这个构造方法，以追加的方式在文件末尾写入，不会清空原文件内容。
fos = new FileOutputStream("JAVAse进阶/src/IO流/aa",true);
//开始写
byte[] bytes = {97,98,99,100};
//将byte全部写出
fos.write(bytes);
//将byte数组一部分写出 从下标0开始，取2个
fos.write(bytes,0,2);
//字符串
String s = "我是一个中国人";
//将字符串转换成byte数组。
byte[] bytes1 = s.getBytes(StandardCharsets.UTF_8);
//写
fos.write(bytes1);
//写完之后一定要刷新
fos.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (args != null) {
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
运行后文件末尾会多出：abcdab我是一个中国人
文件复制
使用FileInputStream+FileOutputStream完成文件的拷贝。拷贝的过程应该是一边读，一边写。
使用以上的字节流拷贝文件的时候，文件类型随意，万能的。什么样的文件都能拷贝。
public class 文件复制 {
public static void main(String[] args) {
FileInputStream fis = null;
FileOutputStream fos = null;
try {
//创建一个输入流对象
fis= new FileInputStream("D:\\a剪辑\\完成视频\\123.mp4");
//创建一个输出流对象
fos = new FileOutputStream("D:\\123.mp4");
//最核心 一边写 一边读
byte[] bytes =new byte[1024*1024]; //1MB(一次最多拷贝1MB)
int aa = 0;
while ((aa= fis.read(bytes))!=-1){ //Fis.Read(bytes) :往bytes数组中读
fos.write(bytes,0,aa); // 然后从数组拿出来 一次写aa个，aa是写入数组的数量
}
//刷新 输出流最后要刷新
fos.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fos == null) {
// 分开try，不要一起try
// 一起try的时候，其中一个异常，可能会影响另外一个流的关闭。
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
FileReader（读 字符）
FileReader ：文件字符输入流。只能读取普通文本。
读取文本内容时，比较方便，快捷。
FileReader 和上面 FileInputStream（读 字节）的使用方法一样，直接照葫芦画瓢
public class FileReader读 {
public static void main(String[] args) {
FileReader fileReader = null;
try {
//创建文件字符输入流
fileReader = new FileReader("JAVAse进阶/src/IO流/aa");
//开始读
char [] chars = new char[4]; //一次读四个字符
int red = 0;
while ((red = fileReader.read(chars))!=-1){
//使用String构造方法，将char转换为字符串，从0开始，到red结束，转换这么多
//red返回的是读取字符数量。
System.out.print(new String(chars,0,red));
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fileReader != null) {
try {
fileReader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
FileWriter （写 字符）
FileWriter： 文件字符输出流，只能输出普通文本。
public class FileWriter写 {
public static void main(String[] args) {
FileWriter fileWriter = null;
try {
//创建文件字符流对象 清空原文内容在写入
//fileWriter = new FileWriter("JAVAse进阶/src/IO流/aa");
//加个ture 表示不清空原文内容，从后面追加
fileWriter = new FileWriter("JAVAse进阶/src/IO流/aa",true);
//创建一个char数组
char[] chars = {'我','是','中','国','人'};
//全部写出
fileWriter.write(chars);
//部分写出，下标从2开始，取三个
fileWriter.write(chars,2,3);
//直接传入一个String也是可以的
fileWriter.write("我是中国人");
//换行符
fileWriter.write("\n");
fileWriter.write("励志当一个程序员");
//刷新 写出都要刷新
fileWriter.flush();
} catch (IOException e) {
e.printStackTrace();
}finally {
if (fileWriter != null) {
try {
fileWriter.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
复制普通文本文件
使用FileReader, FileWriter进行拷贝的话，只能拷贝“普通文本”文件。
public class 复制普通文本文件 {
public static void main(String[] args) {
FileReader du = null;
FileWriter xie = null;
try {
//读
du = new FileReader("JAVAse进阶/src/IO流/aa");
//写
xie = new FileWriter("aa");
//一边读一边写
char [] chars = new char[1024*512];
int aa = 0;
//du.read(chars) 往chars数组中读
while ((aa =du.read(chars) )!=-1){
//读多少写多少
xie.write(chars,0,aa);
}
//刷新
xie.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
if (xie != null) {
try {
xie.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (du != null) {
try {
du.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
缓冲流专属和转换流
BufferedReader读，和InputStreamReader转换流联合使用
BufferedReader:
带有缓冲区的字符输入流。
使用这个流的时候不需要自定义char数组，或者说不需要自定义byte数组。自带缓冲。
BufferedReader的括号里面要求传的是Reader(字符输入流)，如果要传字节输入流，就要使用转换流(InputStreamReader)，使字节输入流转成字符输入流。
public class BufferedReader读_加转换流 {
public static void main(String[] args) {
BufferedReader br= null;
FileReader fr = null;
FileInputStream fis = null;
InputStreamReader isr = null;
try {
/* 这里面演示的是BufferedReader传入一个Reader
这个构造方法里面只能传入Reader类型的，如果要传入字节输入流，就要用转换流转换
fr = new FileReader("D:\\AJava\\新建文件夹\\aaa");
br = new BufferedReader(fr);*/
//这个构造方法里面只能传入字符输入流类型。传入字节输入流要使用转换流，把字节输入流转换成字符入出流
//演示传入字节输入流 用转换流
//创建字节输入流对象
fis = new FileInputStream("aa");
//创建转换流对象（字节输入转换成字符输入）
isr= new InputStreamReader(fis);
//创建BufferdReader对象
br = new BufferedReader(isr);
/*上面的合并在一起写 也就不用上面的赋值null了
//当一个流的构造方法中需要一个流的时候，这个被传进来的流叫做:节点流。外部负责包装的这个流，叫做:包装流，还有一个名字叫做:处理流。
br = new BufferedReader(new InputStreamReader(new FileInputStream("aa")));*/
//readLine()读取一行内容，当读到末尾没有内容的时候，返回null
String aa =null;
while ((aa = br.readLine())!=null){
System.out.println(aa);
}
/*String s = br.readLine();
System.out.println(s);读一行内容*/
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fr != null) {
try {
br.close(); //对于包装流来说，只需要关闭最外层的流就行，里面的节点会自动关闭。
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
BufferedWriter写，和OutputStreamWriter转换流联合使用
BufferedWriter ：带有缓冲的字符输出流。
OutputStreamWriter：转换流。
BufferedWriter 括号里面要求传的是writer(字符输出流)，如果要传字节输出流，就要使用转换流(OutputStreaWriter)，使字节输出流转换成字符输出流。
public class BufferedWriter写_加转换流 {
public static void main(String[] args) {
BufferedWriter bw =null;
try {
/*传入字符writer类型的输出流
bw = new BufferedWriter(new FileWriter("aa",true));*/
//里面只能传入字符输出流类型。传入字节输出流要使用转换流，把字节输出流转换成字符输出流
bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("JAVAse进阶/src/IO流/aa",true)));
bw.write("我是一个大帅哥");
bw.write("\n");
bw.write("你好大帅哥");
//刷新
bw.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (bw != null) {
try {
bw.close(); //关闭最外层
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
数据流专属
DataOutputStream 写
java.io.DataOutputStream:数据专属的流。这个流可以将数据连同数据的类型一并写入文件。
注意:这个文件不是普通文本文档。(这个文件使用记事本打不开。)
public class 数据流_写 {
public static void main(String[] args) throws IOException {
// 创建数据专属的字节输入流
DataOutputStream dos = new DataOutputStream(new FileOutputStream("JAVAse进阶/src/IO流/aa"));
// 写数据
byte b = 100;
short s = 200;
int i = 300;
long l = 400;
float f = 3.0F;
double d = 3.14;
boolean sex = false;
char c = 'a';
// 写
dos.writeByte(b); // 把数据以及数据的类型一并写入到文件当中。
dos.writeShort(s);
dos.writeInt(i);
dos.writeLong(l);
dos.writeFloat(f);
dos.writeDouble(d);
dos.writeBoolean(sex);
dos.writeChar(c);
//刷新
dos.flush();
}
}
DataInputStream 读
DataInputStream:数据字节输入流。
DataOutputStream写的文件，只能使用DataInputStream去读。并且读的时候你需要提前知道写入的顺序。读的顺序需要和写的顺序一致。才可以正常取出数据。
public class 数据流_读 {
public static void main(String[] args) throws IOException {
//创建对象
DataInputStream dis = new DataInputStream(new FileInputStream("JAVAse进阶/src/IO流/aa"));
//开始读
byte b = dis.readByte();
short s = dis.readShort();
int i = dis.readInt();
long l = dis.readLong();
float f = dis.readFloat();
double d = dis.readDouble();
boolean sex = dis.readBoolean();
char c = dis.readChar();
dis.close();
System.out.println(b);
System.out.println(s);
System.out.println(i);
System.out.println(l);
System.out.println(f);
System.out.println(d);
System.out.println(sex);
System.out.println(c);
}
}
输出结果：
标准输出流
//联合起来写
System.out.println("hello world!");
//分开写
PrintStream ps =System.out;
ps.println("hello world!");
标准输出流不需要手动close()关闭。可以改变标准输出流的输出放向
public class PringtStream标准输出流 {
public static void main(String[] args) {
PrintStream printStream = null;
try {
//标准输出流不在指向控制台，指向log输出流文件
printStream = new PrintStream(new FileOutputStream("log输出流文件",true));
//修改输出方向，将输出方向修改到“log输出流文件”文件
System.setOut(printStream);
//下面输出的 ，就不会再控制台显示了，会写入到“log输出流文件”这个文件
System.out.println("你好");
System.out.println("iedsoafj");
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
}
执行结果
会发现没有输出到控制台，而是输出到了指定文件
利用标准输出流做一个记录日志工具
/*
日志工具
*/
public class logger {
/**
* 记录日志的方法
* @param msg 发生了神什么事
*/
public static void log(String msg) {
//PrintStream printStream = null;
try {
//指向一个日志文件
PrintStream printStream = new PrintStream(new FileOutputStream("JAVAse进阶/src/IO流/输出流日志/log.txt",true));
//PrintStream printStream = new PrintStream(new FileOutputStream("JAVAse进阶/src/IO流/输出流日志/log.txt"),true);
//改变输出方向
System.setOut(printStream);
//日期当前时间
Date date = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
String format = sdf.format(date);
//什么时间发生了什么事件
System.out.println(format+":"+msg);
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
}
public class 测试日志方法 {
public static void main(String[] args) {
//测试工具类
logger.log("有灰正在编写java代码");
logger.log("有灰正在测试日志工具类");
logger.log("写一上午代码的有灰，眼睛好累，好模糊！");
}
}
运行后输出结果
会发现已经在文件中记录
File类
1、File类和四大家族没有关系，所以File类不能完成文件的读和写。
2、File对象代表什么?
文件和目录路径名的抽象表示形式。
C:\Drivers这是一个File对象
C:\Drivers\LanRealtek\Readme.txt也是File对象。
一个File对象有可能对应的是目录，也可能是文件。 File只是一个路径名的抽象表示形式。
3、需要掌握File类中常用的方法。
14个常用方法
exists():判断这个文件是否存在
createNewFile():以文件的形式创建出来
file.mkdir():以目录的形式创建出来
mkdirs():可以创建多重目录
getParent():获取文件的父路径
getParentFile():获取文件的父路径,和上面的返回类型不一样，其他都一样
getAbsolutePath():获取绝对路径
getName():获取文件名
isDirectory():判断是否是一个目录
isFile():判断是否是一个文件
lastModified():获取文件最后一次修改时间
length（）：获取文件大小
listFiles():获取当前目录下所有的子文件。返回值是File[], 遍历输出获得这个路径下的子文件的绝对路径
list():返回值是String[], 遍历输出获得这个路径下的子文件的文件名
详细介绍
public class File类的常用方法 {
public static void main(String[] args) throws IOException {
//创建File对象
File file = new File("D:\\AJava\\新建文件夹1");
//exists():判断这个文件是否存在
System.out.println(file.exists());
//createNewFile():如果D:\AJava\新建文件夹1不存在，则以文件的形式创建出来
if(!file.exists()){
file.createNewFile();//此处有异常
}
//file.mkdir():如果D:\AJava\新建文件夹1不存在，则以目录的形式创建出来
if(!file.exists()){
//
file.mkdir();
}
//mkdirs()可以创建多重目录
File file1 = new File("D:\\AJava\\a\\ab\\cd\\ef");
if (!file1.exists()){
file1.mkdirs();
}
File file2 = new File("D:\\AJava\\新建文件夹\\新建文件夹\\你好.txt");
//getParent():获取文件的父路径
String parent = file2.getParent();
System.out.println(parent);//D:\AJava\新建文件夹\新建文件夹
//getParentFile():获取文件的父路径,和上面的返回类型不一样，其他都一样
File parentFile = file2.getParentFile(); //返回的是File对象，还可以继续掉其他方法
System.out.println(parentFile);//D:\AJava\新建文件夹\新建文件夹
File file3 = new File("aa");
//getAbsolutePath():获取绝对路径
System.out.println("绝对路径："+ file3.getAbsolutePath());//绝对路径：D:\AJava\xiangmu\aa
//getName():获取文件名
System.out.println("文件名："+file3.getName());
//isDirectory():判断是否是一个目录
System.out.println(file3.isDirectory());//false
//isFile():判断是否是一个文件
System.out.println(file3.isFile());//true
//lastModified():获取文件最后一次修改时间
long l = file3.lastModified();//这个毫秒是从1970年到现在的总毫秒数
//将总毫秒数转换成日期
Date date = new Date(l);
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS ");
String format = simpleDateFormat.format(date);
System.out.println(format);//2021-07-16 10:50:23 937
//length（）：获取文件大小
System.out.println(file3.length());//74字节
File f = new File("D:\\AJava");
//listFiles():获取当前目录下所有的子文件。返回值是File[], 遍历输出获得这个路径下的子文件的绝对路径
File[] files = f.listFiles();
for (File e : files){
System.out.println(e); //和绝对路径一样
//System.out.println(e.getName()); //所有的文件名
//System.out.println(e.getAbsolutePath());//所有的绝对路径
}
//list():返回值是String[], 遍历输出获得这个路径下的子文件的文件名
String[] a = f.list();
for (String s : a) {
System.out.println(s);
}
}
}
序列化和反序列化
1、java.io.NotSerializableException:
Student对象不支持序列化!!!
2、参与序列化和反序列化的对象，必须实现serializable接口。
3、注意:通过源代码发现Serializable接口只是一个标志接口:
public interface Serializable{}
这个接口当中什么代码都没有。那么它起到一个什么作用呢?
起到标识的作用，标志的作用，java虚拟机看到这个类实现了这个接口，可能会对这个类进行特殊待遇。 Serializable这个标志接口是给java虚拟机参考的，java虚拟机看到这个接口之后，会为该类自动生成一个序列化版本号。
例如：它可以把内存中某个对象持久化、永久性的保存到硬盘文件，断电之后这个状态还在；下一次重启电脑的时候，再把硬盘上的文件恢复发哦内存当中。
单个对象序列化（ObjectOutputStream）
Student对象
public class Student implements Serializable {
//Java虚拟机看到Serializable接口之后，会自动生成一个序列化版本号。
//这里没有手动写出来，Java虚拟机会自动提供这个序列化版本号
private int no ;
//transient (穿森的) ：关键字 表示游离，不参与序列化
private transient String name; //name 不参与序列化操作
public Student() {
}
public Student(int no, String name) {
this.no = no;
this.name = name;
}
public int getNo() {
return no;
}
public void setNo(int no) {
this.no = no;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Student{" +
"no=" + no +
", name='" + name + '\'' +
'}';
}
}
public class 序列化的实现 {
public static void main(String[] args) throws Exception {
//创建java对象
Student s = new Student(1111,"zhangsna");
//序列化 异常先抛出去了 不管了
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("JAVAse进阶/src/IO流/序列化和反序列化/students"));
//序列化对象
oos.writeObject(s);
//刷新
oos.flush();
//关闭
oos.close();
}
}
反序列化（ObjectInputStream）
public class 反序列化的实现 {
public static void main(String[] args) throws Exception {
//创建反序列化对象
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("JAVAse进阶/src/IO流/序列化和反序列化/students"));
//开始反序列化 读
Object obj = ois.readObject();
//反序列化回来是一个学生对象。所以会调用学生对象的toString方法
System.out.println(obj);//Student{no=1111, name='zhangsna'}
//关闭
ois.close();
}
}
集合序列化和反序列化
一次序列化多个对象，将对象方放到集合中，序列化集合
提示：参与序列化的ArrayList集合以及集合中的User元素都需要实现java.io.Serializable接口
ArrayList集合已经实现了这个接口，所以我们要把我们自己定义的类(User)实现了
序列化多个对象集合（ObjectOutputStream ）
User对象
public class User implements Serializable {
private int no ;
private String name;
public User() {
}
public User(int no, String name) {
this.no = no;
this.name = name;
}
public int getNo() {
return no;
}
public void setNo(int no) {
this.no = no;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "User{" +
"no=" + no +
", name='" + name + '\'' +
'}';
}
}
实现
public class 序列化多个对象集合 {
public static void main(String[] args) throws Exception{
List<User> userList = new ArrayList<>();
userList.add(new User(1,"zhangsan"));
userList.add(new User(2,"lisi"));
userList.add(new User(3,"wnagwu "));
userList.add(new User(4,"zhaliu"));
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("JAVAse进阶/src/IO流/序列化和反序列化/users"));
//一次序列化一个集合，这个集合对象中放了很多其他对象。
oos.writeObject(userList);
oos.flush();
oos.close();
}
}
反序列化集合（ObjectInputStream ）
public class 反序列化集合 {
public static void main(String[] args) throws Exception {
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("JAVAse进阶/src/IO流/序列化和反序列化/users"));
//Object o = ois.readObject();
//System.out.println(o instanceof List); //true 代表o是一个List集合
//ois.readObject()返回的是一个List集合，读出来后直接强转成List对象
List<User> userList = (List<User>)ois.readObject();
//for循环 取出每个序列化对象
for (User user : userList) {
System.out.println(user); //User的tuString已经重写
}
ois.close();
}
}
序列化版本号
序列化版本号有什么用呢?
java.io.InvalidClassException:
com.java.bean.Student ；
Local class incompatible:
stream classdesc serialVersionUID=-684255398724514298(十年后)
local class serialVersionUID=-3463447116624555755(十年前)
java语言中是采用什么机制来区分类的?
第一:首先通过类名进行比对，如果类名不一样，肯定不是同一个类。
第二:如果类名一样，再怎么进行类的区别?靠序列化版本号进行区分。
小鹏编写了一个类:com.java.bean.Student implements Serializable
胡浪编写了一个类:com.java.bean.Student implements Serializable不同的人编写了同一个类，但“这两个类确实不是同一个类”。这个时候序列化版本就起上作用了。
对于iava虚拟机来说，java虚拟机是可以区分开这两个类的，因为这两个类都实现了Serializable接口，都有默认的序列化版本号，他们的序列化版本号不一样。所以区分开了。(这是自动生成序列化版本号的好处。
请思考?
这种自动生成序列化版本号有什么缺陷?
这种自动生成的序列化版本号缺点是:一旦代码确定之后，不能进行后续的修改。因为只要修改，必然会重新编译，此时会生成全新的序列化版本号，这个时候java虚拟机会认为这是一个全新的类，重新序列化后，生成新的序列化版本号，之前序列化进去的东西，再反序列化后就会出问题，因为前后序列化版本号不一样。(这样就不好了!)
所以 可以手动写个序列化版本号固定的。
最终结论:
凡是一个类实现了Serializable接口，建议给该类提供一个固定不变的序列化版本号。这样，以后这个类即使代码修改了，但是版本号不变，java虚拟机会认为是同一个类。
public class Student implements Serializable {
//Java虚拟机看到Serializable接口之后，会自动生成一个序列化版本号。
//这里没有手动写出来，Java虚拟机会自动提供这个序列化版本号
// 建议将序列化版本号手动的写出来。不建议自动生成
private static final long serialVersionUID = 1L;//手动写出来
// 如果是自动生成的序列化版本号，过了很久，Student这个类的源代码改动了，
// 源代码改动之后，需要重新编译，编译之后生成了全新的字节码文件，
// 并且class文件再次运行的时候，java虚拟机生成的序列化版本号也会发生相应的改变，
//而上面自己手动写了一个固定的序列化版本号，以后这个类即使代码修改了，但是版本号不变，java虚拟机会认为是同一个类。
private int no ;
private String name;
public Student() {
}
public Student(int no, String name) {
this.no = no;
this.name = name;
}
public int getNo() {
return no;
}
public void setNo(int no) {
this.no = no;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Student{" +
"no=" + no +
", name='" + name + '\'' +
'}';
}
}
IDEA工具生成版本号快捷键
首先进入设置把下面图片红框框出来的那一栏打上勾
IO和Properties属性类的联合应用
IO+Properties的联合应用。
非常好的一个设计理念:
以后经常改变的数据，可以单独写到一个文件中，使用程序动态读取。将来只需要修改这个文件的内容，Java代码不需要改动，不需要重新编译，服务器也不需要重启。就可以拿到动态的信息。
类似于以上机制的这种文件被称为配置文件。并且当配置文件中的内容格式是:
key1=value
key2=value
的时候，我们把这种配置文件叫做属性配置文件。
java规范中有要求:属性配置文件建议以.properties结尾，但这不是必须的。这种以.properties结尾的文件在java中被称为:属性配置文件。其中Properties是专门存放属性配置文件内容的一个类。
示例
配置文件
代码
public class IO和Properties联合应用 {
public static void main(String[] args) throws Exception{
/*
Properties是一个Map集合，Key和Value都是String类型
想将aaaa文件中的数据加载到Properties对象当中。
*/
//新建一个输入流对象
FileReader fileReader = new FileReader("JAVAse进阶/src/IO流/联合应用/aaaa.properties");
//新建一个Map集合
Properties properties = new Properties();
//调用Properties对象的load方法将文件中的数据加载到Map集合中
properties.load(fileReader);//文件中的数据顺着管道加载到Map集合中，其中等号左边是Key，右边是Value
//通过Key来获取Value
String username = properties.getProperty("username");
System.out.println(username);// 输出：admin
String password = properties.getProperty("password");
System.out.println(password);// 输出：123456
}
}