一、文件
文件：保存数据的地方
文件流：
程序（内存）<--输入流--文件（磁盘、网络、数据库等）
程序（内存）--输入流-->文件（磁盘、网络、数据库等）
常用的文件操作
1、创建文件
package com.yans.java.io;
import java.io.File;
import java.io.IOException;
//创建文件的三种方式
public class TestFileCreate {
public static void main(String[] args) {
createFile1();
createFile2();
createFile3();
}
//方式1 new File(String path)
public static void createFile1(){
String filePath = "d:\\new1.txt";
File file = new File( filePath ); //在java程序中，只是一个file对象
try {
file.createNewFile(); //只有执行了该方法，才会真正在磁盘创建文件对象
System.out.println("文件1创建成功");
} catch (IOException e) {
e.printStackTrace();
}
}
//方式2 new File(File parent, String child)
public static void createFile2(){
File filePath = new File("d:\\"); //指定路径
String fileName = "new2.txt";
File file = new File(filePath, fileName); //创建file对象
try {
file.createNewFile();
System.out.println("文件2创建成功");
} catch (IOException e) {
e.printStackTrace();
}
}
//方式3 new File(String parent, String child)
public static void createFile3() {
String parentPath = "d:\\";
String filePath = "new3.txt";
File file = new File(parentPath, filePath);
try {
file.createNewFile();
System.out.println("文件3创建成功");
} catch (IOException e) {
e.printStackTrace();
}
}
}
2、获取文件相关信息
package com.yans.java.io;
import java.io.File;
public class TestDirectory {
public static void main(String[] args) {
TestDirectory testDirectory = new TestDirectory();
testDirectory.m1();
testDirectory.m2();
testDirectory.m3();
}
//删除文件
public void m1() {
String filename = "d:\\new2.txt";
File file = new File(filename);
if (file.exists()) {
if (file.delete()) {
System.out.println(filename + "删除成功");
} else {
System.out.println(filename + "删除失败");
}
} else {
System.out.println(filename + "文件不存在");
}
}
//删除目录，创建目录
public void m2() {
String filename = "d:\\demo";
File file = new File(filename);
if (file.exists()) {
if (file.delete()) {
System.out.println(filename + "删除成功");
} else {
System.out.println(filename + "删除失败");
}
} else {
System.out.println(filename + "目录不存在，创建");
file.mkdir(); //创建一级目录 mkdirs()创建多级目录
}
}
//删除目录
public void m3() {
String filename = "d:\\demo1\\c";
File file = new File(filename);
if (file.exists()) {
if (file.delete()) {
System.out.println(filename + "删除成功");
} else {
System.out.println(filename + "删除失败");
}
} else {
System.out.println(filename + "目录不存在，创建");
file.mkdirs(); //创建多级目录
}
}
}
二、IO流原理及流（stream）的分类
1、IO流原理
1）I/O（Input/output），用于处理数据传输，如读/写文件，网络通信等
2）java程序中对数据的输入输出操作都以流（stream）来操作
3）java.io包下提供了各种“流”和接口，用于获取不同的种类的数据，并输入输出数据
2、流的分类
按操作数据单位不同分为：字节流（8bit）、字符流（按字符）
按数据流的流向不同分为：输入流、输出流
按流的角色不同分为：节点流、处理流/包装流
都是抽象类，不能直接实例化，只能使用实现子类取实现它们
| 字节流 | 字符流 | |
| 输入流 | InputStream | Reader |
| 输出流 | outputStream | Writer |
3、java IO流整体架构图：
4、字节流常用子类
1、FileInputStream/FileOutputStream 文件读/写
FileInputStream：
package com.yans.java.io;
import java.io.FileInputStream;
import java.io.IOException;
//FileInputStream 字节输入流
public class TestFileInputStream {
public static void main(String[] args) {
TestFileInputStream testFileInputStream = new TestFileInputStream();
testFileInputStream.readFile1();
testFileInputStream.readFile2();
}
//单个字节读取，效率低
public void readFile1() {
FileInputStream fileInputStream = null;
String filePath = "d:\\hello.txt";
int readDate = 0;
try {
//创建FileInputStream对象，用于读取文件
fileInputStream = new FileInputStream(filePath);
//读取文件一个字节
//如果返回-1，表示读取完毕
while ((readDate = fileInputStream.read()) !=-1) {
System.out.println((char) readDate); //转成char显示，读取中文显示乱码
}
} catch (IOException e) {
e.printStackTrace();
} finally {
//关闭文件流，释放资源
try {
fileInputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
//read(byte[])
public void readFile2() {
FileInputStream fileInputStream = null;
String filePath = "d:\\hello.txt";
int readLen = 0;
//字节数组
byte[] buffer = new byte[8];
try {
//创建FileInputStream对象，用于读取文件
fileInputStream = new FileInputStream(filePath);
//读取文件一个字节
//如果返回-1，表示读取完毕
//如果读取正常，返回实际读取字节数 readLen
while ((readLen = fileInputStream.read(buffer)) !=-1) {
System.out.println(new String(buffer, 0 ,readLen)); //转成
}
} catch (IOException e) {
e.printStackTrace();
} finally {
//关闭文件流，释放资源
try {
fileInputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
FileOutputStream：
package com.yans.java.io;
import java.io.FileOutputStream;
import java.io.IOException;
//FileInputStream 字节输出流
public class TestFileOutputStream {
public static void main(String[] args) {
TestFileOutputStream testFileOutputStream = new TestFileOutputStream();
testFileOutputStream.writeFile();
}
public void writeFile() {
//创建FileOutputStream
String filePath = "d:\\a.txt"; //文件不存在，则会创建一个
FileOutputStream fileOutputStream = null;
try {
//得到FileOutputStream对象
//1、new FileOutputStream(filePath) 创建方式，当写入内容时，会覆盖原来的内容
//2、new FileOutputStream(filePath, true) 创建方式，当写入内容时，会追加到文件末尾
//fileOutputStream = new FileOutputStream(filePath);
fileOutputStream = new FileOutputStream(filePath, true);
//写入一个字节
fileOutputStream.write('H');
//写入字符串
String str = "hello,world\n";
fileOutputStream.write(str.getBytes());
String str1 = "hello,world!";
fileOutputStream.write(str1.getBytes(), 0, str1.length()); //推荐使用
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
fileOutputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
组合使用，实现文件拷贝：
package com.yans.java.io;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class TestFileCopy {
public static void main(String[] args) {
TestFileCopy testFileCopy= new TestFileCopy();
testFileCopy.fileCopy();
}
//文件拷贝，将从d:// 拷贝到d://demo
//1、读取文件，到程序中=》输入流
//2、从程序中写入文件中 =》输出流
public void fileCopy() {
//文件原路径
String srcPath = "D:\\spongebob.jpg";
//文件目标路径
String destPath = "D:\\demo\\spongebob.jpg";
FileInputStream fileInputStream = null;
FileOutputStream fileOutputStream = null;
int readLine = 0;
byte[] buffer = new byte[300000];
try {
//定义输入流
fileInputStream = new FileInputStream(srcPath);
//定义输出流
fileOutputStream = new FileOutputStream(destPath);
//将文件读取到程序中
if ((readLine=fileInputStream.read(buffer)) != -1) {
//写入文件，边读边写
fileOutputStream.write(buffer, 0, readLine);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
//关闭输入流和输出流，释放资源
try {
if (fileInputStream != null) {
fileInputStream.close();
}
if (fileOutputStream != null) {
fileOutputStream.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
2、FileReader/FileWriter
继承关系：FileReader -> InputStreamReader -> Reader
FileWriter -> OutputStreamWriter -> Writer
注意：FileWriter必须要关闭（close）或者刷新（flush），否则写入不到指定文件中
FileReader：
package com.yans.java.io;
import java.io.FileReader;
import java.io.IOException;
public class TestFileReader {
public static void main(String[] args) {
TestFileReader testFileReader = new TestFileReader();
testFileReader.reader1();
testFileReader.reader2();
}
//多个字符读取
public void reader1() {
String filePath = "d:\\story.txt";
FileReader fileReader = null;
int readLen = 0;
char[] buffer = new char[8];
try {
fileReader = new FileReader(filePath);
//循环读取，使用read(buff)，返回实际读取到的字符数
//如果当-1，则说明文件结束
while ((readLen = fileReader.read(buffer)) != -1) {
System.out.println(new String(buffer, 0, readLen));
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (fileReader != null) {
fileReader.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
//单个字符读取
public void reader2() {
String filePath = "d:\\story.txt";
FileReader fileReader = null;
int data = 0;
try {
fileReader = new FileReader(filePath);
while ((data = fileReader.read()) != -1) {
System.out.println((char)data);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (fileReader != null) {
fileReader.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
FileWriter：
package com.yans.java.io;
import java.io.FileWriter;
import java.io.IOException;
public class TestFileWriter {
public static void main(String[] args) {
witer();
}
public static void witer() {
String filePath = "d:\\new.txt";
FileWriter fileWriter = null;
try {
fileWriter = new FileWriter(filePath);
//1、写入单个字符
fileWriter.write('H');
char[] chars = new char[] {'a', 'b'};
//2、写入指定数组
fileWriter.write(chars);
//3、写入指定字符串
fileWriter.write("你好北京");
//4、写入数组指定部分
fileWriter.write("你好世界".toCharArray(),0, 3);
//5、写入字符串指定部分
fileWriter.write("你好地球", 0, 3);
//6、数据量大的话，可以使用循环写入
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
//一定要关闭或刷新，不然写入不了文件
//fileWriter.flush();
//close = flush + close
fileWriter.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
3、节点流、处理流
节点流：针对特定数据源进行操作，如：对文件进行操作，使用FileReader\FileWriter（字符流）、FileInputStream\FileOutputStream（字节流）。直接对数据源进行操作，比较底层，效率较低。
处理流（包装流）：“连接”在已存在的流（节点流、包装流）之上，可以消除不同节点流对象的限制，为程序提供更为强大的读写功能。如：BufferedReader类中，有属性Reader，即可以封装一个节点流（Reader的任意子类）；BufferedWriter类中，有属性Writer，即可以封装一个节点流（Writer的任意子类）。修饰器设计模式。
实例--模拟修饰器模式（处理流以及节点流的封装关系）：
package com.yans.java.io.reader;
//定义一个抽象类
public abstract class Reader_ {
//定义两个抽象方法
public void stringReader(){}
public void fileReader(){}
}
package com.yans.java.io.reader;
//模拟字符串节点流
public class StringReader_ extends Reader_{
public void stringReader() {
System.out.println("读取字符串...");
}
}
package com.yans.java.io.reader;
//模拟文件节点流
public class FileReader_ extends Reader_{
public void fileReader() {
System.out.println("读取文件...");
}
}
package com.yans.java.io.reader;
//模拟处理流（包装流）
public class BufferdReader_ extends Reader_{
//有一个Reader_属性
Reader_ reader_;
//构造方法
public BufferdReader_(Reader_ reader_) {
this.reader_ = reader_;
}
//封装子类方法
public void stringReader() {
reader_.stringReader();
}
//扩展方法，多次读取字符串，加缓冲...
public void stringReaders(int num) {
for (int i=0; i<num; i++) {
reader_.stringReader();
}
}
//扩展方法
public void fileReaders(int num) {
for (int i=0; i<num; i++) {
reader_.fileReader();
}
}
}
package com.yans.java.io.reader;
//测试类
public class TestReader {
public static void main(String[] args) {
BufferdReader_ bufferdReader_ = new BufferdReader_(new StringReader_());
bufferdReader_.stringReaders(5);
BufferdReader_ bufferdReader_1 = new BufferdReader_(new FileReader_());
bufferdReader_1.fileReaders(10);
}
}
注意：关闭处理流时，只需要关闭外层流即可。
4、BufferedReader/BufferdWriter
BufferedReader：
package com.yans.java.io;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class TestBufferdReader {
public static void main(String[] args) throws IOException {
//定义文件路径
String filePath = "d:\\a1.txt";
//创建BufferdReader对象
BufferedReader bufferedReader = new BufferedReader(new FileReader(filePath));
//读取文件
//按行读取，效率高，为null时表示文件读取完毕
String line = "";
while ((line = bufferedReader.readLine()) != null) {
//输出到控制台
System.out.println(line);
}
//关闭流，只需关闭外层处理流，因为底层代码会把对应节点流关闭
bufferedReader.close();
}
}
BufferdWriter：
package com.yans.java.io;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
public class TestBufferedWriter {
public static void main(String[] args) throws IOException {
String filePath = "d:\\ok.txt";
//创建BufferdWriter对象
//说明：new FileWriter(filePath, true) 表示以追加的方式写入
//new FileWriter(filePath)表示以覆盖的方式写入
BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(filePath, true));
bufferedWriter.write("hello, 你好");
bufferedWriter.newLine(); //插入一个跟系统相关的换行符
bufferedWriter.write("hello2, 你好\n");
bufferedWriter.write("hello3, 你好");
bufferedWriter.newLine(); //插入一个跟系统相关的换行符
//关闭流
bufferedWriter.close();
}
}
实现文件拷贝：
package com.yans.java.io;
import java.io.*;
public class TestBufferdFileCopy {
public static void main(String[] args) {
//BufferedReader、BufferedWriter是按字符操作，
//不要去操作一个二进制文件，可能造成文件损坏
//定义源文件路径
String srcFilePath = "d:\\a1.txt";
//定义目的文件路径
String destFilePath = "d:\\demo\\a1.txt";
BufferedReader br = null;
BufferedWriter bw = null;
String line;
try {
br = new BufferedReader(new FileReader(srcFilePath));
bw = new BufferedWriter(new FileWriter(destFilePath));
//按行读取文件
while ((line = br.readLine()) != null) {
//按行写入文件
bw.write(line);
//插入一个换行符
bw.newLine();
}
System.out.println("拷贝完毕");
} catch (IOException e) {
e.printStackTrace();
} finally {
if (br != null) {
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (bw !=null) {
try {
bw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
5、BufferedInputStream/BufferedOutputStream
BufferedInputStream（继承自FilterInputStream，继承属性InputStream）;
BufferedOutputStream（继承自FilterOutputStream，继承属性OutputStream）
可以用于处理二进制文件，也可以处理文本文件。
实例，拷贝文件：
package com.yans.java.io;
import java.io.*;
public class TestBufferedCopy2 {
//可处理二进制文件，也可以处理文本文件
public static void main(String[] args) throws IOException {
//文件原路径
String srcPath = "D:\\spongebob.jpg";
//文件目标路径
String destPath = "D:\\demo\\spongebob1.jpg";
//创建对象
BufferedInputStream bis = null;
BufferedOutputStream bos = null;
byte[] buffer = new byte[300000];
int readLine = 0;
bis = new BufferedInputStream(new FileInputStream(srcPath));
bos = new BufferedOutputStream(new FileOutputStream(destPath));
while ((readLine = bis.read(buffer)) != -1) {
bos.write(buffer, 0, readLine);
}
System.out.println("拷贝成功");
//关闭流
bis.close();
bos.close();
}
}
6、对象处理流
能够将基本数据类型或者对象进行序列化和反序列化
序列化：保存值和对应的数据类型。如保存 int 100，将100和int类型都保存起来。
反序列化：将保存在文件中的数据（值和数据类型）重新恢复成值和数据类型。
如果让某个对象支持序列化机制，则必须让其类是可序列化的，可以实现以下两个接口之一：
- Serializable //标记接口，没有方法（推荐使用）
- Externalizable //该接口有方法需要实现，不推荐使用
7、ObjectInputStream/ObjectOutputStream
ObjectOutputStream提供序列化，序列化后保存的文件格式不是纯文本，而是按照它的格式来保存。ObjectInputStream提供反序列化。
实例-ObjectOutputStream序列化：
package com.yans.java.io;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public class TestObjectOutputStream {
public static void main(String[] args) {
String filePath = "d:\\data.bat";
//创建对象
ObjectOutputStream objectOutputStream = null;
try {
objectOutputStream = new ObjectOutputStream(new FileOutputStream(filePath));
objectOutputStream.write(1); //int -> integer（实现了Serializable）
objectOutputStream.writeBoolean(true); //boolean -> Boolean（实现了Serializable）
objectOutputStream.writeDouble(9.1); //double -> Double（实现了Serializable）
objectOutputStream.writeUTF("你好"); //String
objectOutputStream.writeObject(new Dog("旺财", 3));
} catch (IOException e) {
e.printStackTrace();
}
}
}
//写入的对象必须要实现序列化
class Dog implements Serializable {
public String name;
public int age;
public Dog(String name, int age) {
this.name = name;
this.age = age;
}
}
ObjectInputStream 反序列化：
package com.yans.java.io;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
public class TestObjectInputStream {
public static void main(String[] args) {
//指定反序列化文件
String filePath = "d:\\data.bat";
ObjectInputStream ois = null;
try {
ois = new ObjectInputStream(new FileInputStream(filePath));
//读取
//读取（反序列化）的数据需要和你保存序列化的数据顺序一致
//否则会抛异常
System.out.println(ois.readInt());
System.out.println(ois.readBoolean());
System.out.println(ois.readDouble());
System.out.println(ois.readUTF());
//dog的编译类型是Object， 运行类型时Dog
Object obj = ois.readObject();
System.out.println("运行类型" + obj.getClass());
System.out.println("dog信息" + obj.toString());
//注意点：
// 如果我们希望调用Dog的方法，需要向下转型
//需要将Dog类的定义拷贝到可以引用的位置
//先执行序列化后执行反序列化，反序列化不能连续执行，第二次会报错
Dog dog2 = (Dog) obj;
System.out.println(dog2.getAge());
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
} finally {
if (ois != null) {
try {
ois.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
注意点：
- 读写顺序要一致
- 要求进行序列化或者反序列化的对象，必须实现Serializable
- 序列化的类建议条件SerialVersionUID 序列化版本号，可以提高兼容性
- 序列化对象时，默认将对象的所有属性都进行序列化，除了被static和transient修饰的成员
- 序列化对象时，要求里面的成员都需要实现序列化接口
- 序列化具有可继承性，如果父类实现序列化了，继承它的子类也默认实现了序列化
8、标准输入输出
System.in 标准输入，编译类型：InputStream，运行类型：BufferedInputStream（键盘）
System.out 标准输出，编译类型：PrintStream，运行类型：PrintStream（显示器）
9、转换流
将字节流转换为字符流（解决因编码格式导致的中文乱码问题）。当处理纯中文文本数据时，效率更高，且可以解决中文乱码问题。
InputStreamReader：Reader的子类，可以将InputStream包装成Reader
package com.yans.java.io;
import java.io.*;
//将字节流FileInputStream转换成字符流，指定编码gbk/utf-8
public class TestInputStreamReader {
public static void main(String[] args) throws IOException {
String filePath = "d:\\ok.txt";
//把FileInputStream转成 InputStreamReader
//指定编码utf-8
InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream(filePath), "utf-8");
//把InputStreamReader 传入 BufferedReader
BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
//读取
String line;
while((line = bufferedReader.readLine()) != null) {
System.out.println(line);
}
//关闭外层流
bufferedReader.close();
}
}
OutputStreamWriter：Writer的子类，可以将OutputStream包装成Writer
package com.yans.java.io;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
//把FileOutputStream转换成OutputStreamWriter指定编码格式gbk
public class TestOutputStreamWriter {
public static void main(String[] args) throws IOException {
String filePath = "d:\\out.txt";
//转换
OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream(filePath), "gbk");
writer.write("hello，你好啊");
writer.close();
System.out.println("保存文件成功");
}
}
10、打印流
只有输出流，没有输入流。可以打印到显示屏（默认输出），也可以保存到文件中。
PrintStream，字节流，继承FileouputStream
package com.yans.java.io;
import java.io.IOException;
import java.io.PrintStream;
public class TestPrintStream {
public static void main(String[] args) throws IOException {
PrintStream out = System.out;
//默认情况下，打印流默认输出显示屏
out.print("hello，你好" + "\n");
//因为底层使用的是write方法，所以可以直接使用write方法进行打印/输出
out.write("你好啊~".getBytes());
//System.setOut方法修改输出位置
//修改成打印到文件中
System.setOut(new PrintStream("d:\\print.txt"));
System.out.print("hello, 你好"); //输出到文件中
out.close();
}
}
PrintWriter，字符流，继承Writer
package com.yans.java.io;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
public class TestPrintWriter {
public static void main(String[] args) throws IOException {
//打印到显示屏
PrintWriter printWriter = new PrintWriter(System.out);
printWriter.print("你好");
//输出到文件
PrintWriter printWriter1 = new PrintWriter(new FileWriter("d:\\writer.txt"));
printWriter1.print("你好a");
printWriter.close();
printWriter1.close(); //真正写入文件
}
}
11、Properties类
读取 .properties配置文件信息
保存文件为：键=值 格式，键值对间没有空格，值不需要用引号括起来，默认String类型
常用方法：
load：加载文件中的配置信息
list：显示文件配置信息
getProperty：根据键获取对于值信息
setProperty：向Properties中添加键值对信息。如果文件没有key，就创建；如果有则修改。
store：将信息存储到文件中，如果是中文，保存为对应的Unicode码
package com.yans.java.io;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;
/**
* 分别使用传统方法和Properties类来实现对配置文件的读取
* 对比两种方法的使用
*/
public class TestProperties {
public static void main(String[] args) throws IOException {
//文件路径
String filePath = "D:\\project\\java_workspace\\javaLearning\\src\\mysql.properties";
TestProperties properties = new TestProperties();
//传统方法
properties.readFile01(filePath);
System.out.println("=============");
//Properties类
properties.readFile02(filePath);
}
//传统方法读取mysql.properties文件
//获取信息
public void readFile01(String filePath) throws IOException {
//创建BufferedReader对象读取
BufferedReader br = new BufferedReader(new FileReader(filePath));
String line = "";
while ((line = br.readLine()) != null) {
//读取IP
String[] lines = line.split("=");
if ("ip".equals(lines[0])) {
System.out.println(lines[0] + "值为：" + lines[1]);
}
}
//关闭流
br.close();
}
//使用Properties类获取配置文件信息
public void readFile02(String filePath) throws IOException {
//创建Properties对象
Properties properties = new Properties();
//load方法加载文件信息
properties.load(new FileReader(filePath));
//打印k-v文件信息
properties.list(System.out);
//获取key对应的值
String user = properties.getProperty("user");
System.out.println("用户名为：" + user);
}
}
package com.yans.java.io;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;
/**
* 1、写入信息到配置文件
* 2、修改k-v的值
*/
public class TestProperties2 {
public static void main(String[] args) throws IOException {
//创建Properties对象
Properties properties = new Properties();
//设置键值对
properties.setProperty("charset", "utf-8");
properties.setProperty("user", "小明"); //保存为Unicode编码
properties.setProperty("pwd", "88888"); //key存在时，直接修改对应的值
//写入到mysql1.properties文件中，第二个参数是注释，如果不为null则会以注释的格式写入文件开头
properties.store(new FileWriter("D:\\project\\java_workspace\\javaLearning\\src\\mysql1.properties"), null);
}
}
总结
完成三道练习题
（一）文件基本操作：
1、判断d盘下是否有temp，没有则创建
2、在temp目录下，创建文件hello.txt
3、如果文件存在则提示该文件已存在，就不重复创建了
（二）BufferedReader 处理流的基本操作：
使用BufferedReader读取一个文本文件，为每行加上行号 *后，一起输出到屏幕上
（三）序列化、Properties类的使用
*1、编写一个dog.propertes类，包括以下信息 ：
name=tom
age=5
color=red
2、编写Dog类（name, age, color） 创建一个dog对象
3、读取dog.properties，用相应的内容完成属性初始化，并输出
4、将创建的Dog序列化到文件dog.dat文件
5、将dog对象反序列化输出
package com.yans.java.io.homework;
import java.io.File;
import java.io.IOException;
/**
* 1、判断d盘下是否有temp，没有则创建
* 2、在temp目录下，创建文件hello.txt
* 3、如果文件存在则提示该文件已存在，就不重复创建了
*/
public class HomeWork01 {
public static void main(String[] args) throws IOException {
//判断d盘下是否有temp，没有则创建
//文件目录
String filePath = "d:\\temp";
File file = new File(filePath);
if (!file.exists()) {
file.mkdirs(); //创建目录
}
//在temp目录下，创建文件hello.txt
//如果文件存在则提示该文件已存在，就不重复创建了
String fileName = "hello.txt";
File file1 = new File(filePath, fileName);
if (!file1.exists()) {
file1.createNewFile();
} else {
System.out.println("该文件已存在");
}
}
}
package com.yans.java.io.homework;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
/**
* 使用BufferedReader读取一个文本文件，为每行加上行号
* 连同以上内容一起输出到屏幕上
*/
public class HomeWork02 {
public static void main(String[] args) throws IOException {
//使用BufferedReader读取一个文本文件
BufferedReader br = null;
br = new BufferedReader(new FileReader("d:\\temp\\test1.txt"));
String line = "";
int i = 1; //记录行号
while((line = br.readLine()) != null) {
//加行号
System.out.print(i);
System.out.println(line);
i ++;
}
if (br != null) {
br.close();
}
}
}
package com.yans.java.io.homework;
import java.io.*;
import java.util.Properties;
/**
* 1、编写一个dog.propertes类，包括以下信息
* name=tom
* age=5
* color=red
* 2、编写Dog类（name, age, color） 创建一个dog对象
* 3、读取dog.properties，用相应的内容完成属性初始化，并输出
* 4、将创建的Dog序列化到文件dog.dat文件
* 5、反序列化
*/
public class HomeWork03 {
public static void main(String[] args) throws IOException, ClassNotFoundException {
//使用Properties类
Properties properties = new Properties();
//写入信息
properties.setProperty("name","tom");
properties.setProperty("age", "5");
properties.setProperty("color", "red");
properties.store(new FileWriter("dog.properties"), null);
//读取配置文件信息
properties.load(new FileReader("dog.properties"));
properties.list(System.out);
String name = properties.getProperty("name");
int age = Integer.parseInt(properties.getProperty("age"));
String color = properties.getProperty("color");
//实例化Dog对象
Dog dog = new Dog(name, age, color);
//输出Dog
System.out.println(dog.toString());
//序列化Dog对象 ObjectOutputStream
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("d:\\temp\\dog.dat"));
oos.writeObject(dog);
oos.close();
//反序列化
ObjectInputStream ios = new ObjectInputStream(new FileInputStream("d:\\temp\\dog.dat"));
Object dog1= ios.readObject();
System.out.println("反序列化后输出" + dog1.toString());
}
}
//Dog类
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 + '\'' +
'}';
}
}
扫一扫
125
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
