文章目录
-
- 1.文件
- 2.IO流原理及分类
- 3.FileInputStream
- 4.FileOutputStream
- 5.FileReader
- 6.FileWriter
- 7.节点流与处理流
- 8.BufferedReader
- 9.BufferedWriter
- 10.Buffered拷贝
- 11.Buffered字节处理流
- 12.对象处理流(读写对象)
- 13.标准输入输出流
-
-
- System.in
- System.out
- [new Scanner(System.in)](#new Scanner(System.in))
-
- 14.转换流(字节流转换成字符流并指定编码)
- 15.打印流
- 16.IO流总结
- 17.Properties处理配置文件
- 18.本章作业
1.文件
1.基本介绍
2.常用的文件操作
1.创建文件的相关构造器和方法
代码实例
java
package IO_;
import java.io.File;
import java.io.IOException;
/**
* @author 孙显圣
* @version 1.0
*/
public class FileCreate {
public static void main(String[] args) {
//使用三种方式在e盘下创建三个文件
// new File(String pathname)
String path1 = "e:\\file1.txt";
File file = new File(path1); //在内存中创建文件对象
//调用方法在磁盘中创建文件
try {
file.createNewFile();
System.out.println("创建文件1成功!");
} catch (IOException e) {
throw new RuntimeException(e);
}
// new File(File parent, String child)
File file1 = new File("e:\\"); //父文件对象
String child = "file2.txt"; //子文件路径
File file2 = new File(file1, child);
try {
file2.createNewFile();
System.out.println("创建文件2成功");
} catch (IOException e) {
throw new RuntimeException(e);
}
// new File(String parent, String child)
String parent = "e:\\"; //父路径
String child_ = "file3.txt";
File file3 = new File(parent, child_);
try {
file3.createNewFile();
System.out.println("文件3创建成功");
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
结果
2.获取文件相关信息
代码实例
java
package IO_;
import java.io.File;
/**
* @author 孙显圣
* @version 1.0
*/
public class FileInfo {
public static void main(String[] args) {
File file = new File("e:\\file1.txt"); //创建文件对象
System.out.println("文件绝对路径 " + file.getAbsolutePath());
System.out.println("文件名字 " + file.getName());
System.out.println("文件父级目录 " + file.getParent());
System.out.println("文件大小(字节) " + file.length());
System.out.println("文件是否存在 " + file.exists());
System.out.println("是不是一个文件 " + file.isFile());
System.out.println("是不是一个目录 " + file.isDirectory());
}
}
结果
3.目录的删除和文件删除
代码实例
java
package IO_;
import java.io.File;
/**
* @author 孙显圣
* @version 1.0
*/
public class FileMkdir {
public static void main(String[] args) {
// 判断e:\\file1.txt是否存在,如果存在则删除
File file = new File("e:\\file1.txt");
if (file.exists()) {
file.delete();
System.out.println("删除成功");
}
else {
System.out.println("删除失败");
}
// 判断e:\\demo02是否存在,存在就删除,否则提示不存在
String path = file.getParent() + "demo02"; //路径拼接
File file1 = new File(path);
if (file1.exists()) {
file1.delete();
System.out.println("删除成功");
}
else {
System.out.println("删除失败");
}
// 判断e:\\demo\\a\\b\\c是否存在,如果不存在则创建
File file2 = new File("e:\\demo\\a\\b\\c");
if (file2.exists()) {
System.out.println("已经存在");
}
else {
file2.mkdirs();
System.out.println("文件不存在,已经自动创建");
}
}
}
2.IO流原理及分类
IO流原理
IO流就相当于是外卖小哥,用来传输数据
IO流分类
3.FileInputStream
1.类图
2.代码实例
java
package IO_;
import org.junit.jupiter.api.Test;
import java.io.FileNotFoundException;
import java.io.IOException;
/**
* @author 孙显圣
* @version 1.0
*/
public class FileInputStream {
//逐个字节读取
@Test
public void one() {
String path = "e:\\hello.txt"; //1.文件路径
int readData = 0;
java.io.FileInputStream fileInputStream = null;
try {
fileInputStream = new java.io.FileInputStream(path); //2.根据文件路径,创建输入流的对象
//3.逐个字节读取
while ((readData = fileInputStream.read()) != -1) { //返回读取的字节,如果返回-1则到文件末尾
System.out.print((char) readData); //将字节转换成char类型并输出
}
} catch (FileNotFoundException e) {
throw new RuntimeException(e);
} catch (IOException e) {
throw new RuntimeException(e);
}finally {
//4.关闭字节流
try {
fileInputStream.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
//按照字节数组读取
public static void main(String[] args) {
String path = "e:\\hello.txt"; //1.文件路径
byte[] bytes = new byte[8]; //3.8个容量的字节数组
int readData = 0;
java.io.FileInputStream fileInputStream = null;
try {
fileInputStream = new java.io.FileInputStream(path); //2.字节流对象
//4.按照字节数组读取
while ((readData = fileInputStream.read(bytes)) != -1) { //会将字节读进字节数组中,返回读进的字节数
System.out.print(new String(bytes, 0, readData)); //将字节数组转换成String类型并且输出
}
} catch (FileNotFoundException e) {
throw new RuntimeException(e);
} catch (IOException e) {
throw new RuntimeException(e);
} finally {
//5.关闭字节流
try {
fileInputStream.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
}
3.结果
4.FileOutputStream
1.类图
2.案例
代码实例
java
package IO_;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* @author 孙显圣
* @version 1.0
*/
public class FileOutputStream01 {
public static void main(String[] args) {
//输出流如果没有那个文件,会自动创建
String path = "e:\\a.txt"; //1.文件路径
FileOutputStream fileOutputStream = null; //2.获取文件输出流引用
try {
// fileOutputStream = new FileOutputStream(path); //3.获取文件输出流
fileOutputStream = new FileOutputStream(path, true); //8.设置该文件输出流的写入位置为文件末尾(不覆盖原来的文件)
//5.输出单个字符
fileOutputStream.write('h');
//6.输出字符串
String a = "hello,world";
fileOutputStream.write(a.getBytes()); //使用字符串的getBytes来将字符串转化成字节数组
//7.输出部分字符串
String b = "hsp,java";
fileOutputStream.write(b.getBytes(), 0, 3);
} catch (IOException e) {
throw new RuntimeException(e);
} finally {
//4.关闭文件输出流
try {
fileOutputStream.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
}
3.综合案例---文件拷贝
代码实例
java
package IO_;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* @author 孙显圣
* @version 1.0
*/
public class FileCopy {
public static void main(String[] args) {
//文件源路径
String src = "C:\\Users\\86156\\Desktop\\images\\1.png";
//文件目标路径
String dest = "e:\\1.png";
//文件输入流
FileInputStream fileInputStream = null;
//文件输出流
FileOutputStream fileOutputStream = null;
byte[] bytes = new byte[1024]; //用来存储文件输入的字节数组
int readLength = 0; //记录读取的字节数
try {
//获取文件输入流
fileInputStream = new FileInputStream(src);
//获取文件输出流
fileOutputStream = new FileOutputStream(dest);
//将文件读取到字节数组中
while ((readLength = fileInputStream.read(bytes)) != -1) {
fileOutputStream.write(bytes, 0, readLength); //将读取到的部分写入目标文件
}
System.out.println("拷贝成功!");
} catch (IOException e) {
throw new RuntimeException(e);
} finally {
//关闭两个流
try {
fileInputStream.close();
fileOutputStream.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
}
5.FileReader
1.类图
2.基本介绍
3.案例
代码实例
java
package IO_;
import org.junit.jupiter.api.Test;
import java.io.FileReader;
import java.io.IOException;
/**
* @author 孙显圣
* @version 1.0
*/
public class FileReader_ {
//按照单个字符读取
public static void main(String[] args) {
//读取路径
String src = "e:\\a.txt";
//获取字符输入流引用
FileReader fileReader = null;
int readData = 0; //接收输入的字符
try {
//获取字符输入流
fileReader = new FileReader(src);
//按照字符,循环读取
while ((readData = fileReader.read()) != -1) { //这里返回的是单个字符但是,是以int形式返回的
System.out.print(((char)readData));
}
} catch (IOException e) {
throw new RuntimeException(e);
} finally {
//关闭字符输入流
try {
fileReader.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
//按照字符数组读取
@Test
public void readMore() {
//读取路径
String src = "e:\\a.txt";
//获取字符输入流引用
FileReader fileReader = null;
char[] chars = new char[100]; //用来接收读取的数据
int redLen = 0; //记录读取长度
try {
//获取字符输入流
fileReader = new FileReader(src);
//按照字符,循环读取
while ((redLen = fileReader.read(chars)) != -1) { //这里是将内容读取到char数组,返回的是读取的长度
System.out.print(new String(chars, 0, redLen)); //将读取到的部分转化成String,并输出
}
} catch (IOException e) {
throw new RuntimeException(e);
} finally {
//关闭字符输入流
try {
fileReader.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
}
6.FileWriter
1.类图
2.基本介绍
3.案例
代码实例
java
package IO_;
import java.io.FileWriter;
import java.io.IOException;
/**
* @author 孙显圣
* @version 1.0
*/
public class FileWriter_ {
public static void main(String[] args) {
//写入文件地址
String path = "e:\\a.txt";
//获取输出字符流引用
FileWriter fileWriter = null;
try {
fileWriter = new FileWriter(path); //获取输出字符流对象
//写入单个字符
fileWriter.write('a');
//写入字符数组
char[] a = new char[]{'1','2','3'};
fileWriter.write(a);
//写入指定字符数组的指定部分
fileWriter.write("你好,世界".toCharArray(),3,2); //注意这里面的指定位置指的是off(开始位置)len(长度),这里我就是,从3开始2个位置所以是世界
//写入字符串
fileWriter.write("字符串");
//写入部分字符串
fileWriter.write("韩顺平,java",0, 3);
} catch (IOException e) {
throw new RuntimeException(e);
} finally {
//关闭字符流
try {
fileWriter.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
}
7.节点流与处理流
1.基本介绍
简单来说,就是节点流的处理局限性太强,java设计者就设计了处理流,处理流中有一个属性,这个属性是一个类的引用,而这个类是各种节点流的父类,通过将其他节点流的对象赋值给这个属性,就可以向上转型,从而使用这个属性来调用各种节点流的方法
2.节点流和处理流的区别和联系
- 节点流式底层流,直接跟数据源相接
- 处理流(包装类 )包装节点流,既可以消除不同节点流的实现差异,也可以对提供更方便的方法来完成输入输出
- 处理流对节点流进行包装,使用了修饰器设计模式,不会与数据源直接相连
- 重点就是:处理流有一个属性,这个属性是很多子类型的父类,也就是说可以接收很多子类型的对象,接受的谁的对象,掉用的就是谁的方法
8.BufferedReader
代码实例
java
package IO_;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
/**
* @author 孙显圣
* @version 1.0
*/
public class BufferReader_ {
public static void main(String[] args) {
//读取的路径
String path = "e:\\a.txt";
//BufferedReader的引用
BufferedReader bufferedReader = null;
//接受读取的内容
String readData = null;
try {
bufferedReader = new BufferedReader(new FileReader(path)); //由于要对文件进行操作,所以传入FileReader
while ((readData = bufferedReader.readLine()) != null) { //按行读取
System.out.println(readData);
}
} catch (FileNotFoundException e) {
throw new RuntimeException(e);
} catch (IOException e) {
throw new RuntimeException(e);
} finally {
try {
bufferedReader.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
}
9.BufferedWriter
案例
代码实例
java
package IO_;
import java.io.FileWriter;
import java.io.IOException;
/**
* @author 孙显圣
* @version 1.0
*/
public class BufferedWriter {
public static void main(String[] args) throws IOException {
String path = "e:\\a.txt";
java.io.BufferedWriter bufferedWriter = new java.io.BufferedWriter(new FileWriter(path, true));//以追加的方式写入
bufferedWriter.write("韩顺平教育,,,java");
bufferedWriter.close(); //关闭外层流
}
}
10.Buffered拷贝
代码实例
java
package IO_;
import java.io.*;
import java.io.BufferedWriter;
/**
* @author 孙显圣
* @version 1.0
*/
public class BufferedCopy {
public static void main(String[] args) throws IOException {
//源地址
String src = "e:\\a.txt";
//目标地址
String dest = "e:\\b.txt";
String readData = null; //存储读取信息
//获取输入流
BufferedReader bufferedReader = new BufferedReader(new FileReader(src));
//获取输出流
BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(dest));
//按行读取信息
while ((readData = bufferedReader.readLine()) != null) {
//写入
bufferedWriter.write(readData);
bufferedWriter.newLine(); //写入一行
}
//关闭
bufferedWriter.close();
bufferedReader.close();
}
}
11.Buffered字节处理流
1.基本介绍
2.字节处理流拷贝(图片/音乐)
代码实例
java
package IO_;
import java.io.*;
import java.io.FileInputStream;
/**
* @author 孙显圣
* @version 1.0
*/
public class BufferedCopy02 {
public static void main(String[] args) throws IOException {
//源地址
String src = "e:\\1.png";
//目标地址
String dest = "e:\\3.png";
//存储读取到的字节数组
byte[] bytes = new byte[1024];
//存储读取长度
int readLen = 0;
//获取输入字节流
BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream(src));
//获取输出字节流
BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(dest));
//循环读取
while ((readLen = bufferedInputStream.read(bytes)) != -1) {
bufferedOutputStream.write(bytes, 0, readLen);
}
//关闭字节流
bufferedInputStream.close();
bufferedOutputStream.close();
}
}
3.字节处理流和字符处理流比较
- 字节处理流主要用于处理二进制文件(视频、图片等),也能处理二进制文件
- 字符处理流主要用于处理文本文件(效率高),不能处理二进制文件
- 字节处理流可以写一个字节、字节数组、部分字节数组
- 字符处理流可以写一个字符、一个字符数组、一个字符串、部分字符数组、部分字符串
- 简单来说,字节处理的是单个字节,字节数组,字符处理的是单个字符,字符数组,字符串
12.对象处理流(读写对象)
1.序列化和反序列化
介绍
- 序列化就是在保存数据的时候,保存数据的值和数据类型
- 反序列化就是在回复数据时,恢复数据的值和数据类型
- 需要让某个对象支持序列化机制,则必须让其类是可序列化的,为了让某个类是可序列化的,该类必须实现如下两个接口之一
- Serializable(推荐) 这是一个标记接口,里面没有任何方法
- Externalizable
2.ObjectOutputStream
类图
案例
java
package IO_;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.Serializable;
/**
* @author 孙显圣
* @version 1.0
*/
public class ObjectOutputStream_ {
public static void main(String[] args) throws IOException {
//输出文件路径
String path = "e:\\data.dat"; //注意序列化的文件是dat格式的
//获取对象输出流
ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(path));
//保存
objectOutputStream.writeInt(100); // Integer
objectOutputStream.writeBoolean(true);
objectOutputStream.writeChar('a');
objectOutputStream.writeDouble(10.2);
objectOutputStream.writeUTF("adf");
objectOutputStream.writeObject(new Dog("jack",12));
//关闭
objectOutputStream.close();
}
}
class Dog implements Serializable {
private String name;
private int age;
public Dog(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Dog{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
3.ObjectInputStream
类图
案例
java
package IO_;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
/**
* @author 孙显圣
* @version 1.0
*/
public class ObjectInputStream_ {
public static void main(String[] args) throws IOException, ClassNotFoundException {
//输入的地址
String path = "e:\\data.dat";
//获取对象处理流
ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(path));
// 按照之前序列化的次序来获取对象
System.out.println(objectInputStream.readInt());
System.out.println(objectInputStream.readBoolean());
System.out.println(objectInputStream.readChar());
System.out.println(objectInputStream.readDouble());
System.out.println(objectInputStream.readUTF());
Object o = objectInputStream.readObject();
System.out.println(o.getClass());
System.out.println(o);
//关闭对象处理流
objectInputStream.close();
}
}
对象处理流使用细节
- 在修改了对象处理流的文件之后,需要重新运行一遍程序,保持版本一致性
- 如果是自定义的对象,要保证该输入流文件可以引入
- 读写顺序需要一致
- 序列化或者反序列化对象必须实现Serializable接口
- 序列化中的类建议添加SerialVersionUID,为了提高版本的兼容性
- 序列化对象时,默认将里面所有属性都进行序列化,但除了static或transient修饰的成员
- 序列化对象时,要求里面的属性也需要实现序列化接口
- 序列化具备可继承性,也就是如果某类已经实现了序列化,则它的所有子类也默认实现了序列化
13.标准输入输出流
System.in
- 编译类型:InputStream
- 运行类型:BufferedInputStream(可以处理所有输入,只需要传入相应的InputStream子类即可)
- 表示的是标准输入 键盘
System.out
- 编译类型:PrintStream
- 运行类型:PrintStream
- 表示的是标准输出 显示器
new Scanner(System.in)
- 这个就相当于给扫描器传入了接受键盘输入的数据
14.转换流(字节流转换成字符流并指定编码)
1.字符流出现乱码引出转换流
- 将文件类型改成非utf-8,然后使用字符流读取
- 如果想解决这个问题,就只能将字符流转换成字节流并且指定编码,然后再转回来
2.InputStreamReader
解决乱码问题
代码实例
java
package IO_;
import org.junit.jupiter.api.Test;
import java.io.FileInputStream;
import java.io.*;
/**
* @author 孙显圣
* @version 1.0
*/
public class CodeQuestion {
public static void main(String[] args) throws IOException {
//使用字符流读取文件内容
String url = "e:\\a.txt";
//获取字符处理流
BufferedReader bufferedReader = new BufferedReader(new FileReader(url));
//读取一行内容
String s = bufferedReader.readLine();
System.out.println(s);
}
//字节流转换成字符流
@Test
public void test() throws IOException {
String url = "e:\\a.txt";
//这里是使用文件字节流读取信息,并传入编码,会返回一个字符流的实例
InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream(url), "gbk");
// //使用节点流的方式去读
// char[] chars = new char[100];
// int readLen;
// while ((readLen = inputStreamReader.read(chars)) != -1) { //读到字符数组中并返回读取的长度
// System.out.println(new String(chars, 0, readLen)); //根据读取的长度取出数组内的长度
// }
//使用BufferedReader的方式去读
String re = null;
BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
while ((re = bufferedReader.readLine()) != null) {
System.out.println(re);
}
}
}
3.OutputStreamWriter
案例
代码示例
java
package IO_;
import java.io.*;
import java.io.BufferedWriter;
/**
* @author 孙显圣
* @version 1.0
*/
public class FileOutputStream02 {
public static void main(String[] args) throws IOException {
//使用OutputStreamWriter 将字节流转换成字符流指定utf-8并且执行
//要写入的url
String url = "e:\\a.txt";
BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(url), "utf-8"));
//这里使用OutputStreamWriter将字节流转化为字符流并且指定编码,并且使用BufferedWriter来操作这个字符流
bufferedWriter.write("世界,你好!");
bufferedWriter.close();
}
}
15.打印流
PrintStream(字节打印流)
代码实例
java
package IO_;
import java.io.FileNotFoundException;
import java.io.PrintStream;
/**
* @author 孙显圣
* @version 1.0
*/
public class PrintStream_ {
public static void main(String[] args) throws FileNotFoundException {
//使用字节打印流在屏幕打印
PrintStream out = System.out;
out.println("你好,世界");
//修改打印位置为文件中的位置
System.setOut(new PrintStream("e:\\a.txt"));
System.out.println("dsfasdfs");
}
}
PrintWrite(字符打印流)
代码实例
java
package IO_;
import java.io.*;
/**
* @author 孙显圣
* @version 1.0
*/
public class PrintWriter_ {
public static void main(String[] args) throws IOException {
PrintWriter printWriter = new PrintWriter(System.out); //传入了一个标准输出到屏幕的对象
PrintWriter printWriter1 = new PrintWriter(new FileWriter("e:\\a.txt")); //传入了一个输入到文件的对象
printWriter1.print("辅导费");
printWriter1.close();
printWriter.println("dagasdg");
printWriter.close();
}
}
16.IO流总结
1.示意图
字节流
- InputStream
- FileInputStream(节点流)
- BufferedInputStream(处理流)(System.in 标准输入 键盘)
- ObjectInputStream(对象处理流,反序列化)
- OutputStream
- FileOutputStream(节点流)
- BufferedOutputStream(处理流)
- ObjectOutputStream(对象处理流,序列化)
- PrintStream(字节打印流)(System.out 标准输出 显示器)
字符流
- Reader
- FileReader(节点流)
- BufferedReader(处理流)
- InputStreamReader(转换流)
- Writer
- FileWriter(节点流)
- BufferedWriter(处理流)
- OutputStreamWriter(转换流)
- PrintWriter(字符打印流)
2.细节说明
1.字节流和字符流处理的数据
- 字节流:处理单个字节(字符)、字节数组,一般处理二进制文件时使用
- 字符流:处理单个字符、字符数组、字符串(可写),一般处理文本文件时使用
2.处理流的说明
- 字符处理流可以读写String类型,并且 可以读一行,字节处理流还是只能读字节或者字节数组
- 由于节点流的处理局限性太强,所以产生了处理流
- 处理流使用了修饰器模式,就是使用一个其他节点流的父类型的属性,通过构造方法来接收其他节点流的实例,接受了谁的实例,这个属性调用的方法就是谁的方法,也就是处理哪个节点
- 处理流可以处理基类的所有节点子类
3.转换流的说明
- 为了指定文本文件的编码,又想使用字符流,就产生了转换流
- 转换流可以接收字节流的实例,用于读写和设置编码,然后返回一个转换流,由于这个转换流也是两大基类节点子类,所以一般使用处理流来处理
4.打印流
- System.out:默认指向标准输出 显示器的打印流,使用System.setOut可以接收输出到文件的PrintStream类
- PrintWriter:它的构造方法可以接收一个System.out(指向一个标准输出到显示器的实例),也可以接收一个输出到文件的FileWriter
5.常用的流
- 一般使用处理流Buffered。。。来进行处理
- 字节处理流,读写字节数组,需要字节数组缓冲区和计数器,循环条件是不等于-1
- 字符处理流,读写字符串,可以读一行,需要字符串缓冲区,循环条件是不等于null
17.Properties处理配置文件
1.实际需求引出properties配置文件
在开发中操作数据库需要用户名和密码,如果在程序中写死,则一但更换了数据库则需要修改源代码,所以一般将其写在配置文件中,在代码中使用Properties类来读取
2.使用Properties读取配置文件信息
java
package IO_;
import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;
/**
* @author 孙显圣
* @version 1.0
*/
public class Properties_ {
public static void main(String[] args) throws IOException {
//1.创建实例
Properties properties = new Properties();
//2.使用流的方式加载配置文件
properties.load(new FileReader("src\\mysql.properties"));
//3.以打印流的方式展示所有文件
properties.list(System.out); //这里传入一个标准打印流 屏幕
//4.根据key,获取value信息
String username = properties.getProperty("username");
String password = properties.getProperty("password");
System.out.println("username:" + username);
System.out.println("password:" + password);
}
}
3.使用Properties创建配置文件并且修改配置文件信息
java
package IO_;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;
/**
* @author 孙显圣
* @version 1.0
*/
public class Properties_1 {
public static void main(String[] args) throws IOException {
//使用properties来创建一个文件赋值并且修改
//1.创建实例
Properties properties = new Properties();
//2.为其设置几个值
properties.setProperty("username","12344");
properties.setProperty("password","9999");
//3.将其存储到配置文件中
properties.store(new FileWriter("src\\mysql1.properties"), "这个是文档开头注释");
//4.修改配置文件
properties.setProperty("username","111111");
properties.store(new FileWriter("src\\mysql1.properties"),null);
}
}
18.本章作业
作业一
题目
代码
java
package IO_;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
/**
* @author 孙显圣
* @version 1.0
*/
public class HomeWork01 {
public static void main(String[] args) throws IOException {
//创建文件对象
File file = new File("e:\\mytemp");
//判断是否是文件夹,如果不是则创建
if (!file.isDirectory()) {
file.mkdirs();
}
//在e盘刚才创建的目录下创建文件hello.txt,如果存在则输出内容
File file1 = new File(file, "hello.txt");
if (file1.exists()) {
System.out.println("文件已经存在");
//写入内容
BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(file1));
bufferedWriter.write("你好世界");
//关闭
bufferedWriter.close();
}
file1.createNewFile();
}
}
作业二
题目
代码
java
package IO_;
import org.junit.jupiter.api.Test;
import java.io.*;
import java.io.FileInputStream;
/**
* @author 孙显圣
* @version 1.0
*/
public class HomeWork02 {
public static void main(String[] args) throws IOException {
File file = new File("e:\\mytemp\\hello.txt");
//创建对象
BufferedReader bufferedReader = new BufferedReader(new FileReader(file));
//存储数据
String re = null;
int num = 0; //记录行号
while ((re = bufferedReader.readLine()) != null) { //按行读取
num ++;
//加上行号之后重新输出
System.out.println(num + re);
//读取出来
}
//关闭
bufferedReader.close();
}
//将文件改成gbk码则需要使用转换流
@Test
public void test() throws IOException {
File file = new File("e:\\mytemp\\hello.txt");
//使用转换流
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream(file), "gbk"));
String re = null;
while ((re = bufferedReader.readLine()) != null) {
System.out.println(re);
}
//关闭转换流
bufferedReader.close();
}
}
作业三
题目
代码
java
package IO_;
import org.junit.jupiter.api.Test;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;
/**
* @author 孙显圣
* @version 1.0
*/
public class HomeWork03 {
public static void main(String[] args) throws IOException {
//创建实例
Properties properties = new Properties();
//设置值
properties.setProperty("name", "tom");
properties.setProperty("age", "5");
properties.setProperty("color", "red");
//存储到文件
properties.store(new FileOutputStream("src\\dog.properties"), null);
}
}
class Dog_ {
//读取配置文件并且初始化并输出
@Test
public void test() throws IOException {
Properties properties = new Properties();
//加载文件
properties.load(new FileInputStream("src\\dog.properties"));
//完成初始化
properties.setProperty("name","jack");
//输出文件
properties.list(System.out);
}
}