【Properties特点】
/*
* 集合对象Properties类特点:
* 1. 继承Hashtable,实现Map接口
* 2. 该集合无泛型,键值都是字符串
* 3. 键值可以存储到集合中,也可以存储到持久化的设备如硬盘、U盘、光盘上。键值的来源也可是持久化的设备
* 4. 可以和IO对象结合使用,有和流技术相结合的方法
*/
【Properties的存、取】
public class PropertiesDemo1 {
public static void main(String[] args) {
function_1();
}
public static void function_1(){
Properties pro = new Properties();
// 方法1. 存储键值对 setProperty(String key, String value) 等同Map接口中的put()
pro.setProperty("1", "a");
pro.setProperty("2", "s");
pro.setProperty("3", "d");
System.out.println(pro); // {3=d, 2=s, 1=a}
// 方法2. 通过键获取值 getProperty(String key)
String str = pro.getProperty("1");
System.out.println(str); // a
// StringPropertyNames,将集合中的键存储到Set集合中,类似于Map接口的方法keySet
Set<String> set = pro.stringPropertyNames();
for(String key:set){
System.out.println(key+" "+pro.getProperty(key)); // 3 d 2 s 1 a
}
}
}
【Properties的特殊方法】
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;
/*
* Properties集合特有方法:
* 1. load(InputStream in)
* load(Reader r)
* 传递任意的 字节 或者 字符 输入流 ,流对象读取文件(".properties"文件的后缀)中的键值对,保存在集合中
*
* 2. store(OutputStream out)
* store(Writer w)
* 接受所有的字节或者字符的输出流,将集合中的键值对,写回文件中保存
*/
public class PropertiesDemo2 {
public static void main(String[] args) throws IOException {
fun_2();
}
// 1. 方法load()
public static void fun_1() throws IOException{
Properties pro = new Properties();
FileReader fr = new FileReader("E:\\workspace\\Demo\\pro.properties"); // 文件中 注释掉数据使用 “#”
// 调用集合的load方法,传递字符输入流
pro.load(fr);
System.out.println(pro.getproperty("Name")); // lisiguang 通过键获取值
fr.close();
System.out.println(pro); // {Name=lisiguang, age=22, email=129032032@qq.com}
}
// 2. 方法store()
public static void fun_2() throws IOException{
Properties pro = new Properties();
pro.setProperty("Name", "zhangsan");
pro.setProperty("age", "52");
pro.setProperty("email", "123456@qq.com");
FileWriter fw = new FileWriter("E:\\workspace\\Demo\\pro.properties");
// 键值对存回文件,调用store方法
pro.store(fw,""); // 第二个参数写修改的原因(使用英文)
fw.close();
}
}
【序列化流,反序列化流】 注意:静态不能序列化(不属于对象)
详细可以参考:https://www.cnblogs.com/xdp-gacl/p/3777987.html
对象的序列化:把对象转换为字节序列的过程。
对象的反序列化:把字节序列恢复为对象的过程。
对象序列化的两个主要用途:(1)把对象的字节序列永久保存到硬盘上。(2)在网络上传送对象的字节序列。
序列化Person成功后,在E盘生成一个.properties文件, 反序列化Person是读取.properties文件后生成一个Person对象
ObjectOutputStream: 对象输出流 构造方法参数:任意字节输出流
ObjectInputStream: 对象输入流 构造方法参数:任意字节输入流
import java.io.Serializable;
// 注意:静态不能序列化(静态属于类不属于对象)
public class Person implements Serializable{
private String name;
private int age;
// transient 阻止成员变量序列化
//private transient int age;
// serialVersionUID 序列化的版本号,凡是实现Serializable接口的类都会有一个表示序列化版本标识符的静态变量
// 类自定义序列号,编译器不会再计算序列号 作用:类的不同版本对序列化兼容,确保类的不同版本有相同的serialVersionUID
static final long serialVersionUID = 12345554L;
// 构造方法
public Person(){}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
// get set 方法
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;
}
}
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
/*
* 序列化: 用于向流中写入对象的操作流 ObjectOutputStream
* 反序列化流:用于从流中读取对象的操作流 ObjectInputStream
*
* 使用IO流,实现对象Person的序列化 和 反序列化
* 1. ObjectOutputStream(对象输出流) 写对象,实现序列化
* 构造方法:ObjectOutputStream(OutputStream out) 传递任意的字节输出流
* 写出对象的方法: void writeObject(Object o)
* 2. ObjectInputStream(对象输入流) 读对象,实现反序列化
* 构造方法:ObjectInputStream(InputStream in) 传递任意字节的输入流
* 读取对象的方法: Object readObject()
*
* 序列化Person成功后,在E盘生成一个.properties文件, 反序列化Person是读取.properties文件后生成一个Person对象
*/
public class XuLieHuaDemo1 {
public static void main(String[] args) throws IOException, ClassNotFoundException {
fun_2();
}
// 1. 对象的序列化
public static void fun_1() throws IOException{
// 创建字节输出流对象,封装文件
FileOutputStream fos = new FileOutputStream("E:\\workspace\\Demo\\xuliehua.properties"); // 或者.txt
// 创建写出对象的序列化流的对象
ObjectOutputStream oos = new ObjectOutputStream(fos);
Person per = new Person("zhangsan",32);
// 调用序列化流的方法writeObject, 写出对象
oos.writeObject(per);
oos.close();
}
// 2. 对象的反序列化 注意:异常
public static void fun_2() throws IOException, ClassNotFoundException{
// 创建字节输入流对象
FileInputStream fis = new FileInputStream("E:\\workspace\\Demo\\xuliehua.properties");
// 创建反序列化流,构造方法中传递,字节输入流
ObjectInputStream ois = new ObjectInputStream(fis);
// 调用方法readObject()读取对象
Object obj = ois.readObject();
System.out.println(obj);
ois.close();
/*
* Person中 private transient int age; transient阻止成员变量序列化
* 输出:Person [name=zhangsan, age=0]
*
* Person中 private int age;
* 输出:Person [name=zhangsan, age=32]
*/
}
}
【打印流】
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintWriter;
/*
* PrintStream 字节打印流
* PrintWriter 字符打印流
*
* 打印流的特点:
* 1. 此流不负责数据源,只负责数据目的
* 2. 为其他输出流添加功能
* 3. 永不会抛出IOException异常 , 但是 可能会抛出其他异常
*
* 构造方法:
* PrintStream() 接收File类型、字符串类型文件名、字节输出流OutputStream
* PrintWriter() 接收File类型、字符串类型文件名、字节输出流OutputStream、字符输出流Writer (较常用)
*
*
* 打印流的,可以开启自动刷新功能 ,需要满足2个条件
* 1. 输出的数据目的必须是流对象 OutputStream Writer
* 2. 必须调用print、println、format中的一个,才能启用自动刷新
*/
public class PrintDemo1 {
public static void main(String[] args) throws FileNotFoundException {
func_2();
int[] a = {1,2};
System.out.println(a); // [I@1d1e730
char[] c = {'1','2'};
System.out.println(c); // 12
byte[] b = {};
System.out.println(b); // [B@1a116c9
}
// 1. 打印流PrintWriter,向File对象的数据目的 ,写入数据
// 方法:print() println() 打印内容原样输出
// 方法:write() 打印内容走编码表
public static void func_1() throws FileNotFoundException{
File file = new File("E:\\workspace\\Demo\\print1.txt");
PrintWriter pw = new PrintWriter(file);
pw.println(100); // 写入文件中的是 100
pw.flush();
pw.write(100); // 写入文件的是 d
pw.flush();
pw.close();
}
// 2. 打印流PrintWriter,向FileOutputStream流绑定数据目的 ,写入数据
public static void func_2() throws FileNotFoundException {
FileOutputStream fos = new FileOutputStream("E:\\workspace\\Demo\\print2.txt");
PrintWriter pw = new PrintWriter(fos,true); // 启用自动刷新功能
pw.println("I"); // 写入文件中的是 I
pw.println("Love"); // 写入文件中的是 Love
pw.close();
}
}
【使用打印流复制文件】
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
/*
* 打印流实现文本复制
* 读取数据源 BufferedReader + File 读取文本行
* 写入数据目的 PrintWriter + Println 自动刷新
*
*/
public class PrintCopyDemo1 {
public static void main(String[] args) throws IOException {
// 创建缓冲流,绑定数据源
BufferedReader br = new BufferedReader(new FileReader("E:\\workspace\\Demo\\printCopy1.txt"));
// 创建打印流,绑定数据目的,开启自动刷新
PrintWriter pw = new PrintWriter(new FileWriter("E:\\workspace\\Demo\\printCopy2.txt"),true);
// 调用流方法,循环写入
String line = null;
while((line = br.readLine()) != null){
pw.println(line); // 写入文件的内容 line1: 形而上学谓之道 line2:形而下学谓之器
}
pw.close();
br.close();
}
}