Java学习23：IO流
2020-11-19 本文已影响0人
苦难_69e0
什么是IO？
I：Input
O：Output
通过IO可以完成硬盘文件的读和写。
什么是IO.png
IO流的分类
有多种分类方式：
一种方式是按照流的方向进行分类：
以内存作为参照物，
往内存中去，叫做输入(Input)，或者叫做读(Read)。
从内存中出来，叫做输出(Output)，或者叫做写(Write)。
另一种方式是按照读取数据方式不同进行分类：
有的流是按照字节的方式读取数据，一次读取1个字节byte，等同于一次读取8个二进制位。
这种流是万能的，什么类型的文件都可以读取，包括：文本文件，图片，声音文件，视频文件等......
字节流.png
有的流是按照字符的方式读取数据的，一次读取一个字符，这种流是为了方便读取普通文本文件而存在的，这种流不能读取：图片，声音，视频等文件，智能读取春文本文件，连word文件都无法读取。
字符流.png
综上所述：流的分类
输入流、输出流
字节流、字符流
流应该怎么学
Java中的IO流都已经写好了，我们程序员不需要关心，我们最主要还是掌握，在java中已经提供了哪些流，每个流的特点是什么，每个流对象上的常用方法有哪些？
java中所有的流都是在：java.io.*;下。
java中主要还是研究：
怎么new流对象。
调用流对象的哪个方法是读，哪个方法是写。
流的四大家族
四大家族的首领：
java.io.InputStream 字节输入流
java.io.OutputStream 字节输出流
java.io.Reder 字符输入流
java.io.Writer 字符输出流
四大家族的首领都是抽象类。（abstract class）
所有的流都实现了：
java.io.Closeable接口，都是可关闭的，都有close()方法。
流毕竟是一个管道，这个是内存和硬盘之间的通道，用完之后一定要关闭，不然会耗费（占用）很多资源。养成好习惯，用完流一定要关闭。
所有的输出流都实现了：
java.io.Flushable接口，都是可刷新的，都有flush()方法。
养成一个好习惯，输出流在最终输出之后，一定要记得flush刷新一下。这个刷新表示将通道/管道当中剩余为输出的数据强行输出完（清空管道！）刷新的作用就是清空管道。
注意：如果没有flush()可能会导致丢失数据。
注意：在java中只要“类名”以Stream结尾的都是字节流。以“Reader/Writer”结尾的都是字符流。
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.DateOutputStream
标准输出流：
java.io.PrintWriter
java.io.PrintStream
对象专属流：
java.io.ObjectInputStream
java.io.ObjectOutputStream
java.io.FileInputStream流
文件字节输入流，万能的，任何类型的文件都可以采用这个流来读。
字节的方式，完成输入的操作，完成读的操作（硬盘--->内存）
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class Text {
public static void main(String[] args) {
FileInputStream fis = null;
try {
//创建文件字节输入流对象
//文件路径：C:\Users\HP\Desktop\temp（IDEA会自动把\变成\\，因为java中\表示转义）
//temp中存储的是：abcdef
//以下是采用了：绝对路径的方式
//fis = new FileInputStream("C:\\Users\\HP\\Desktop\\temp");
//写成这个 / 也是可以的
fis = new FileInputStream("C:/Users/HP/Desktop/temp");
//开始读
int readData = fis.read();//这个方法的返回值是：被取到的“字节”本身。
System.out.println(readData);//97
readData = fis.read();
System.out.println(readData);//98
readData = fis.read();
System.out.println(readData);//99
readData = fis.read();
System.out.println(readData);//100
readData = fis.read();
System.out.println(readData);//101
readData = fis.read();
System.out.println(readData);//102
//已经读到文件的末尾了，再读的时候读取不到任何数据，返回-1
readData = fis.read();
System.out.println(readData);//-1
readData = fis.read();
System.out.println(readData);//-1
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
//在finally语句块中确保流一定关闭
if (fis != null) {//避免空指针异常
//关闭流的前提是：流不是空。流是null的时候没必要关闭
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
对以上程序读的方式进行改变
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class Text {
public static void main(String[] args) {
FileInputStream fis = null;
try {
fis = new FileInputStream("C:\\Users\\HP\\Desktop\\temp");
//开始读
/*
while (true){
int readData = fis.read();
if (readData == -1){
break;
}
System.out.println(readData);
}
*/
//进一步改进while循环
int readData = 0;
while ((readData = fis.read()) != -1){
System.out.println(readData);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fis != null) {
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
在IDEA中默认的当前路径是Project的根。
分析以上程序的缺点：
一次读取一个字节byte，这样内存和硬盘的交互太频繁，基本上时间/资源都耗费在交互上面了。能不能读取多个字节呢？可以。
int read(byte[] b)
一次最多读取b.length个字节。
减少硬盘和内存的交互，提高程序的执行效率。
往byte[]数组当中读。
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class Text {
public static void main(String[] args) {
FileInputStream fis = null;
try {
fis = new FileInputStream("C:\\Users\\HP\\Desktop\\temp");
//开始读,采用byte数组，一次读取多个字符。最多读取“数组.length”个字符
byte[] bytes = new byte[4];//准备一个4个长度的byte数组，一次最多取4个字节。
//这个方法的返回值是：读取到的字节数量。（不是字节本身）
int readCount = fis.read(bytes);
System.out.println(readCount);//第一次读到了4个字节
//将字节数组全部转换成字符串
//System.out.println(new String(bytes));//abcd
//不应该全部转换，应该是读取了多少字节，转换多少个
System.out.println(new String(bytes,0,readCount));//abcd
readCount = fis.read(bytes);//第二次只能读取到2个字节
System.out.println(readCount);//2
//将字节数组全部转换成字符串
//System.out.println(new String(bytes));//efcd
//不应该全部转换，应该是读取了多少字节，转换多少个
System.out.println(new String(bytes,0,readCount));//ef
readCount = fis.read(bytes);//1个字节都没有读取到返回-1
System.out.println(readCount);//-1
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fis != null) {
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
最终程序
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class Text {
public static void main(String[] args) {
FileInputStream fis = null;
try {
fis = new FileInputStream("C:\\Users\\HP\\Desktop\\temp");
//开始读
//准备一个byte数组
byte[] bytes = new byte[4];
/*
while(true){
int readCount = fis.read(bytes);
if (readCount == -1) {
break;
}
//把byte数组转换成字符串，读到多少个转换多少个。
System.out.print(new String(bytes,0,readCount));
}
*/
//改进while
int readCount = 0;
while((readCount= fis.read(bytes)) != -1){
System.out.println(new String(bytes,0,readCount));
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fis != null) {
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
FileInputStream的其他常用方法
int available()：返回流当中剩余的没有读到的字节数量
long skip(long n)：跳过几个字节不读
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class Text {
public static void main(String[] args) {
FileInputStream fis = null;
try {
fis = new FileInputStream("C:\\Users\\HP\\Desktop\\temp");
System.out.println("总字节数量：" + fis.available());
//读一个字节
//int readByte = fis.read();
//还剩下可以读的字节数量是：5
//System.out.println("剩下多少个字节没有读：" + fis.available());
//这方法有什么用？
byte[] bytes = new byte[fis.available()];//这种方式不太适合太大的文件，因为byte[]数组不能太大。
//不需要循环了
//直接读一次就行了
int readCount = fis.read(bytes);//6
System.out.println(new String(bytes));
//skip跳过几个字节不读取，这个方法也可能以后会用。
fis.skip(3);//跳过去3个
System.out.println(fis.read());//100
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fis != null) {
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
FileOutputStream的使用
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class Text {
public static void main(String[] args) {
FileOutputStream fos = null;
try {
//myfile文件不存在的时候会自动新建
//这种方式谨慎使用，这种方式会先将源文件清空，然后重新写入。
//fos = new FileOutputStream("myfile");
//以追加的方式在文件末尾写入。不会清空源文件内容。
fos = new FileOutputStream("myfile",true);
//开始写
byte[] bytes = {97,98,99,100};
//将byte数组全部写出！
fos.write(bytes);//abcd
//将byte数组的一部分写出！
fos.write(bytes,0,2);//再写出ab 就是abcdab
String s = "我是一个中国人，我骄傲！！！";
//将字符串转换成byte数组
byte[] bs = s.getBytes();
//写
fos.write(bs);
//写完之后，最后要刷新。
fos.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
if (fos != null) {
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
文件复制
使用FileInputStream + FileOutputStream 完成文件的拷贝。
拷贝的过程应该是一边读，一边写。
使用以上的字节流拷贝文件的时候，文件类型随意，万能的。什么文件都能拷贝。
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class CopyFile {
public static void main(String[] args) {
FileInputStream fis = null;
FileOutputStream fos = null;
try {
//创建一个输入流对象
fis = new FileInputStream("C:\\Users\\HP\\Desktop\\temp");
//创建一个输出流对象
fos = new FileOutputStream("D:\\temp");
//最核心的：一边读，一边写
byte[] bytes = new byte[1024 * 1024];//1MB(一次最多拷贝1MB)
int readCount = 0;
while ((readCount = fis.read(bytes)) != -1){
fos.write(bytes,0,readCount);
}
//刷新，输出流最后要刷新
fos.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
//分开try，不要一起try
//一起try的时候，其中一个出现异常，可能会影响到另一个流的关闭
if (fos != null) {
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (fis != null) {
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
FileReader的使用
文件字符输入流，只能读取普通文本。
读取文本内容时，比较方便快捷。
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
public class Text {
public static void main(String[] args) {
FileReader reader = null;
try {
//创建文件字符输入流
reader = new FileReader("C:\\Users\\HP\\Desktop\\temp");
/*
//准备一个char数组
char[] chars = new char[4];
//往char数组中读
reader.read(chars);//按照字符的方式读取
for (char c: chars) {
System.out.println(c);
}
*/
//开始读
char[] chars = new char[4];//一次读取4个字符
int readCount = 0;
while ((readCount = reader.read()) != -1){
System.out.println(new String(chars,0,readCount));
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
if (reader != null) {
try {
reader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
FileWriter的使用
文件字符输出流，写。
只能输出普通文本。
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
public class Text {
public static void main(String[] args) {
FileWriter out = null;
try {
//创建文件字符输出流
//out = new FileWriter("file");
out = new FileWriter("file",true);
//开始写
char[] chars = {'我','是','中','国','人'};
out.write(chars);
out.write(chars,2,3);
out.write("我是一名java软件工程师！");
//写出一个换行符
out.write("\n");
out.write("hello world!");
//刷新
out.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
if (out != null) {
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
复制普通文本文件
能使用记事本打开编辑的都是普通文本文件。
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class CopyFile1 {
public static void main(String[] args) {
FileReader in = null;
FileWriter out = null;
try {
//读
in = new FileReader("");
//写
out = new FileWriter("");
//一边读，一边写
char[] chars = new char[1024 * 512];//1MB
int readCount = 0;
while((readCount = in.read()) != -1){
out.write(chars,0,readCount);
}
//刷新
out.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (out != null) {
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (in != null) {
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
BufferedReader
带有缓冲区的字符输入流
使用这个流的时候不需要自定义char数组，或者说不需要定义byte数组。自带缓冲。
在这里没有进行try/catch是为了省事，正常编写的时候，还是该干嘛干嘛。
import java.io.BufferedReader;
import java.io.FileReader;
public class Text {
public static void main(String[] args) throws Exception{
FileReader reader = new FileReader("");
//当一个流的构造方法中需要一个流的时候，这个被传进来的流叫做：节点流。
//外部负责包装的这个流，叫做：包装流，还有一个名字叫做：处理流。
//像当前这个程序来说：FileReader就是一个节点流。BufferedReader就是包装流/处理流。
BufferedReader br = new BufferedReader(reader);
/*
//读一行
String firstLine = br.readLine();
System.out.println(firstLine);
*/
//br.readLine()方法读取一个文本行，但不带换行符
String s = null;
while((s = br.readLine()) != null){
System.out.println(s);
}
//关闭流
//对于包装流来说，只需要关闭最外层流就行，里面的节点流会自动关闭。
br.close();
}
}
转换流：InputStreamReader
import java.io.*;
public class Text {
public static void main(String[] args) throws Exception{
/*
//字节流
FileInputStream in = new FileInputStream("");
//通过转换流转换（InputStreamReader将字节流转换成字符流）
//in是节点流。reader是包装流。
InputStreamReader reader = new InputStreamReader(in);
//这个构造方法只能传一个字符流。不能传字节流
//reader是节点流。br是包装流。
BufferedReader br = new BufferedReader(reader);
*/
//合并
BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("")));
String line = null;
while((line = br.readLine()) != null){
System.out.println(line);
}
//关闭最外层
br.close();
}
}
BufferedWriter、OutputStreamWriter：转换流
带有缓冲的字符输出流
OutputStreamWriter：转换流
import java.io.*;
public class Text {
public static void main(String[] args) throws Exception{
//带有缓冲的字符输出流
//BufferedWriter out = new BufferedWriter(new FileWriter("copy"));
//转换流
BufferedWriter out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("",true)));
//开始写
out.write("hello world!");
out.write("\n");
out.write("hello kitty!");
//刷新
out.flush();
//关闭最外层
out.close();
}
}
数据流
java.io.DataOutputStream：数据专属的流。
这个流可以将数据连同数据的类型一并写入文件。
注意：这个文件不是普通文本文档。（这个文件使用记事本打不开。）
import java.io.*;
public class Text {
public static void main(String[] args) throws Exception{
//创建数据专属的字节输出流
DataOutputStream dos = new DataOutputStream(new FileOutputStream("data"));
//写数据
byte b = 100;
short s = 200;
int i = 300;
long l = 400L;
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();
//关闭最外层
dos.close();
}
}
DataInputStream：数据字节输入流。
DataOutputStream写的文件，只能使用DataInputStream去读。并且读的时候你需要提前知道写入的顺序。
读的顺序要和写的顺序一致。才可以正常取出数据。
import java.io.*;
public class Text {
public static void main(String[] args) throws Exception{
DataInputStream dis = new DataInputStream(new FileInputStream("data"));
//开始读
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();
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);
//关闭最外层
dis.close();
}
}
标准输出流
java.io.PrintStream：标准的字节输出流。默认输出到控制台。
import java.io.*;
public class Text {
public static void main(String[] args) throws Exception{
//联合起来写
System.out.println("hello world!");
//分开写
PrintStream ps = System.out;
ps.println("hello zhangsan");
ps.println("hello li");
ps.println("hello wangwu");
//标准输出流不需要手动close()关闭。
//可以改变标准输出流的输出方向么？可以
/*
//这些是之前System类使用过的方法和属性。
System.gc();
System.currentTimeMillis();
PrintStream ps2 = System.out;
System.exit();
System.arraycopy();
*/
//标准输出流不再指向控制台，指向“log”文件
PrintStream printStream = new PrintStream(new FileOutputStream("log"));
//修改输出方向，将输出方向修改到“log”文件
System.setOut(printStream);
//再输出
System.out.println("hello world");
System.out.println("hello kitty");
System.out.println("hello zhangsan");
}
}
记录日志的方法
import java.io.*;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Text {
public static void log(String[] msg){
//指向一个日志文件
PrintStream out = null;
try {
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 sttrTime = sdf.format(nowTime);
System.out.println(sttrTime + ":" + msg);
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
}
//测试工具类是否好用
public class LogText{
public static void main(String[] args){
Text.log("调用了System类的gc()方法，建议启动垃圾回收");
Text.log("用户尝试进行登录，验证失败");
}
}
File类
File类和四大家族没有关系，所以File类不能完成文件的读和写。
File对象代表：文件和目录路径名的抽象表示形式。
一个File对象有可能对应的是目录，也可能是文件。
File只是一个路径名的抽象表示形式。
File类的常用方法要掌握。
import java.io.File;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Text {
public static void main(String[] args) throws Exception{
//创建一个File对象
File f1 = new File("D:\\file");
//判断是否存在
System.out.println(f1.exists());
//如果D:\file不存在，则以文件的形式创建出来
if(!f1.exists()){
//以文件形式新建
f1.createNewFile();
}
//如果D:\file不存在，则以目录的形式创建出来
if(!f1.exists()){
//以目录形式新建
f1.mkdir();
}
//可以创建多重目录么？
File f2 = new File("D:/a/b/c/d/e/f");
if(!f2.exists()){
//以多重目录形式新建
f1.mkdirs();
}
File f3 = new File("C:\\Users\\HP\\Desktop\\temp.txt");
//获取文件的父路径
String parentPath = f3.getParent();
System.out.println(parentPath);//C:\Users\HP\Desktop
File parentFile = f3.getParentFile();
System.out.println("获取绝对路径：" + parentFile.getAbsolutePath());
//获取文件名字
System.out.println("文件名：" + f3.getName());
//判断是否是一个目录
System.out.println(f3.isDirectory());//false
//判断是否是一个文件
System.out.println(f3.isFile());//true
//获取文件最后一次修改时间
long haoMiao = f3.lastModified();//这个毫秒是从1970年到现在的总毫秒数。
//将总毫秒数转换成日期
Date time = new Date(haoMiao);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
String strTime = sdf.format(time);
System.out.println(strTime);
//获取文件大小
System.out.println(f3.length());//多少字节
//获取当前目录下所有的子文件。
File f = new File("D:\\IntelliJ IDEA Community Edition 2020.2");
File[] files = f.listFiles();
//foreach
for (File file : files) {
System.out.println(file.getAbsolutePath());
System.out.println(file.getName());
}
}
}
目录拷贝
import java.io.*;
public class CopyAll {
public static void main(String[] args) {
//拷贝源
File srcFile = new File("D:\\course\\02-javase\\document");
//拷贝目标
File destFile = new File("C:\\");
//调用方法拷贝
copyDir(srcFile,destFile);
}
/*
* 拷贝目录
* srcFile 拷贝源
* destFile 拷贝目录
* */
private static void copyDir(File srcFile, File destFile) {
if (srcFile.isFile()){
//srcFile如果是一个文件的话，，递归结束.
//是文件的时候需要拷贝。
//一边读一边写
FileInputStream in = null;
FileOutputStream out = null;
try {
//读这个文件
in = new FileInputStream(srcFile);
//写到这个文件中
String path = (destFile.getAbsolutePath().endsWith("\\") ? destFile.getAbsolutePath() : destFile.getAbsolutePath() + "\\" )+ srcFile.getAbsolutePath().substring(3);
out = new FileOutputStream(path);
//一边读一边写
byte[] bytes = new byte[1024 * 1024];//一次复制1MB
int readCount = 0;
while((readCount = in.read(bytes)) != -1){
out.write(bytes,0,readCount);
}
//刷新
out.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (out != null) {
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (in != null) {
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return;
}
//获取源下面的子目录
File[] files = srcFile.listFiles();
for (File file: files) {
//获取所有文件的（包括目录和文件）绝对路径
//System.out.println(file.getAbsolutePath());
if (file.isDirectory()){
//新建对应的目录
//System.out.println(file.getAbsolutePath());
String srcDir = file.getAbsolutePath();
System.out.println(srcDir.substring(3));
String destDir = (destFile.getAbsolutePath().endsWith("\\") ? destFile.getAbsolutePath() : destFile.getAbsolutePath() + "\\" )+ srcDir.substring(3);
File newFile = new File(destDir);
if (!newFile.exists()){
newFile.mkdirs();
}
}
//递归调用
copyDir(file,destFile);
}
}
}
对象的序列化和反序列化
对象的序列化和反序列化.png
参与序列化和反序列化的对象，必须实现Serializable接口。
注意：通过源代码发现，Serializable接口只是一个标志接口：
public interface Serializable{
}
这个接口当中什么代码都没有。
它起到了标识的作用，标志的作用，java虚拟机看到这个类实现了这个接口，可能会对这个类进行特殊待遇。
Serializable这个标志接口是给java虚拟机参考的，java虚拟机看到这个接口之后，会为该类自动生成一个序列化版本号。
序列化版本号有什么用？
java语言中采用什么机制来区分类的？
第一：首先通过类名进行比对，如果类名不一样，肯定不是同一个类。
第二：如果类名一样，再怎么进行类的区别?靠序列化版本号进行区分。
不同的人编写了同一个类，例如：A编写了一个类叫Student，B编写的一个类也叫Student。但是这两个类确实不是同一个类。这个时候序列化版本号就起上作用了。
对Java虚拟机来说，java虚拟机时可以区分开这两个类的，因为这两个类都实现了Serializable接口，都有默认的序列化版本号，他们的序列化版本号不一样。所以区分开来了。（这是自动生成序列化版本号的好处）
那这种自动生成序列化版本号有什么缺陷？
这种自动生成的序列化版本号缺点是：一旦代码确定之后，不能进行后续的修改，因为只要修改，必然会重新编译，此时会生成全新的序列化版本号，这个时候java虚拟机会认为这是一个全新的类。（这样就不好了！）
最终结论：凡是一个类实现了Serializable接口，建议给该类提供一个固定不变的序列化版本号。这样以后这个类即使代码修改了，但是版本号不变，java虚拟机会认为是同一个类。
//建议手动写出来序列化版本号，不建议自动生成
//版本号自己定义，最好是全球唯一的
private static final long serialVersionUID = 15451285684684L；
IDEA工具可以自动生成序列化版本号
File---settings---Inspections---Serializable class without 'serialVersionUID'选中---apply
使用的时候，光标放到类名上，alt + 回车 添加就好了
import java.io.Serializable;
public class Student implements Serializable {
//java虚拟机看到Serializable接口之后，会自动生成一个序列化版本号。
//这里没有手动写出来，java虚拟机会默认提供这个序列化版本号。
//建议手动写出来序列化版本号，不建议自动生成
//版本号自己定义，最好是全球唯一的
private static final long serialVersionUID = 15451285684684L；
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 + '\'' +
'}';
}
}
序列化
mport java.io.FileOutputStream;
import java.io.ObjectOutputStream;
public class Text {
public static void main(String[] args) throws Exception{
//创建java对象
Student s = new Student(111,"zhangsan");
//序列化
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("students"));
//序列化对象
oos.writeObject(s);
//刷新
oos.flush();
//关闭
oos.close();
}
}
反序列化
import java.io.FileInputStream;
import java.io.ObjectInputStream;
public class Text {
public static void main(String[] args) throws Exception{
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(""));
//开始反序列化，读
Object obj = ois.readObject();
//反序列化回来是一个学生对象，所以会调用学生对象的toString方法。
System.out.println(obj);
ois.close();
}
}
可以一次序列化多个对象么？
可以，可以将对象放到集合当中，序列化集合。
提示：参与序列化的ArrayList集合以及集合中的元素都需要实现java.io.Serializable接口。
序列化集合
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.List;
public class Text {
public static void main(String[] args) throws Exception{
List<Student> studentList = new ArrayList<>();
studentList.add(new Student(1,"zhangsan"));
studentList.add(new Student(2,"lisi"));
studentList.add(new Student(1,"wangwu"));
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("students"));
//序列化一个集合，这个集合对象中放了很多其它对象
oos.writeObject(studentList);
oos.flush();
oos.close();
}
}
反序列化集合
import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.util.List;
public class Text {
public static void main(String[] args) throws Exception{
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("students"));
//Object obj = ois.readObject();
//System.out.println(obj instanceof List);
List<Student> studentList = (List<Student>)ois.readObject();
for (Student student: studentList) {
System.out.println(student);
}
ois.close();
}
}
那如果我不希望Student中的某一个属性，参与序列化呢？
可以使用transient关键字修饰。
例如：private transient String name;
transient关键字表示游离的，不参与序列化。
IO + Properties的联合应用
Properties是一个Map集合，key和value都是String类型。
想将某一个文件（例如：userinfo）中的数据加载到Properties对象当中。
userinfo文件中存储的是:username=admin password=123
非常好的一个设计理念：
以后经常改变的数据，可以单独写到一个文件中，使用程序动态读取。将来只需要修改这个文件的内容，java代码不需要改动，不需要重新编译，服务器也不需要重启。就可以拿到动态的信息。
类似于以上机制的这种文件称为配置文件。
并且当配置文件中的内容格式是：
key1=value1
key2=value2
的时候，我们把这种配置文件叫做属性配置文件。
java规范中有要求：属性配置文件建议以.properties结尾，但这不是必须的。
这种以.properties结尾的文件再java中被称为：属性配置文件。
其中Properties对象是专门存放属性配置文件的内容的一个类。
在属性配置文件中井号是注释
属性配置文件的key重复的话，value会自动覆盖！
注意：key=value中间最好不要有空格，除了用等号隔开也可以用冒号隔开，但是不建议使用冒号隔开。
import java.io.FileReader;
import java.util.Properties;
public class Text {
public static void main(String[] args) throws Exception{
//新建一个输入流对象
FileReader reader = new FileReader("userinfo");
//新建一个Map集合
Properties pro = new Properties();
//调用Properties对象的Load方法将文件中的数据加载到Map集合中。
pro.load(reader);//文件中的数据顺着管道加载到Map集合中，其中等号=左边做key，右边做value
//通过key来获取value
String username = pro.getProperty("username");
System.out.println(username);
String password = pro.getProperty("password");
System.out.println(password);
}
}
