IO流之properties,序列化流和反序列化流 1. Properties类 2.序列化流与反序列化流

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

特点:

  1、Hashtable的子类,map集合中的方法都可以用。

  2、该集合没有泛型。键值都是字符串。

  3、它是一个可以持久化的属性集。键值可以存储到集合中,也可以存储到持久化的设备(硬盘、U盘、光盘)上。键值的来源也可以是持久化的设备。

  4、有和流技术相结合的方法。

方法:

把集合中的数据,保存到指定的流所对应的文件中,其中参数commonts代表描述信息

IO流之properties,序列化流和反序列化流
1. Properties类
2.序列化流与反序列化流

实际操作:

1.先创建一个properties文件

2.进行存值,因为它是Hashtable的子类,所以存取值可以使用get(),put()方法。

 1     public static void main(String[] args) throws IOException {
 2         Properties pro = new Properties();
 3         //存值
 4         pro.put("name","zhangsan");
 5         pro.put("age","18");
 6         //取值
 7         System.out.println(pro.get("name"));
 8         //将集合中的数据写入到文件中
 9         ////明确目的地
10         FileWriter fw = new FileWriter
11                 ("src/com/oracle/demo01/pro.properties");
12         pro.store(fw,"This is my properties");//描述信息
13     }

把指定流所对应的文件中的数据,读取出来,保存到Propertie集合中

IO流之properties,序列化流和反序列化流
1. Properties类
2.序列化流与反序列化流

 实际操作:

1     public static void main(String[] args) throws IOException {
2         Properties pro = new Properties();
3         //明确数据源
4         FileReader fr = new FileReader("src/com/oracle/demo01/pro.properties");
5         //将文件中的键值对读取到集合中
6         pro.load(fr);
7         System.out.println(pro.get("name"));//zhangsan
8         System.out.println(pro.get("age"));//18
9     }

2.序列化流与反序列化流

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

用于向流中写入对象的操作流 ObjectOutputStream   称为 序列化流

用于从流中读取对象的操作流 ObjectInputStream    称为 反序列化流

特点:用于操作对象。可以将对象写入到文件中,也可以从文件中读取对象。

 

2.1对象序列化流ObjectOutputStream

IO流之properties,序列化流和反序列化流
1. Properties类
2.序列化流与反序列化流

先模拟创建个Person类

 1 public class Person implements Serializable {
 2     private String name;
 3     private int age;
 4     public String getName() {
 5         return name;
 6     }
 7     public void setName(String name) {
 8         this.name = name;
 9     }
10     public int getAge() {
11         return age;
12     }
13     public void setAge(int age) {
14         this.age = age;
15     }
16     @Override
17     public String toString() {
18         return "Person [name=" + name + ", age=" + age + "]";
19     }
20 }

代码演示

 1     public static void main(String[] args) throws IOException {
 2         //明确目的地
 3         FileOutputStream fos = 
 4                 new FileOutputStream("D:\io0429\person.txt");
 5         //创建序列化流
 6         ObjectOutputStream oos = new ObjectOutputStream(fos);
 7         Person p = new Person();
 8         p.setName("张三");
 9         p.setAge(18);
10         //写对象写入文件中
11         oos.writeObject(p);
12         //释放资源
13         oos.close();
14     }

2.2对象反序列化流ObjectInputStream

IO流之properties,序列化流和反序列化流
1. Properties类
2.序列化流与反序列化流

代码演示

 1     public static void main(String[] args) throws IOException, ClassNotFoundException {
 2         //明确数据源
 3         FileInputStream fis = new FileInputStream("D:\io0429\person.txt");
 4         //创建反序列化流
 5         ObjectInputStream ois = new ObjectInputStream(fis);
 6         //读取一个对象
 7         Person p = (Person)ois.readObject();
 8         System.out.println(p);
 9         ois.close();
10     }

 2.3序列化接口

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

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

  1.该类的序列版本号与从流中读取的类描述符的版本号不匹配

  2.该类包含未知数据类型

  3.该类没有可访问的无参数构造方法

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

所以我们修改Person类的代码如下

 1 public class Person implements Serializable{
 2     private String name;
 3     private int age;
 4     public static final long serialVersionUID=123L;
 5     public String getName() {
 6         return name;
 7     }
 8 
 9     public void setName(String name) {
10         this.name = name;
11     }
12 
13     public int getAge() {
14         return age;
15     }
16 
17     public void setAge(int age) {
18         this.age = age;
19     }
20 
21     @Override
22     public String toString() {
23         return "Person [name=" + name + ", age=" + age + "]";
24     }
25     
26 }

2.4瞬态关键字transient

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

同时静态修饰也不会被序列化,因为序列化是把对象数据进行持久化存储,而静态的属于类加载时的数据,不会被序列化。