共计 29564 个字符，预计需要花费 74 分钟才能阅读完成。
文章和代码曾经归档至【Github 仓库：https://github.com/timerring/java-tutorial】或者公众号【AIShareLab】回复 java 也可获取。
文件
文件，对咱们并不生疏, 文件是保留数据的中央。文件在程序中是以流的模式来操作的。
流：数据在数据源 (文件) 和程序 (内存) 之间经验的门路
输出流：数据从数据源 (文件) 到程序 (内存) 的门路
输入流：数据从程序 (内存) 到数据源 (文件) 的门路
罕用的文件操作
创立文件对象相干结构器和办法
new File(String pathname)// 依据门路构建一个 File 对象new File(File parent, String child)// 依据父目录文件 + 子门路构建 newFile(String parent, String child)// 依据父目录 + 子门路构建
package com.hspedu.file;
import org.junit.jupiter.api.Test;
import java.io.*;
/**
* 演示创立文件
*/
public class FileCreate {public static void main(String[] args) { }
// 形式 1 new File(String pathname)
@Test
public void create01() {
String filePath = "e:\\news1.txt";
File file = new File(filePath);
try {file.createNewFile();
System.out.println("文件创建胜利");
} catch (IOException e) {e.printStackTrace();
}
}
// 形式 2 new File(File parent,String child) // 依据父目录文件 + 子门路构建
//e:\\news2.txt
@Test
public void create02() {File parentFile = new File("e:\\");
String fileName = "news2.txt";
// 这里的 file 对象，在 java 程序中，只是一个对象
// 只有执行了 createNewFile 办法，才会真正的，在磁盘创立该文件
File file = new File(parentFile, fileName);
try {file.createNewFile();
System.out.println("创立胜利~");
} catch (IOException e) {e.printStackTrace();
}
}
// 形式 3 new File(String parent,String child) // 依据父目录 + 子门路构建
@Test
public void create03() {
//String parentPath = "e:\\";
String parentPath = "e:\\";
String fileName = "news4.txt";
File file = new File(parentPath, fileName);
try {file.createNewFile();
System.out.println("创立胜利~");
} catch (IOException e) {e.printStackTrace();
}
}
// 上面四个都是抽象类
//InputStream
//OutputStream
//Reader // 字符输出流
//Writer // 字符输入流
}获取文件的相干信息
getName、getAbsolutePath、getParent、length、exists、isFile、isDirectory
package com.hspedu.file;
import org.junit.jupiter.api.Test;
import java.io.File;
public class FileInformation {public static void main(String[] args) { }
// 获取文件的信息
@Test
public void info() {
// 先创立文件对象
File file = new File("e:\\news1.txt");
// 调用相应的办法，失去对应信息
System.out.println("文件名字 =" + file.getName());
// getName、getAbsolutePath、getParent、length、exists、isFile、isDirectory
System.out.println("文件绝对路径 =" + file.getAbsolutePath());
System.out.println("文件父级目录 =" + file.getParent());
System.out.println("文件大小(字节)=" + file.length());
System.out.println("文件是否存在 =" + file.exists());//T
System.out.println("是不是一个文件 =" + file.isFile());//T
System.out.println("是不是一个目录 =" + file.isDirectory());//F
}
}目录的操作和文件删除
mkdir 创立一级目录、mkdirs 创立多级目录、delete 删除空目录或文件
利用案例演示
1) 判断 d:\\news1.txt是否存在，如果存在就删除
2) 判断 D:\\ldemo02 是否存在，存在就删除, 否则提醒不存在.
3) 判断 D:\\demo\\a\\b\\c目录是否存在，如果存在就提醒曾经存在，否则就创立
package com.hspedu.file;
import org.junit.jupiter.api.Test;
import java.io.File;
import java.io.InputStream;
import java.io.OutputStream;
public class Directory_ {public static void main(String[] args) {//}
// 判断 d:\\news1.txt 是否存在，如果存在就删除
@Test
public void m1() {
String filePath = "e:\\news1.txt";
File file = new File(filePath);
if (file.exists()) {if (file.delete()) {System.out.println(filePath + "删除胜利");
} else {System.out.println(filePath + "删除失败");
}
} else {System.out.println("该文件不存在...");
}
}
// 判断 D:\\demo02 是否存在，存在就删除，否则提醒不存在
// 这里咱们须要领会到，在 java 编程中，目录也被当做文件
@Test
public void m2() {
String filePath = "D:\\demo02";
File file = new File(filePath);
if (file.exists()) {if (file.delete()) {System.out.println(filePath + "删除胜利");
} else {System.out.println(filePath + "删除失败");
}
} else {System.out.println("该目录不存在...");
}
}
// 判断 D:\\demo\\a\\b\\c 目录是否存在，如果存在就提醒曾经存在，否则就创立
@Test
public void m3() {
String directoryPath = "D:\\demo\\a\\b\\c";
File file = new File(directoryPath);
if (file.exists()) {System.out.println(directoryPath + "存在..");
} else {if (file.mkdirs()) {// 创立一级目录应用 mkdir()，创立多级目录应用 mkdirs()
System.out.println(directoryPath + "创立胜利..");
} else {System.out.println(directoryPath + "创立失败...");
}
}
}
}IO 流原理及流的分类
Java IO 流原理
- I/O 是 Input/Output 的缩写，I/ O 技术是十分实用的技术，用于解决数据传输。
如读 / 写文件, 网络通讯等。 - Java 程序中，对于数据的输出 / 输入操作以”流(stream)”的形式进行。
- java.io 包下提供了各种“流”类和接口，用以获取不同品种的数据, 并通过办法输出或输入数据
- 输出 input: 读取内部数据 (磁盘、光盘等存储设备的数据) 到程序 (内存) 中。
- 输入 output: 将程序 (内存) 数据输入到磁盘、光盘等存储设备中
流的分类
- 按操作数据单位不同分为：字节流(8 bit)（二进制文件例如声音视频 word 等能够无损操作），字符流(按字符)（文本文件）。
- 按数据流的流向不同分为：输出流，输入流。
- 按流的角色的不同分为：节点流，解决流 / 包装流。
1) Java 的 IO 流共波及 40 多个类，实际上十分规定，都是从如上 4 个形象基类派生的。
2) 由这四个类派生进去的子类名称都是以其父类名作为子类名后缀。
IO 流体系图 - 罕用的类
IO 流体系图
文件 VS 流
FileInputStream 介绍
FileInputStream 利用实例
请应用 FileInputStream 读取 hello.txt 文件，并将文件内容显示到控制台.
当然，留神一个汉字通常是由 3 个 bytes 形成的，而 read 只会读取一个 byte 的数据，因而如果用 read 则会乱码，倡议文本文件用字符流解决。
package com.hspedu.inputstream_;
import org.junit.jupiter.api.Test;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/**
* 演示 FileInputStream 的应用(字节输出流 文件 --> 程序)
*/
public class FileInputStream_ {public static void main(String[] args) { }
/**
* 演示读取文件...
* 单个字节的读取，效率比拟低
* -> 应用 read(byte[] b)
*/
@Test
public void readFile01() {
String filePath = "e:\\hello.txt";
int readData = 0;
FileInputStream fileInputStream = null;
try {
// 创立 FileInputStream 对象，用于读取 文件
fileInputStream = new FileInputStream(filePath);
// 从该输出流读取一个字节的数据。如果没有输出可用，此办法将阻止。// 如果返回 -1 , 示意读取结束
while ((readData = fileInputStream.read()) != -1) {System.out.print((char)readData);// 转成 char 显示
}
} catch (IOException e) {e.printStackTrace();
} finally {
// 敞开文件流，开释资源.
try {fileInputStream.close();
} catch (IOException e) {e.printStackTrace();
}
}
}
/**
* 应用 read(byte[] b) 读取文件，提高效率
*/
@Test
public void readFile02() {
String filePath = "e:\\hello.txt";
// 字节数组
byte[] buf = new byte[8]; // 一次读取 8 个字节.
int readLen = 0;
FileInputStream fileInputStream = null;
try {
// 创立 FileInputStream 对象，用于读取 文件
fileInputStream = new FileInputStream(filePath);
// 从该输出流读取最多 b.length 字节的数据到字节数组。此办法将阻塞，直到某些输出可用。// 如果返回 -1 , 示意读取结束
// 如果读取失常, 返回理论读取的字节数
while ((readLen = fileInputStream.read(buf)) != -1) {System.out.print(new String(buf, 0, readLen));// 显示
}
} catch (IOException e) {e.printStackTrace();
} finally {
// 敞开文件流，开释资源.
try {fileInputStream.close();
} catch (IOException e) {e.printStackTrace();
}
}
}
}FileOutputStream 介绍
FileOutputStream 利用实例
请应用 FileOutputStream 在 a.txt 文件，中写入“hello，world”. 如果文件不存在，会创立文件(留神：前提是目录曾经存在.)
package com.hspedu.outputstream_;
import org.junit.jupiter.api.Test;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileOutputStream01 {public static void main(String[] args) { }
/**
* 演示应用 FileOutputStream 将数据写到文件中,
* 如果该文件不存在，则创立该文件
*/
@Test
public void writeFile() {
// 创立 FileOutputStream 对象
String filePath = "e:\\a.txt";
FileOutputStream fileOutputStream = null;
try {
// 失去 FileOutputStream 对象 对象
// 老师阐明
//1. new FileOutputStream(filePath) 创立形式，当写入内容是，会笼罩原来的内容
//2. new FileOutputStream(filePath, true) 创立形式，当写入内容是，是追加到文件前面
fileOutputStream = new FileOutputStream(filePath, true);
// 写入一个字节
//fileOutputStream.write('H');//
// 写入字符串
String str = "hello,world!";
//str.getBytes() 能够把 字符串 -> 字节数组
//fileOutputStream.write(str.getBytes());
/*
write(byte[] b, int off, int len) 将 len 字节从位于偏移量 off 的指定字节数组写入此文件输入流
*/
fileOutputStream.write(str.getBytes(), 0, 3);
} catch (IOException e) {e.printStackTrace();
} finally {
try {fileOutputStream.close();
} catch (IOException e) {e.printStackTrace();
}
}
}
}FileOutputStream 利用实例 2
编程实现图片 / 音乐的拷贝.
package com.hspedu.outputstream_;
import com.hspedu.inputstream_.FileInputStream_;
import java.io.*;
public class FileCopy {public static void main(String[] args) {
// 实现 文件拷贝，将 e:\\Koala.jpg 拷贝 c:\\
// 思路剖析
//1. 创立文件的输出流 , 将文件读入到程序
//2. 创立文件的输入流，将读取到的文件数据，写入到指定的文件.
String srcFilePath = "e:\\Koala.jpg";
String destFilePath = "e:\\Koala3.jpg";
FileInputStream fileInputStream = null;
FileOutputStream fileOutputStream = null;
try {fileInputStream = new FileInputStream(srcFilePath);
fileOutputStream = new FileOutputStream(destFilePath);
// 定义一个字节数组, 进步读取成果
byte[] buf = new byte[1024];
int readLen = 0;
while ((readLen = fileInputStream.read(buf)) != -1) {
// 读取到后，就写入到文件 通过 fileOutputStream
// 即，是一边读，一边写
fileOutputStream.write(buf, 0, readLen);// 肯定要应用这个办法
// 不能用 fileOutputStream.write(buf) 因为最初有可能读不够而出错
}
System.out.println("拷贝 ok");
} catch (IOException e) {e.printStackTrace();
} finally {
try {
// 敞开输出流和输入流，开释资源
if (fileInputStream != null) {fileInputStream.close();
}
if (fileOutputStream != null) {fileOutputStream.close();
}
} catch (IOException e) {e.printStackTrace();
}
}
}
}FileReader 和 FileWriter 介绍
FileReader 相干办法
1) new FileReader(File/String)
2) read: 每次读取 单个字符，返回该字符，如果到文件开端返回 -1
3) read(charD): 批量读取多个字符到数组，返回读取到的字符数，如果到文件未尾返回 -1
相干 API:
1) new String(charD): 将 char[]转换成 String
2) new String(charl,off,len): 将 char[]的指定局部转换成 String
FileWriter 相干办法
1) new FileWriter(File/String): 笼罩模式，相当于流的指针在首端
2) new FileWriter(File/String,true): 追加模式，相当于流的指针在尾端
3) write(int): 写入单个字符
4) write(char): 写入指定数组
5) write(charl.off,.len): 写入指定数组的指定局部 6) write (string): 写入整个字符串
6) write(string,off,len): 写入字符串的指定局部
相干 APl: String 类: toCharArray: 将 String 转换成 char[]
留神: FileWriter 应用后，必须要敞开 (close) 或刷新 (flush)，否则写入不到指定的文件! 因为仅仅到了 Java 程序内存中。
FileReader 和 FileWriter 利用案例
1) 应用 FileReader 从 story.txt 读取内容，并显示
package com.hspedu.reader_;
import org.junit.jupiter.api.Test;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class FileReader_ {public static void main(String[] args) { }
/**
* 单个字符读取文件
*/
@Test
public void readFile01() {
String filePath = "e:\\story.txt";
FileReader fileReader = null;
int data = 0;
//1. 创立 FileReader 对象
try {fileReader = new FileReader(filePath);
// 循环读取 应用 read, 单个字符读取
while ((data = fileReader.read()) != -1) {System.out.print((char) data);
}
} catch (IOException e) {e.printStackTrace();
} finally {
try {if (fileReader != null) {fileReader.close();
}
} catch (IOException e) {e.printStackTrace();
}
}
}
/**
* 字符数组读取文件
*/
@Test
public void readFile02() {System.out.println("~~~readFile02 ~~~");
String filePath = "e:\\story.txt";
FileReader fileReader = null;
int readLen = 0;
char[] buf = new char[8];
//1. 创立 FileReader 对象
try {fileReader = new FileReader(filePath);
// 循环读取 应用 read(buf), 返回的是理论读取到的字符数
// 如果返回 -1, 阐明到文件完结
while ((readLen = fileReader.read(buf)) != -1) {System.out.print(new String(buf, 0, readLen));
}
} catch (IOException e) {e.printStackTrace();
} finally {
try {if (fileReader != null) {fileReader.close();
}
} catch (IOException e) {e.printStackTrace();
}
}
}
}2) 应用 FileWriter 将“风雨之后，定见彩虹”写入到 note.txt 文件中, 留神细节.
package com.hspedu.writer_;
import java.io.FileWriter;
import java.io.IOException;
public class FileWriter_ {public static void main(String[] args) {
String filePath = "e:\\note.txt";
// 创立 FileWriter 对象
FileWriter fileWriter = null;
char[] chars = {'a', 'b', 'c'};
try {fileWriter = new FileWriter(filePath);// 默认是笼罩写入
// 3) write(int): 写入单个字符
fileWriter.write('H');
// 4) write(char[]): 写入指定数组
fileWriter.write(chars);
// 5) write(char[],off,len): 写入指定数组的指定局部
fileWriter.write("教育".toCharArray(), 0, 3);
// 6) write（string）：写入整个字符串
fileWriter.write("你好北京~");
fileWriter.write("风雨之后，定见彩虹");
// 7) write(string,off,len): 写入字符串的指定局部
fileWriter.write("上海天津", 0, 2); // 输入上海，因为从 offset0 开始，写入两个字符
// 在数据量大的状况下，能够应用循环操作.
} catch (IOException e) {e.printStackTrace();
} finally {
// 对应 FileWriter , 肯定要敞开流，或者 flush 能力真正的把数据写入到文件
// 看源码就晓得起因.
/*
看看代码
private void writeBytes() throws IOException {this.bb.flip();
int var1 = this.bb.limit();
int var2 = this.bb.position();
assert var2 <= var1;
int var3 = var2 <= var1 ? var1 - var2 : 0;
if (var3 > 0) {if (this.ch != null) {assert this.ch.write(this.bb) == var3 : var3;
} else {this.out.write(this.bb.array(), this.bb.arrayOffset() + var2, var3);
}
}
this.bb.clear();}
*/
try {//fileWriter.flush();
// 敞开文件流，等价于 flush() + 敞开
fileWriter.close();} catch (IOException e) {e.printStackTrace();
}
}
System.out.println("程序完结...");
}
}节点流和解决流
根本介绍
-
节点流能够从一个特定的数据源读写数据，如 FileReader、FileWriter
-
解决流 (也叫包装流) 是“连贯”在已存在的流（节点流或解决流)之上，为程序提供更为弱小的读写性能，也更加灵便, 如 BufferedReader、BufferedWriter
节点流和解决流一览图
节点流和解决流的区别和分割
- 节点流是底层流 / 低级流, 间接跟数据源相接。
- 解决流 ( 包装流 ) 包装节点流，既能够打消不同节点流的实现差别，也能够提供更方
便的办法来实现输入输出。 - 解决流 (也叫包装流) 对节点流进行包装，应用了润饰器设计模式，不会间接与数据
源相连[模仿润饰器设计模式]
package com.hspedu;
public class StringReader_ extends Reader_ {public void readString() {System.out.println("读取字符串..");
}
}package com.hspedu;
public class FileReader_ extends Reader_ {public void readFile() {System.out.println("对文件进行读取...");
}
}package com.hspedu;
public abstract class Reader_ { // 抽象类
public void readFile() {}
public void readString() {}
// 在 Reader_ 抽象类，应用 read 办法对立治理.
// 前面在调用时，利于对象动静绑定机制，绑定到对应的实现子类即可.
//public abstract void read();}package com.hspedu;
/**
* 做成解决流 / 包装流
*/
public class BufferedReader_ extends Reader_{
private Reader_ reader_; // 属性是 Reader_类型
// 接管 Reader_ 子类对象
public BufferedReader_(Reader_ reader_) {this.reader_ = reader_;}
public void readFile() { // 封装一层
reader_.readFile();}
// 让办法更加灵便，屡次读取文件, 或者加缓冲 byte[] ....
public void readFiles(int num) {for(int i = 0; i < num; i++) {reader_.readFile();
}
}
// 扩大 readString, 批量解决字符串数据
public void readStrings(int num) {for(int i = 0; i <num; i++) {reader_.readString();
}
}
}package com.hspedu;
import java.io.*;
public class Test_ {public static void main(String[] args) {BufferedReader_ bufferedReader_ = new BufferedReader_(new FileReader_());
bufferedReader_.readFiles(10);
//bufferedReader_.readFile();
//Serializable
//Externalizable
//ObjectInputStream
//ObjectOutputStream
// 这次心愿通过 BufferedReader_ 屡次读取字符串
BufferedReader_ bufferedReader_2 = new BufferedReader_(new StringReader_());
bufferedReader_2.readStrings(5);
}
}解决流的性能
- 性能的进步: 次要以减少缓冲的形式来进步输入输出的效率。
- 操作的便捷: 解决流可能提供了一系列便捷的办法来一次输入输出大批量的数据, 应用更加灵便不便。
解决流 BufferedReader 和 BufferedWriter
BufferedReader 和 BufferedWriter 属于字符流，是依照字符来读取数据的
敞开时解决流，只须要敞开外层流即可（因为真正工作的是内层流，敞开时只须要敞开外层解决流，会主动敞开内层流）【源码】
利用案例
- 应用 BufferedReader 读取文本文件，并显示在控制台
package com.hspedu.reader_;
import java.io.BufferedReader;
import java.io.FileReader;
/**
* 演示 bufferedReader 应用
*/
public class BufferedReader_ {public static void main(String[] args) throws Exception {
String filePath = "e:\\a.java";
// 创立 bufferedReader
BufferedReader bufferedReader = new BufferedReader(new FileReader(filePath));
// 读取
String line; // 按行读取, 效率高
// 阐明
//1. bufferedReader.readLine() 是按行读取文件
//2. 当返回 null 时，示意文件读取结束
while ((line = bufferedReader.readLine()) != null) {System.out.println(line);
}
// 敞开流, 这里留神，只须要敞开 BufferedReader，因为底层会主动的去敞开 节点流
//FileReader。/*
public void close() throws IOException {synchronized (lock) {if (in == null)
return;
try {in.close();//in 就是咱们传入的 new FileReader(filePath), 敞开了.
} finally {
in = null;
cb = null;
}
}
}
*/
bufferedReader.close();}
}- 应用 BufferedWriter 将”hello，教育”，写入到文件中
package com.hspedu.writer_;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
/**
* 演示 BufferedWriter 的应用
*/
public class BufferedWriter_ {public static void main(String[] args) throws IOException {
String filePath = "e:\\ok.txt";
// 创立 BufferedWriter
// 阐明:
//1. new FileWriter(filePath, true) 示意以追加的形式写入
//2. new FileWriter(filePath) , 示意以笼罩的形式写入
BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(filePath));
bufferedWriter.write("hello, 教育!");
bufferedWriter.newLine();// 插入一个和零碎相干的换行
bufferedWriter.write("hello2, 教育!");
bufferedWriter.newLine();
bufferedWriter.write("hello3, 教育!");
bufferedWriter.newLine();
// 阐明：敞开外层流即可，传入的 new FileWriter(filePath) , 会在底层敞开
bufferedWriter.close();}
}3) 综合应用 BufferedReader 和 BufferedWriter 实现文本文件拷贝，留神文件编码。
package com.hspedu.writer_;
import java.io.*;
public class BufferedCopy_ {public static void main(String[] args) {
//1. BufferedReader 和 BufferedWriter 是依照字符操作
//2. 不要去操作 二进制文件[声音，视频，doc, pdf], 可能造成文件损坏
//BufferedInputStream
//BufferedOutputStream
String srcFilePath = "e:\\a.java";
String destFilePath = "e:\\a2.java";
// String srcFilePath = "e:\\0245_零根底学 Java_引出 this.avi";
// String destFilePath = "e:\\a2.avi";
BufferedReader br = null;
BufferedWriter bw = null;
String line;
try {br = new BufferedReader(new FileReader(srcFilePath));
bw = new BufferedWriter(new FileWriter(destFilePath));
// 阐明: readLine 读取一行内容，然而没有换行
while ((line = br.readLine()) != null) {
// 每读取一行，就写入
bw.write(line);
// 插入一个换行
bw.newLine();}
System.out.println("拷贝结束...");
} catch (IOException e) {e.printStackTrace();
} finally {
// 敞开流
try {if(br != null) {br.close();
}
if(bw != null) {bw.close();
}
} catch (IOException e) {e.printStackTrace();
}
}
}
}解决流 BufferedInputStream 和 BufferedOutputStream
BufferedInputStream 是字节流在创立 BufferedInputStream 时，会创立一个外部缓冲区数组。
BufferedOutputStream 是字节流, 实现缓冲的输入流, 能够将多个字节写入底层输入流中，而不用对每次字节写入调用底层零碎。
利用案例
要求: 编程实现图片 / 音乐的拷贝(要求应用 Buffered.. 流).
package com.hspedu.outputstream_;
import java.io.*;
/**
* 演示应用 BufferedOutputStream 和 BufferedInputStream 应用
* 应用他们，能够实现二进制文件拷贝.
* 思考：字节流能够操作二进制文件，能够操作文本文件吗？当然能够
*/
public class BufferedCopy02 {public static void main(String[] args) {
// String srcFilePath = "e:\\Koala.jpg";
// String destFilePath = "e:\\hsp.jpg";
// String srcFilePath = "e:\\0245_零根底学 Java_引出 this.avi";
// String destFilePath = "e:\\hsp.avi";
String srcFilePath = "e:\\a.java";
String destFilePath = "e:\\a3.java";
// 创立 BufferedOutputStream 对象 BufferedInputStream 对象
BufferedInputStream bis = null;
BufferedOutputStream bos = null;
try {
// 因为 FileInputStream 是 InputStream 子类
bis = new BufferedInputStream(new FileInputStream(srcFilePath));
bos = new BufferedOutputStream(new FileOutputStream(destFilePath));
// 循环的读取文件，并写入到 destFilePath
byte[] buff = new byte[1024];
int readLen = 0;
// 当返回 -1 时，就示意文件读取结束
while ((readLen = bis.read(buff)) != -1) {bos.write(buff, 0, readLen);
}
System.out.println("文件拷贝结束~~~");
} catch (IOException e) {e.printStackTrace();
} finally {
// 敞开流 , 敞开外层的解决流即可，底层会去敞开节点流
try {if(bis != null) {bis.close();
}
if(bos != null) {bos.close();
}
} catch (IOException e) {e.printStackTrace();
}
}
}
}对象流 ObjectInputStream 和 ObjectOutputStream
看一个需要：不仅须要保留值，还须要保留数据类型。
- 将 int num = 100 这个 int 数据保留到文件中, 留神不是 100 数字，而是 int 100，并且，可能从文件中间接复原 int 100
- 将 Dog dog = new Dog(“小黄”，3)这个 dog 对象保留到文件中，并且可能从文件复原.
- 下面的要求，就是可能将根本数据类型或者对象进行序列化和反序列化操作
序列化和反序列化
- 序列化就是在保留数据时，保留数据的值和数据类型
- 反序列化就是在复原数据时，复原数据的值和数据类型
-
须要让某个对象反对序列化机制，则必须让其类是可序列化的，为了让某个类是可序列化的，该类必须实现如下两个接口之一:
- Serializable // 这是一个标记接口, 没有办法
- Externalizable // 该接口有办法须要实现，因而咱们个别实现下面的接口
对象流介绍
性能：提供了对根本类型或对象类型的序列化和反序列化的办法
- ObjectOutputStream 提供序列化性能
- ObjectInputStream 提供反序列化性能
利用案例
- 应用 ObjectOutputStream 序列化根本数据类型和一个 Dog 对象 (name, age), 并
保留到 data.dat 文件中。
package com.hspedu.outputstream_;
import java.io.Serializable;
// 如果须要序列化某个类的对象，实现 Serializable
public class Dog implements Serializable {
private String name;
private int age;
// 序列化对象时，默认将外面所有属性都进行序列化，但除了 static 或 transient 润饰的成员
private static String nation;
private transient String color;
// 序列化对象时，要求外面属性的类型也须要实现序列化接口
private Master master = new Master();
//serialVersionUID 序列化的版本号，能够进步兼容性
private static final long serialVersionUID = 1L;
public Dog(String name, int age, String nation, String color) {
this.name = name;
this.age = age;
this.color = color;
this.nation = nation;
}
@Override
public String toString() {
return "Dog{" +
"name='" + name + '\'' +
", age=" + age +
", color='" + color + '\'' +
'}' + nation + " " +master;
}
public String getName() {return name;}
public void setName(String name) {this.name = name;}
public int getAge() {return age;}
public void setAge(int age) {this.age = age;}
}package com.hspedu.outputstream_;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
/**
* 演示 ObjectOutputStream 的应用, 实现数据的序列化
*/
public class ObjectOutStream_ {public static void main(String[] args) throws Exception {
// 序列化后，保留的文件格式，不是存文本，而是依照他的格局来保留
String filePath = "e:\\data.dat";
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filePath));
// 序列化数据到 e:\data.dat
oos.writeInt(100);// int -> Integer (Integer 实现了 Serializable)
oos.writeBoolean(true);// boolean -> Boolean (实现了 Serializable)
oos.writeChar('a');// char -> Character (实现了 Serializable)
oos.writeDouble(9.5);// double -> Double (实现了 Serializable)
oos.writeUTF("教育");//String
// 保留一个 dog 对象
oos.writeObject(new Dog("旺财", 10, "日本", "红色"));
oos.close();
System.out.println("数据保留结束(序列化模式)");
}
}- 应用 ObjectlnputStream 读取 data.dat 并反序列化复原数据
package com.hspedu.inputstream_;
import com.hspedu.outputstream_.Dog;
import java.io.*;
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());
//dog 的编译类型是 Object , dog 的运行类型是 Dog
Object dog = ois.readObject();
System.out.println("运行类型 =" + dog.getClass());
System.out.println("dog 信息 =" + dog);// 底层 Object -> Dog
// 这里是特地重要的细节:
//1. 如果咱们心愿调用 Dog 的办法, 须要向下转型
//2. 须要咱们将 Dog 类的定义，放在到能够援用的地位
Dog dog2 = (Dog)dog;
System.out.println(dog2.getName()); // 旺财..
// 敞开流, 敞开外层流即可，底层会敞开 FileInputStream 流
ois.close();}
}package com.hspedu.outputstream_;
import java.io.Serializable;
// 如果须要序列化某个类的对象，实现 Serializable
public class Dog implements Serializable {
private String name;
private int age;
// 序列化对象时，默认将外面所有属性都进行序列化，但除了 static 或 transient 润饰的成员
private static String nation;
private transient String color;
// 序列化对象时，要求外面属性的类型也须要实现序列化接口
private Master master = new Master();
//serialVersionUID 序列化的版本号，能够进步兼容性
private static final long serialVersionUID = 1L;
public Dog(String name, int age, String nation, String color) {
this.name = name;
this.age = age;
this.color = color;
this.nation = nation;
}
@Override
public String toString() {
return "Dog{" +
"name='" + name + '\'' +
", age=" + age +
", color='" + color + '\'' +
'}' + nation + " " +master;
}
public String getName() {return name;}
public void setName(String name) {this.name = name;}
public int getAge() {return age;}
public void setAge(int age) {this.age = age;}
}注意事项和细节阐明
- 读写程序要统一。
- 要求序列化或反序列化对象，须要实现
Serializable。 -
序列化的类中倡议增加
SerialVersionUID，为了进步版本的兼容性。当退出新属性时，序列化和反序列化会认为是原来的修改版，而不会认为是一个全新的类。private static final long serialVersionUID = 1L; - 序列化对象时，默认将外面所有属性都进行序列化，但除了 static 或 transient 润饰的成员。也就是序列化并不保留
static或transient润饰的信息。 - 序列化对象时，要求外面属性的类型也须要实现序列化接口。
- 序列化具备可继承性，也就是如果某类曾经实现了序列化，则它的所有子类也曾经默认实现了序列化。
规范输入输出流
介绍
利用案例 1
传统办法 System.out.println(“”); 是应用 out 对象将数据输入到显示器
利用案例 2
传统的办法, Scanner 是从规范输出键盘接收数据
package com.hspedu.standard;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.Scanner;
public class InputAndOutput {public static void main(String[] args) {
//System 类的 public final static InputStream in = null;
// System.in 编译类型 InputStream
// System.in 运行类型 BufferedInputStream
// 示意的是规范输出 键盘
System.out.println(System.in.getClass());
//1. System.out public final static PrintStream out = null;
//2. 编译类型 PrintStream
//3. 运行类型 PrintStream
//4. 示意规范输入 显示器
System.out.println(System.out.getClass());
System.out.println("hello, 教育");
Scanner scanner = new Scanner(System.in);
System.out.println("输出内容");
String next = scanner.next();
System.out.println("next=" + next);
}
}转换流 InputStreamReader 和 OutputStreamWriter
文件乱码问题，引出学习转换流必要性。
能够这么了解：相当于把 InputStream 转为 Reader，把 OutputStream 转为 Writer。
- InputStreamReader:Reader 的子类，能够将 InputStream(字节流)包装成(转换)Reader(字符流)
- OutputStreamWriter:Writer 的子类，实现将 OutputStream(字节流)
包装成 Writer(字符流) - 当解决纯文本数据时，如果应用字符流效率更高，并且能够无效解决中文
问题, 所以倡议将字节流转换成字符流。 - 能够在应用时指定编码格局(比方 utf-8, gbk , gb2312,ISO8859- 1 等)
利用案例
1. 编程将字节流 FilelnputStream 包装成 (转换成) 字符流 InputStreamReader, 对
文件进行读取(依照 utf-8/gbk 格局), 进而包装成 BufferedReader
package com.hspedu.transformation;
import java.io.*;
/**
* 演示应用 InputStreamReader 转换流解决中文乱码问题
* 将字节流 FileInputStream 转成字符流 InputStreamReader, 指定编码 gbk/utf-8
*/
public class InputStreamReader_ {public static void main(String[] args) throws IOException {
String filePath = "e:\\a.txt";
// 解读
//1. 把 FileInputStream 转成 InputStreamReader
//2. 指定编码 gbk
//InputStreamReader isr = new InputStreamReader(new FileInputStream(filePath), "gbk");
//3. 把 InputStreamReader 传入 BufferedReader
//BufferedReader br = new BufferedReader(isr);
// 将 2 和 3 合在一起
BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(filePath), "gbk"));
//4. 读取
String s = br.readLine();
System.out.println("读取内容 =" + s);
//5. 敞开外层流
br.close();}
}- 编程将字节流 FileOutputStream 包装成 (转换成) 字符流 OutputStreamWriter, 对文件进行写入(依照 gbk 格局, 能够指定其余，比方 utf-8)
package com.hspedu.transformation;
import java.io.*;
/**
* 演示 OutputStreamWriter 应用
* 把 FileOutputStream 字节流，转成字符流 OutputStreamWriter
* 指定解决的编码 gbk/utf-8/utf8
*/
public class OutputStreamWriter_ {public static void main(String[] args) throws IOException {
String filePath = "e:\\hsp.txt";
String charSet = "utf-8";
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(filePath), charSet);
osw.write("hi, 教育");
osw.close();
System.out.println("依照" + charSet + "保留文件胜利~");
}
}打印流 PrintStream 和 PrintWriter
打印流只有输入流，没有输出流
package com.hspedu.printstream;
import java.io.IOException;
import java.io.PrintStream;
/**
* 演示 PrintStream（字节打印流 / 输入流）*/
public class PrintStream_ {public static void main(String[] args) throws IOException {
PrintStream out = System.out;
// 在默认状况下，PrintStream 输入数据的地位是 规范输入，即显示器
/*
public void print(String s) {if (s == null) {s = "null";}
write(s); //!!!
}
*/
out.print("john, hello");
// 因为 print 底层应用的是 write , 所以咱们能够间接调用 write 进行打印 / 输入
out.write("你好".getBytes());
out.close();
// 咱们能够去批改打印流输入的地位 / 设施
//1. 输入批改成到 "e:\\f1.txt"
//2. "hello, 教育~" 就会输入到 e:\f1.txt
//3. 源码：// public static void setOut(PrintStream out) {// checkIO();
// setOut0(out); // native 办法，批改了 out
// }
System.setOut(new PrintStream("e:\\f1.txt"));
System.out.println("hello, 教育~");
}
}package com.hspedu.transformation;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
/**
* 演示 PrintWriter 应用形式
*/
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("hi, 北京你好~~~~");
printWriter.close();//flush + 敞开流, 才会将数据写入到文件..}
}Properties 类
看一个需要
如下一个配置文件 mysql.properties
- ip=192.168.0.13
- user=root
- pwd=12345
请问编程读取 ip. user 和 pwd 的值是多少
剖析
- 传统的办法
- 应用 Properties 类能够不便实现
package com.hspedu.properties_;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
public class Properties01 {public static void main(String[] args) throws IOException {
// 读取 mysql.properties 文件，并失去 ip, user 和 pwd
BufferedReader br = new BufferedReader(new FileReader("src\\mysql.properties"));
String line = "";
while ((line = br.readLine()) != null) { // 循环读取
String[] split = line.split("=");
// 如果咱们要求指定的 ip 值
if("ip".equals(split[0])) {System.out.println(split[0] + "值是:" + split[1]);
}
}
br.close();}
}根本介绍
-
专门用于读写配置文件的汇合类
配置文件的格局:
键 = 值
键 = 值
- 留神: 键值对不须要有空格，值不须要用引号一起来。默认类型是 String
- Properties 的常见办法
- load: 加载配置文件的键值对到 Properties 对象
- list: 将数据显示到指定设施
- getProperty(key): 依据键获取值
- setProperty(key,value): 设置键值对到 Properties 对象
- store: 将 Properties 中的键值对存储到配置文件, 在 idea 中，保存信息到配置文件，如果含有中文，会存储为 unicode 码
http://tool.chinaz.com/tools/unicode.aspx unicode 码查问工具
利用案例
1. 应用 Properties 类实现对 mysql.properties 的读取, 看老师代码演示
package com.hspedu.properties_;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;
public class Properties02 {public static void main(String[] args) throws IOException {
// 应用 Properties 类来读取 mysql.properties 文件
//1. 创立 Properties 对象
Properties properties = new Properties();
//2. 加载指定配置文件
properties.load(new FileReader("src\\mysql.properties"));
//3. 把 k - v 显示控制台
properties.list(System.out);
//4. 依据 key 获取对应的值
String user = properties.getProperty("user");
String pwd = properties.getProperty("pwd");
System.out.println("用户名 =" + user);
System.out.println("明码是 =" + pwd);
}
}2. 应用 Properties 类增加 key-val 到新文件 mysql2.properties 中
3. 应用 Properties 类实现对 mysq12.properties 的读取，并批改某个 key-val
package com.hspedu.properties_;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;
public class Properties03 {public static void main(String[] args) throws IOException {
// 应用 Properties 类来创立 配置文件, 批改配置文件内容
Properties properties = new Properties();
// 创立
//1. 如果该文件没有 key 就是创立!!
//2. 如果该文件有 key , 就是批改!!
/*
Properties 父类是 Hashtable，底层就是 Hashtable 外围办法
public synchronized V put(K key, V value) {
// Make sure the value is not null
if (value == null) {throw new NullPointerException();
}
// Makes sure the key is not already in the hashtable.
Entry<?,?> tab[] = table;
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length;
@SuppressWarnings("unchecked")
Entry<K,V> entry = (Entry<K,V>)tab[index];
for(; entry != null ; entry = entry.next) {if ((entry.hash == hash) && entry.key.equals(key)) {
V old = entry.value;
entry.value = value;// 如果 key 存在，就替换
return old;
}
}
addEntry(hash, key, value, index);// 如果是新 k, 就 addEntry
return null;
}
*/
properties.setProperty("charset", "utf8");
properties.setProperty("user", "汤姆");// 留神保留时，是中文的 unicode 码值
properties.setProperty("pwd", "888888");
// 将 k -v 存储文件中即可
properties.store(new FileOutputStream("src\\mysql2.properties"), null);
System.out.println("保留配置文件胜利~");
}
}本章作业
1. 编程题
(1)在判断 e 盘下是否有文件夹 mytemp , 如果没有就创立 mytemp
(2)在 e:llmytemp 目录下，创立文件 hello.txt
(3)如果 hello.txt 曾经存在，提醒该文件曾经存在, 就不要再反复创立了
(4)并且在 hello.txt 文件中，写入 hello,world~
package com.hspedu.homework;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
public class Homework01 {public static void main(String[] args) throws IOException {
/**
*(1) 在判断 e 盘下是否有文件夹 mytemp , 如果没有就创立 mytemp
*(2) 在 e:\\mytemp 目录下, 创立文件 hello.txt
*(3) 如果 hello.txt 曾经存在，提醒该文件曾经存在，就不要再反复创立了
*(4) 并且在 hello.txt 文件中，写入 hello,world~
*/
String directoryPath = "e:\\mytemp";
File file = new File(directoryPath);
if(!file.exists()) {
// 创立
if(file.mkdirs()) {System.out.println("创立" + directoryPath + "创立胜利");
}else {System.out.println("创立" + directoryPath + "创立失败");
}
}
String filePath = directoryPath + "\\hello.txt";// e:\mytemp\hello.txt
file = new File(filePath);
if(!file.exists()) {
// 创立文件
if(file.createNewFile()) {System.out.println(filePath + "创立胜利~");
// 如果文件存在，咱们就应用 BufferedWriter 字符输出流写入内容
BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(file));
bufferedWriter.write("hello, world~~ 教育");
bufferedWriter.close();} else {System.out.println(filePath + "创立失败~");
}
} else {
// 如果文件曾经存在，给出提示信息
System.out.println(filePath + "曾经存在，不在反复创立...");
}
}
}2. 编程题
要求: 应用 BufferedReader 读取一个文本文件，为每行加上行号，再连同内容一并输入到屏幕上。
// 如果把文件的编码改成了 gbk，呈现中文乱码，大家思考如何解决
//1. 默认是依照 utf- 8 解决, 开始没有乱码
//2. 提醒: 应用咱们的转换流，将 FilelnputStream -> InputStreamReader[能够指定编码]- >BufferedReader …
package com.hspedu.homework;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class Homework02 {public static void main(String[] args) {
/**
* 要求: 应用 BufferedReader 读取一个文本文件，为每行加上行号，* 再连同内容一并输入到屏幕上。*/
String filePath = "e:\\a.txt";
BufferedReader br = null;
String line = "";
int lineNum = 0;
try {br = new BufferedReader(new FileReader(filePath));
while ((line = br.readLine()) != null) { // 循环读取
System.out.println(++lineNum + line);
}
} catch (Exception e) {e.printStackTrace();
} finally {
try {if(br != null) {br.close();
}
} catch (IOException e) {e.printStackTrace();
}
}
}
}3. 编程题
(1) 要编写一个 dog.properties
- name=tom
- age=5
- color=red
(2)编写 Dog 类 (name,age,color) 创立一个 dog 对象，读取 dog.properties 用相应的内容实现属性初始化, 并输入
(3)将创立的 Dog 对象, 序列化到文件 dog.dat 文件
package com.hspedu.homework;
import org.junit.jupiter.api.Test;
import java.io.*;
import java.util.Properties;
public class Homework03 {public static void main(String[] args) throws IOException {
/**
* (1) 要编写一个 dog.properties name=tom age=5 color=red
* (2) 编写 Dog 类(name,age,color) 创立一个 dog 对象，读取 dog.properties 用相应的内容实现属性初始化, 并输入
* (3) 将创立的 Dog 对象，序列化到 文件 e:\\dog.dat 文件
*/
String filePath = "src\\dog.properties";
Properties properties = new Properties();
properties.load(new FileReader(filePath));
String name = properties.get("name") + ""; //Object -> String
int age = Integer.parseInt(properties.get("age") + "");// Object -> int
String color = properties.get("color") + "";//Object -> String
Dog dog = new Dog(name, age, color);
System.out.println("===dog 对象信息 ====");
System.out.println(dog);
// 将创立的 Dog 对象，序列化到 文件 dog.dat 文件
String serFilePath = "e:\\dog.dat";
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(serFilePath));
oos.writeObject(dog);
// 敞开流
oos.close();
System.out.println("dog 对象，序列化实现...");
}
// 在编写一个办法，反序列化 dog
@Test
public void m1() throws IOException, ClassNotFoundException {
String serFilePath = "e:\\dog.dat";
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(serFilePath));
Dog dog = (Dog)ois.readObject();
System.out.println("=== 反序列化后 dog====");
System.out.println(dog);
ois.close();}
}
class Dog implements Serializable{
private String name;
private int age;
private String color;
public Dog(String name, int age, String color) {
this.name = name;
this.age = age;
this.color = color;
}
@Override
public String toString() {
return "Dog{" +
"name='" + name + '\'' +
", age=" + age +
", color='" + color + '\'' +
'}';
}
}
正文完
