Properties类

Properties 类表示了一个持久的属性集。Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串

特点：

Hashtable的子类，map集合中的方法都可以用
该集合没有泛型。键值都是字符串
它是一个可以持久化的属性集。键值可以存储到集合中，也可以存储到持久化的设备(硬盘、U盘、光盘)上。键值的来源也可以是持久化的设备
有和流技术相结合的方法
Properties集合，它是唯一一个能与IO流交互的集合

方法：

image.png

public Object setProperty(String key, String value)调用 Hashtable 的方法 put
public Set<String> stringPropertyNames()返回此属性列表中的键集
-public String getProperty(String key)用指定的键在此属性列表中搜索属性

代码演示：

import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;
import java.util.Set;

public class Test {
    public static void main(String[] args) throws IOException {
        // 创建集合对象
        Properties prop = createProp();
        // 将集合中内容存储到文件
        writeProp(prop);
        // 读取文件中的数据，并保存到集合
        readProp();
    }
    
    
    // 创建集合对象
    public static Properties createProp(){
        
        Properties prop = new Properties();
        
        // 添加元素到集合
        prop.setProperty("a", "A");
        prop.setProperty("b", "B");
        prop.setProperty("c", "C");
        prop.setProperty("d", "D");
        
        // 遍历集合
        Set<String> keys = prop.stringPropertyNames();
        for (String key: keys){
            String value = prop.getProperty(key);
            System.out.println(key + " = " + value);
        }
        return prop;
    }
    
    
    // 将集合中内容存储到文件
    public static void writeProp(Properties prop) throws IOException{
        FileWriter fw = new FileWriter("c:\\prop.properties");
        // 键值对储存文件 后面表示保存的原因
        prop.store(fw, "first");
        fw.close(); 
    }
    
    
    // 读取文件中的数据，并保存到集合
    public static void readProp() throws IOException{
        // 创建集合
        Properties prop = new Properties();
        // 创建流对象
        FileInputStream fis = new FileInputStream("c:prop.properties");
        prop.load(fis);
        // 关闭流
        fis.close();
        System.out.println(prop);   // {b=B, a=A, d=D, c=C}
    }   
}

序列化流与反序列化流

ObjectOutputStream 将 Java 对象的基本数据类型和图形写入 OutputStream，可以使用 ObjectInputStream 读取（重构）对象，通过在流中使用文件可以实现对象的持久存储

注意：只能将支持 java.io.Serializable 接口的对象写入流中

Person类

import java.io.Serializable;

public class Person implements Serializable{
    private String name;
    private int age;
    public Person(){
        super();
    }
    public Person(String name, int age){
        super();
        this.name = name;
        this.age = age;
    }
    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;
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
}

序列化和放序列化

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class Test1 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        
        // 对象序列化
        writeObj();
        // 反序列化对象
        readObj();
    }
    
    
    // 对象序列化
    public static void writeObj() throws IOException{
        FileOutputStream fos = new FileOutputStream("c:\\person.txt");
        // 给操作文件写入对象
        ObjectOutputStream oos =  new ObjectOutputStream(fos);
        // 调用写入对象方法
        oos.writeObject(new Person("cuzz", 20));
        // 关闭资源
        oos.close();
    }
    
    
    // 反序列化对象
    public static void readObj() throws IOException, ClassNotFoundException{
        FileInputStream fis = new FileInputStream("c:\\person.txt");
        // 建立用于读取对象功能对象
        ObjectInputStream ois = new ObjectInputStream(fis);
        // 调用读取对象的方法
        Person obj = (Person)ois.readObject();
        System.out.println(obj.toString());   // Person [name=cuzz, age=20]
    }
}

序列化接口

当一个对象要能被序列化，这个对象所属的类必须实现Serializable接口，否则会发生异常NotSerializableException异常

同时当反序列化对象时，如果对象所属的class文件在序列化之后进行的修改，那么进行反序列化也会发生异常InvalidClassException，发生这个异常的原因如下：

该类的序列版本号与从流中读取的类描述符的版本号不匹配
该类包含未知数据类型
该类没有可访问的无参数构造方法

Serializable标记接口。该接口给需要序列化的类，提供了一个序列版本号，serialVersionUID 该版本号的目的在于验证序列化的对象和对应类是否版本匹配

只需要给类声明一个序列版本号private static final long serialVersionUID = 1L;

瞬态关键字transient

当一个类的对象需要被序列化时，某些属性不需要被序列化，这时不需要序列化的属性可以使用关键字transient修饰。只要被transient修饰了，序列化时这个属性就不会琲序列化了

打印流

打印流添加输出数据的功能，使它们能够方便地打印各种数据值表示形式.
打印流根据流的分类：

字节打印流PrintStream
字符打印流PrintWriter

方法：

void print(String str) 输出任意类型的数据，
void println(String str) 输出任意类型的数据，自动写入换行操作

特点：

此流不负责数据源,只负责数据目的
为其他输出流,添加功能
永远不会抛出IOException，但是可能抛出别的异常

public class PrintWriterDemo {
    public static void main(String[] args) throws IOException {
        // 创建流
        // PrintWriter out = new PrintWriter(new FileWriter("test.txt"));
        PrintWriter out = new PrintWriter("test.txt");
        // 写数据
        for (int i = 0; i < 5; i++) {
            out.println("helloWorld");
        }
        // 关闭流
        out.close();
    }
}