Properties
- 该类的特点:键值对集合,键值对类型都是String类型的。
一.构造方法
Properties() 创建一个无默认值的空属性列表。
Properties(Properties defaults) 创建一个带有指定默认值的空属性列表。
二.常用方法
String
getProperty(String key) 用指定的键在此属性列表中搜索属性。
String
getProperty(String key, String defaultValue) 用指定的键在属性列表中搜索属性。
void
load(InputStream inStream) 从输入流中读取属性列表（键和元素对）。
Object
setProperty(String key, String value) 调用 Hashtable 的方法 put。
void
store(OutputStream out, String comments) 以适合使用 load 方法加载到 Properties 表中的格式，将此 Properties 表中的属性列表（键和元素对）写入输出流。
基本步骤：
- 确定目标文件:源文件和要写出去文件位置,可以使用File
- 创建输入输出流：字节流、字符流、转换流、缓冲流
- 读取内容或写出内容,可以使用数组(byte char)
- 关闭资源（强制刷新）
三.代码
- 基本io流来读取
//基本io流来读取
@Test
void proper01() {
//源文件
File file=new File("db.properties");
//io流
try {
FileReader fr=new FileReader(file);
//读取信息
char[] c=new char[(int)file.length()];
fr.read(c);
//关闭资源
fr.close();
System.out.println(new String(c));
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
- properties读取文件
//properties读取文件
@Test
void proper02() {
//源文件
File file=new File("db.properties");
//io流 使用字节流
try {
FileInputStream fis=new FileInputStream(file);
//创建容器 properties
Properties pt=new Properties();
//读取IO流管道的内容
pt.load(fis);
//关闭资源
fis.close();
System.out.println(pt);
System.out.println("用户名："+pt.get("username"));
System.out.println("密码："+pt.getProperty("password"));
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
- 将文件写出到properties配置文件中
//将文件写出到properties配置文件中
@Test
void proper03() {
//目标文件
File file =new File("db.properties");
//创建properties容器，写入数据
Properties pt=new Properties();
pt.setProperty("user", "lisi");
pt.setProperty("password", "456789");
//创建字节输出流
try {
FileOutputStream fos=new FileOutputStream(file);
//写出去
pt.store(fos, "这是我们的用户信息");
//关闭资源
fos.close();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
序列化流
-
使用序列化和反序列化实现信息数据的持久化保存。
-
序列化对象,对象必须实现Serializable接口.
-
静态属性和transient修饰的属性不会被序列化.
-
确定对象是同一个:给要序列化的对象,设置一个版本号码.
-
java对象（自定义对象Object：Student teacher students<>）
序列化与反序列化的定义
- 序列化:将java对象以字节序列的形式保存.
- 反序列化:将字节序列的内容读取为java对象.
注意事项：
- 要序列化的对象必须实现 Serializable接口
- 要想反序列化 必须是先序列化
一.ObjectOutputStream
Student.java
//实现Serializable接口
public class Student implements Serializable{
private static final long serialVersionUID = 1L;//版本号码
String name;
//static int age;//静态属性不会被序列化
//transient int age;//transient修饰的属性不会被序列化
int age;
int id=10;
public Student() {
super();
// TODO Auto-generated constructor stub
}
public Student(String name, int age, int id) {
super();
this.name = name;
this.age = age;
this.id = id;
}
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;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + ", id=" + id + "]";
}
}
//序列化
@Test
void ser01() {
//目标对象
File file=new File("stu.txt");
//字节输出流
try {
FileOutputStream fos=new FileOutputStream(file);
//创建序列化流
ObjectOutputStream oos=new ObjectOutputStream(fos);
//创建对象
Student stu=new Student("zhangsan",20,1001);
Student stu01=new Student("lisi",18,1002);
ArrayList<Student> stus=new ArrayList<Student>();
stus.add(stu);
stus.add(stu01);
//写出去
oos.writeObject(stus);
//关闭资源
oos.flush();
oos.close();
fos.close();
System.out.println("序列化成功");
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
二.ObjectInputStream
//反序列化
@Test
void ser02() {
//源文件
File file = new File("stu.txt");
//创建字节输出流
try {
FileInputStream fis=new FileInputStream(file);
//创建反序列化流
ObjectInputStream ois=new ObjectInputStream(fis);
//读取对象信息
//Student stu=(Student)ois.readObject();
ArrayList<Student> stus=(ArrayList<Student>)ois.readObject();
//关闭资源
ois.close();
fis.close();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
标准打印输出流
- 使用标准输出流可以直接将信息写出到文件中去:可以向文件中写入任意类型的数据.
- 在使用标准打印输出流的时候，可以创建自带刷新缓冲区功能，也可以不带自动刷新。无论使用什么样的输出流：先手动刷新然后在关闭.
一.字节输出流 PrintStream
1.构造方法
- PrintStream(File file) 创建具有指定文件且不带自动行刷新的新打印流。
- PrintStream(File file, String csn) 创建具有指定文件名称和字符集且不带自动行刷新的新打印流。
- PrintStream(OutputStream out) 创建新的打印流。
- PrintStream(OutputStream out, boolean autoFlush) 创建新的打印流。
- PrintStream(OutputStream out, boolean autoFlush, String encoding) 创建新的打印流。
- PrintStream(String fileName) 创建具有指定文件名称且不带自动行刷新的新打印流。
- PrintStream(String fileName, String csn) 创建具有指定文件名称和字符集且不带自动行刷新的新打印流。
标准打印输出流的常用方法
- 在使用标准打印输出流的时候，可以创建自带刷新缓冲区功能，也可以不带自动刷新。无论使用什么样的输出流：先手动刷新然后在关闭。
- print,println,write写出数据, 可以将任意类型的数据直接写出到文件中.
// 字节
@Test
void byteprint() {
//目标文件
File file=new File("print.txt");
//创建输出流
try {
PrintStream ps=new PrintStream(file);
ps.write("字节打印输出流".getBytes());
ps.print("hello,我是字节输出流");
ps.flush();
ps.close();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
// 字节
@Test
void byteprint01() {
//目标文件
File file=new File("print.txt");
try {
FileOutputStream fos=new FileOutputStream(file);
//创建输出流
PrintStream ps=new PrintStream(fos);
ps.write("字节打印输出流".getBytes());
ps.print("hello,我是字节输出流");
ps.flush();
ps.close();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
二.字符输出流 PrintWriter
1.构造方法
- PrintWriter(File file) 使用指定文件创建不具有自动行刷新的新 PrintWriter。
- PrintWriter(File file, String csn) 创建具有指定文件和字符集且不带自动刷行新的新 PrintWriter。
- PrintWriter(OutputStream out) 根据现有的 OutputStream 创建不带自动行刷新的新 PrintWriter。
- PrintWriter(OutputStream out, boolean autoFlush) 通过现有的 OutputStream 创建新的 PrintWriter。
- PrintWriter(String fileName) 创建具有指定文件名称且不带自动行刷新的新 PrintWriter。
- PrintWriter(String fileName, String csn) 创建具有指定文件名称和字符集且不带自动行刷新的新 PrintWriter。
- PrintWriter(Writer out) 创建不带自动行刷新的新 PrintWriter。
- PrintWriter(Writer out, boolean autoFlush) 创建新 PrintWriter。
// 字符输出流
@Test
void charprint01() {
//目标文件
File file=new File("print.txt");
//输出流
try {
FileOutputStream fos=new FileOutputStream(file);
PrintWriter pw=new PrintWriter(fos,true);
//写出内容,使用println、printf 或 format方法将刷新输出缓冲区
pw.println(10.5);
//关闭资源
pw.flush();
pw.close();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
Java的其他流
一.二进制流
1.ByteArrayInputStream
1.构造方法
- ByteArrayInputStream(byte[] buf) 创建一个 ByteArrayInputStream，使用 buf 作为其缓冲区数组。
- ByteArrayInputStream(byte[] buf, int offset, int length) 创建 ByteArrayInputStream，使用 buf 作为其缓冲区数组。
二.字符流
1.StringBufferputStream
2.StringWrite
- 快速将字符串写出到文件中，设定一个缓冲区，提高写出速度。
2.1构造方法
StringWriter() 创建具有默认初始字符串缓冲区大小的新字符串 writer。
StringWriter(int initialSize) 创建具有指定初始字符串缓冲区大小的新字符串 writer。
2.2常用方法
3.StringReader
3.1构造方法
StringReader(String s) 创建一个新字符串 reader。
3.2常用方法
三.数据流
- 可以基本数据类型写出去.
1.DataInputStream
- 可以使用datainputStream获取指定类型.
1.1构造方法
DataInputStream(InputStream in) 使用指定的基础 InputStream 创建一个 DataInputStream。
1.2常用方法
//读取
@Test
void dataInio() {
// 创建数据输入流 ， 必须先有输出流
try {
DataInputStream dis=new DataInputStream(new FileInputStream(new File("data.txt")));
//读取数据
double readDouble = dis.readDouble();
boolean readBoolean = dis.readBoolean();
byte readByte = dis.readByte();
byte readByte2 = dis.readByte();
System.out.println(readDouble+100);
System.out.println(readBoolean);
System.out.println(readByte);
System.out.println(readByte2);
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
2.DataOutputStream
2.1构造方法
DataOutputStream(OutputStream out) 创建一个新的数据输出流，将数据写入指定基础输出流。
2.2常用方法
//数据流
@Test
void dataOutio() {
//创建写出流
try {
DataOutputStream dos=new DataOutputStream(new FileOutputStream(new File("data.txt")));
//写出数据
dos.writeDouble(10.2);
dos.writeBoolean(true);
dos.writeByte(10);
dos.writeByte(20);
//刷新关闭
dos.flush();
dos.close();
System.out.println("写出成功");
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
- 数据流可以进行对应数据类型的操作：写的时候是什么类型，读取的时候就会得到对应的数据类型。
注意
- 写出的顺序要和读取的顺序一致。
- 写的次数和读取的次数要一致，可以少读不能多读。
总结:
- 字节流: 可以操作所有文件类型.
- 字符流: 操作文本文件.
- 转换流: 底层使用字节操作,设置编码.
- 缓冲流: 使用缓冲区,提高读写效率,默认是8kb(8192字节).
- 序列化流: 将对象进行持久化数据保存和读取,底层是字节.
- 标准输出流: 输出内容,任意类型数据直接写出去,没有读取操作.
- 数据流: 基本数据类型的数据进行操作,得到的类型与写出的类型一致.
- 字符串流: 主要对字符串进行操作,可以快速的将字符串读取到io流中.
- 数组流: 将数据变成字节数组的形式读取io流中.
扫一扫
2140
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
