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 (写 字节)
文件字节输出流，负责写。从内存到硬盘。
运行后文件末尾会多出：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： 文件字符输出流，只能输出普通文本。
复制普通文本文件
使用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("
");
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:DriversLanRealtekReadme.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:AJavaxiangmuaa
//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<User>对象
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
}
}本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。