哈喽!大家好,我是小简。今天开始学习《Java-IO流》,此系列是我做的一个 “Java 从 0 到 1 ” 实验,给自己一年左右时间,按照我自己总结的 Java-学习路线,从 0 开始学 Java 知识,并不定期更新所学笔记,期待一年后的蜕变吧!
import org.junit.Test;
import java.io.File;
import java.io.IOException;
public class FileCreate {
//new File(String pathname) //根据路径构建一个File对象
@Test
public void create01(){
String pathname = "/Users/jianjian/Downloads/test1.txt";
File file = new File(pathname);
try {
file.createNewFile();
System.out.println("文件创建成功");
} catch (IOException e) {
e.printStackTrace();
}
}
//new File(File parent. String child) //根据父目录文件+子路径构建
@Test
public void create02(){
File parentFile = new File("/Users/jianjian/Downloads/");
String fileName = "test2.txt";
File file = new File(parentFile, fileName);
try {
file.createNewFile();
System.out.println("文件创建成功");
} catch (IOException e) {
e.printStackTrace();
}
}
//new File(String parent,String child) //根据父目录+子路径构建
@Test
public void create03(){
String parentFile = "/Users/jianjian/Downloads/";
String fileName = "test3.txt";
File file = new File(parentFile, fileName);
try {
file.createNewFile();
System.out.println("文件创建成功");
} catch (IOException e) {
e.printStackTrace();
}
}
}
import org.junit.Test;
import java.io.File;
public class FileInfomation {
//获取文件的信息
@Test
public void info() {
//先创建文件对象
File file = new File("/Users/jianjian/Downloads/test.txt");
//调用相应的方法,得到对应信息
System.out.println("文件名字=" + file.getName());
System.out.println("文件绝对路径=" + file.getAbsolutePath());
System.out.println("文件父级目录=" + file.getParent());
System.out.println("文件大小(字节)=" + file.length());//中文字符3个字节,英文字符1个字节
System.out.println("文件是否存在=" + file.exists());//T
System.out.println("是不是一个文件=" + file.isFile());//T
System.out.println("是不是一个目录=" + file.isDirectory());//F
}
}
实例:
import org.junit.Test;
import java.io.File;
public class Directory_ {
//1) 判断 /Users/jianjian/Downloads/test.txt 文件是否存在如果存在就删除。
@Test
public void Q1(){
String fileName = "/Users/jianjian/Downloads/test.txt";
File file = new File(fileName);
if (file.exists()) {
System.out.println(file.getName()+"文件存在");
if (file.delete()) {
System.out.println(file.getName()+"删除成功");
}
} else {
System.out.println(file.getName()+"文件不存在");
}
}
//2) 判断 /Users/jianjian/Downloads/test 目录是否存在,如果存在就提示已经存在,否则就创建。
@Test
public void Q2(){
String fileName = "/Users/jianjian/Downloads/test";
File file = new File(fileName);
if (file.exists()) {
System.out.println(file.getName()+"文件存在");
} else{
System.out.println(file.getName()+"文件不存在");
if (file.mkdir()) {
System.out.println(file.getName()+"文件创建成功");
} else{
System.out.println(file.getName()+"文件创建失败");
}
}
}
//3) 判断 /Users/jianjian/Downloads/test/a/b 目录是否存在,如果存在就提示已经存在,否则就创建。
@Test
public void Q3(){
String fileName = "/Users/jianjian/Downloads/test/a/b";
File file = new File(fileName);
if (file.exists()) {
System.out.println(file.getName()+"文件存在");
} else{
System.out.println(file.getName()+"文件不存在");
if (file.mkdirs()) {
System.out.println(file.getName()+"文件创建成功");
} else{
System.out.println(file.getName()+"文件创建失败");
}
}
}
}
请使用 FileInputStream 读取 hello.txt 文件,并将文件内容显示到控制台
import org.junit.Test;
import java.io.FileInputStream;
import java.io.IOException;
public class FileInputStream_ {
@Test
public void readFile01() {
String filePath = "/Users/jianjian/Downloads/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();
}
}
}
}
import org.junit.Test;
import java.io.FileInputStream;
import java.io.IOException;
public class FileInputStream_ {
@Test
public void readFile02() {
String filePath = "/Users/jianjian/Downloads/hello.txt";
int readLen = 0;
byte[] buf = new byte[8];//一次读取8个字节.
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();
}
}
}
}
例子1🌰:请使用 FileOutputStream 在 a.txt 文件中写入 “hello,world”, 如果文件不存在,会创建文件(注意:前提是目录已经存在)
package com.jwt.outputstream_;
import org.junit.Test;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileOutputStream_ {
@Test
public void writeFile01(){
String filePath = "/Users/jianjian/Downloads/a.txt";
FileOutputStream fileOutputStream = null;
try {
fileOutputStream = new FileOutputStream(filePath);//覆盖
fileOutputStream.write('J');
} catch (IOException e) {
e.printStackTrace();
}
}
@Test
public void writeFile02(){
String filePath = "/Users/jianjian/Downloads/a.txt";
FileOutputStream fileOutputStream = null;
String str = "Hello,jwt";
try {
fileOutputStream = new FileOutputStream(filePath,true);//追加
//str.getBytes() 可以把字符串-> 字节数组
fileOutputStream.write(str.getBytes());
} catch (IOException e) {
e.printStackTrace();
}
}
@Test
public void writeFile03(){
String filePath = "/Users/jianjian/Downloads/a.txt";
FileOutputStream fileOutputStream = null;
String str = "Hello,jwt";
try {
fileOutputStream = new FileOutputStream(filePath);
fileOutputStream.write(str.getBytes(), 0, str.length());
} catch (IOException e) {
e.printStackTrace();
}
}
}
例子1🌰:编程完成图片的拷贝,将 /Users/jianjian/Downloads/a.jpg 拷贝到 /Users/jianjian/Downloads/test/a.jpg,即输入流和输出流同时使用
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileCopy {
public static void main(String[] args) {
String srcFilePath = "/Users/jianjian/Downloads/a.jpeg";
String destFilePath = "/Users/jianjian/Downloads/test/a.jpeg";
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);//一定要使用这个方法
}
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 从 hello.txt 读取内容,并显示
import org.junit.Test;
import java.io.FileReader;
import java.io.IOException;
public class FileReader_ {
/**
* 单个字符读取文件
*/
@Test
public void readFile01() {
String filePath = "/Users/jianjian/Downloads/hello.txt";
FileReader fileReader = null;
int data = 0;
try {
//创建FileReader 对象
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() {
String filePath = "/Users/jianjian/Downloads/hello.txt";
FileReader fileReader = null;
int readLen = 0;
char[] buf = new char[8];
try {
//创建FileReader 对象
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();
}
}
}
}
例子🌰:使用 FileWriter 将 “Hello,World” 写入到 hello.txt 文件中
import java.io.FileWriter;
import java.io.IOException;
public class FileWriter_ {
public static void main(String[] args) {
String filePath = "/Users/jianjian/Downloads/hello.txt";
//创建FileWriter 对象
FileWriter fileWriter = null;
char[] chars = {'a', 'b', 'c'};
try {
fileWriter = new FileWriter(filePath);//默认是覆盖写入
// 1) write(int):写入单个字符
fileWriter.write('H');
// 2) write(char[]):写入指定数组
fileWriter.write(chars);
// 3) write(char[],off,len):写入指定数组的指定部分
fileWriter.write("加油啊小简".toCharArray(), 0, 3);
// 4) write(string):写入整个字符串
fileWriter.write(" 你好啊~");
// 5)write(string, off, len):写入字符串的指定部分
fileWriter.write("一起学Java", 0, 2);
//在数据量大的情况下,可以使用循环操作.
} catch (IOException e) {
e.printStackTrace();
} finally {
//对于FileWriter , 一定要关闭流,或者flush 才能真正的把数据写入到文件
try {
//fileWriter.flush();
//关闭文件流,等价flush() + 关闭
fileWriter.close();
} catch (IOException e) {
e.printStackTrace();
}
}
System.out.println("程序结束...");
}
}
使用 BufferedReader 读取文本文件,并显示在控制台
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class BufferedReader_ {
public static void main(String[] args) throws IOException {
String filePath = "/Users/jianjian/Downloads/hello.txt";
//创建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 ,因为底层会自动的去关闭节点流
bufferedReader.close();
}
}
关闭流时,只需要关闭外层流(处理流)即可,因为底层会自动的去关闭节点流
使用 BufferedWriter 将 ”hello, World”,写入到文件中
package com.jwt.writer_;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
public class BufferedWriter_ {
public static void main(String[] args) throws IOException {
String filePath = "/Users/jianjian/Downloads/hello.txt";
BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(filePath,true));//以追加的方式写入
bufferedWriter.write("Hello,World");
bufferedWriter.newLine();//插入一个和系统相关的换行
bufferedWriter.write("Hi,World");
bufferedWriter.newLine();
//关闭外层流即可, 传入的new FileWriter(filePath) ,会在底层关闭
bufferedWriter.close();
}
}
例子🌰:综合使用 BufferedReader 和 BufferedWriter 完成文本文件拷贝,注意文件编码
package com.jwt.writer_;
import java.io.*;
public class BufferedCopy_ {
public static void main(String[] args) {
String srcFilePath = "/Users/jianjian/Downloads/hello.txt";
String destFilePath = "/Users/jianjian/Downloads/test/hello.txt";
BufferedReader bufferedReader = null;
BufferedWriter bufferedWriter = null;
String data;
try {
bufferedReader = new BufferedReader(new FileReader(srcFilePath));
bufferedWriter = new BufferedWriter(new FileWriter(destFilePath));
//说明: readLine 读取一行内容,但是没有换行
while ((data=bufferedReader.readLine()) != null) {
//每读取一行,就写入
bufferedWriter.write(data);
//插入一个换行
bufferedWriter.newLine();
}
System.out.println("拷贝完毕...");
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
//关闭流
if (bufferedReader != null){
bufferedReader.close();
}
if (bufferedWriter != null){
bufferedWriter.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
例子🌰:编程完成图片/音乐的拷贝(要求使用Buffered..流)
package com.jwt.writer_;
import java.io.*;
public class BufferedCopy02 {
public static void main(String[] args) {
String srcFilePath = "/Users/jianjian/Downloads/a.jpeg";
String destFilePath = "/Users/jianjian/Downloads/test/a.jpeg";
BufferedInputStream bufferedInputStream = null;
BufferedOutputStream bufferedOutputStream = null;
int data;
try {
bufferedInputStream = new BufferedInputStream(new FileInputStream(srcFilePath));
bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(destFilePath));
//循环的读取文件,并写入到destFilePath
byte[] buff = new byte[1024];
int readLen = 0;
//当返回-1 时,就表示文件读取完毕
while ((readLen=bufferedInputStream.read(buff)) != -1) {
//每读取一行,就写入
bufferedOutputStream.write(buff,0,readLen);
}
System.out.println("拷贝完毕...");
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
//关闭流
if (bufferedInputStream != null){
bufferedInputStream.close();
}
if (bufferedOutputStream != null){
bufferedOutputStream.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
对象功能:提供了对基本类型或对象类型的序列化和反序列化的方法
看一个需求
序列化和反序列化
注意事项和细节说明
例子🌰:使用 ОbjесtОutрutЅtrеаm 序列化基本数据类型和一个 Dоg 对象(nаmе, аgе), 并保存到 data.dat 文件中
package com.jwt.outputstream_;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public class ObjectOutStream_ {
public static void main(String[] args) throws Exception {
//序列化后,保存的文件格式,不是存文本,而是按照他的格式来保存
String filePath = "/Users/jianjian/Downloads/b.dat";
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filePath));
//序列化数据到filePath
oos.writeInt(100);// int -> 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("数据保存完毕(序列化形式)");
}
static class Dog implements Serializable {
String name;
int age;
public Dog(String name, int age) {
this.name = name;
this.age = age;
}
}
}
例子🌰:使用 ObjectInputStream 读取 data.dat 并反序列化恢复数据
package com.jwt.inputstream_;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
public class ObjectInputStream_ {
public static void main(String[] args) throws IOException, ClassNotFoundException {
// 1.创建流对象
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("/Users/jianjian/Downloads/b.dat"));
// 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());
System.out.println(ois.readObject());
// 3.关闭
ois.close();
System.out.println("以反序列化的方式读取(恢复)ok~");
}
}
名称 | 类型 | 默认设备 |
---|---|---|
System.in 标准输入流 | InputStream | 键盘 |
System.out 标准输出流 | OutputStream | 显示器 |
package com.jwt.standard;
import java.util.Scanner;
public class InputOutput {
public static void main(String[] args) {
//1.源码:public final static Inputstream in = null;
//2.System.in 编译类型 Inputstream
//3.System.in 运行类型 BufferedInputstream
//4.表示的是标准输入 键盘
System.out.println(System.in.getClass());
Scanner scanner = new Scanner(System.in);
System.out.println("输入:");
System.out.println("输出:" + scanner.next());
//1.源码:public final static PrintStream out = null;
//2.编译类型 Printstream
//3.运行类型 Printstream
//4.表示标准输出 显示器
System.out.println(System.out.getClass());
System.out.println("hello,你好~");
}
}
例子🌰:编程将字节流 FileInputStream 包装成(转换成)字符流 InputStreamReader,对文件进行读取(按照utf-8/gbk格式),进而在包装成BufferedReader
package com.jwt.transformation;
import java.io.*;
public class InputStreamReader_ {
public static void main(String[] args) throws IOException {
String filePath = "/Users/jianjian/Downloads/a.txt";
//1. 把FileInputStream 转成InputStreamReader,指定编码gbk
InputStreamReader isr = new InputStreamReader(new FileInputStream(filePath),"gbk");
//2. 把InputStreamReader 传入BufferedReader
BufferedReader br = new BufferedReader(isr);
//将1和2合在一起
//BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(filePath), "gbk"));
//3. 读取
String s = br.readLine();
System.out.println("读取内容=" + s);
//4. 关闭外层流
br.close();
}
}
例子🌰:编程将字节流 FileOutputStream 包装成(转换成)字符流 OutputStreamWriter,对文件进行写入(按照gbk格式,可以指定其他,比如utf-8)
package com.jwt.transformation;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
public class OutputStreamWriter_ {
public static void main(String[] args) throws IOException {
// 1.创建流对象
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("/Users/jianjian/Downloads/a.txt"), "gbk");
// 2.写入
osw.write("hello,你好呀~");
// 3.关闭
osw.close();
System.out.println("保存成功~");
}
}
打印流只有输出流,没有输入流
package com.jwt.transformation;
import org.junit.Test;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.PrintStream;
public class PrintStream_ {
@Test
//标准输出到屏幕
public void write01() throws IOException {
PrintStream printStream = new PrintStream(System.out);
printStream.print("hello,你好");
//printStream.write("hello,你好".getBytes());
printStream.close();
}
@Test
//修该打印流输出位置
public void write02() throws FileNotFoundException {
System.setOut(new PrintStream("/Users/jianjian/Downloads/a.txt"));
System.out.println("你好呀");
}
}
package com.jwt.transformation;
import org.junit.Test;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
public class PrintWriter_ {
@Test
//标准输出到屏幕
public void write01(){
PrintWriter printWriter = new PrintWriter(System.out);
printWriter.print("hello,你好");
printWriter.close();
}
@Test
//输出到文件
public void write02() throws IOException {
PrintWriter printWriter = new PrintWriter(new FileWriter("/Users/jianjian/Downloads/a.txt"));
printWriter.print("hello,你好");
printWriter.close();
}
}
如下一个配置文件 mysql.properties
user=root
password=12345
请问编程读取 user 和 password 的值是多少?
package com.jwt.io.properties_;
import org.junit.Test;
import java.io.*;
import java.util.Properties;
public class Properties01 {
//传统的方法
@Test
public void traditionRead() throws IOException {
BufferedReader bufferedReader = new BufferedReader(new FileReader("src//mysql.properties"));
String line = "";
while ((line = bufferedReader.readLine()) != null){
String[] split = line.split("=");
//如果我们要求指定的值
if("user".equals(split[0])) {
System.out.println("用户名=" + split[1]);
}
if("password".equals(split[0])) {
System.out.println("密码=" + split[1]);
}
}
bufferedReader.close();
}
}
package com.jwt.io.properties_;
import org.junit.Test;
import java.io.*;
import java.util.Properties;
public class Properties01 {
@Test
public void propertiesRead() throws IOException {
//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("password");
System.out.println("用户名=" + user);
System.out.println("密码是=" + pwd);
}
}
Properties 是专门用于读写配置文件的集合类
键=值
键=值
Properties的常见方法
例子🌰:使用 Properties 类添加 key-val 到新文件 mysql2.properties 中,再使用 Properties 类完成对 mysql2.properties 的读取,并修改某个 key-val
要点:使用Properties 类来创建配置文件, 修改配置文件内容
package com.jwt.io.properties_;
import org.junit.Test;
import java.io.*;
import java.util.Properties;
public class Properties01 {
@Test
public void insertProperties() throws IOException {
Properties properties = new Properties();
//添加
properties.setProperty("test","123");
properties.setProperty("user", "汤姆");//保存时,是中文的unicode 码值
properties.store(new FileWriter("src//mysql.properties2"), null);
// properties.store(new FileOutputStream("src//mysql.properties2"),null);
System.out.println("保存配置文件成功~");
//读取
Properties properties2 = new Properties();
properties2.load(new FileReader("src//mysql.properties2"));
properties2.list(System.out);
//修改
properties2.setProperty("test","456");
properties2.store(new FileWriter("src//mysql.properties2"),"测试一下下");
System.out.println("修改成功~");
}
}
package com.jwt.io.homework;
import java.io.*;
public class Homework01
{
public static void main(String[] args) throws IOException {
String directory = "/Users/jianjian/Downloads/mytemp";
File file = new File(directory);
if (!file.exists()) {
file.mkdirs();
System.out.println("目录创建成功");
} else {
System.out.println("目录已存在");
}
String filePath = directory + "/hello.txt";
File file2 = new File(filePath);
if (!file2.exists()){
file2.createNewFile();
System.out.println("文件创建成功");
FileWriter fileWriter = new FileWriter(filePath);
fileWriter.write("hello,world~");
System.out.println("文本写入成功");
fileWriter.close();
} else{
System.out.println("文件已存在");
}
}
}
要求:使用 BufferedReader 读取一个文本文件,为每行加上行号,再连同内容一并输出到屏幕上。
package com.jwt.io.homework;
import java.io.*;
public class Homework02 {
public static void main(String[] args){
String filePath = "/Users/jianjian/Downloads/hello.txt";
BufferedReader bufferedReader = null;
String line = "";
int linenum = 0;
try {
bufferedReader = new BufferedReader(new FileReader(filePath));
while ((line = bufferedReader.readLine()) != null) {
System.out.println(++linenum + line);
}
//1. 把FileInputStream转成InputStreamReader,指定编码gbk
InputStreamReader isr = new InputStreamReader(new FileInputStream(filePath),"gbk");
//2. 把InputStreamReader 传入BufferedReader
BufferedReader br = new BufferedReader(isr);
while ((line = br.readLine()) != null) {
System.out.println(++linenum + line);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if (bufferedReader != null) {
try {
bufferedReader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
name=tom
age=5
color=red
package com.jwt.io.homework;
import java.io.*;
import java.util.Properties;
public class Homework03 {
public static void main(String[] args) throws IOException, ClassNotFoundException {
Properties properties = new Properties();
properties.load(new FileReader("src//dog.properties"));
String name = properties.getProperty("name");
int age = Integer.parseInt(properties.getProperty("age"));
String color = properties.getProperty("color");
Dog dog = new Dog(name, age, color);
System.out.println(dog);
//将创建的Dog对象,序列化到文件dog.dat文件
String filePath = "/Users/jianjian/Downloads/dog.dat";
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filePath));
oos.writeObject(dog);
oos.close();
System.out.println("数据保存完毕(序列化形式)");
// 反序列化dog
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(filePath));
System.out.println(ois.readObject());
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 + '\'' +
'}';
}
}