IO流：对象流Poperties类

Posted 2021-01-05 snzd9958

1、对象流OjectInputStream和ObjecOutputStream
   可以用它来实现对象的序列化和反序列化，但读写的对象必须实现Serializable序列化接口
   对象的输出流将指定的对象写入到文件的过程，就是将对象序列化的过程，对象的输入流将指定序列化好的文件读出来的过程，就是对象反序列化的过程
   
   常用构造方法：
   ObjectOutputStream oos = new ObjectOutputStream(OutputStream out);//创建一个写入指定OutputStream的ObjectOutputStream对象.   
   ObjectInputStream ois = new ObjectInputStream(InputStream in);//创建从指定 InputStream 读取的 ObjectInputStream

   public class Student implements Serializable{
    /**
     *但是，如果这时候这个obj.txt是我们项目中一个文件，而项目到后期在原来Student类的基础上添加成员变量String sex;   
     *private int id;
     *private String name;
     *private int age;
     *private String sex;//新添加成员变量
     *这时候如果我们再反序列化，则会引发异常：java.io.InvalidClassException: xuliehua.User; local class incompatible: stream classdesc serialVersionUID = 2161776237447595412, local class serialVersionUID = -3634244984882257127
     *serialVersionUID 是用于记录class文件的版本信息的，serialVersionUID这个数字是JVM(JAVA虚拟界)通过一个类的类名、成员、包名、工程名算出的一个数字。
     *    而这时候序列化文件中记录的serialVersionUID与项目中的不一致，即找不到对应的类来反序列化
     *如果序列化与反序列化的时候可能会修改类的成员，那么最好一开始就给这个类指定一个serialVersionUID，如果一类已经指定的serialVersionUID，然后
     *    在序列化与反序列化的时候，jvm都不会再自己算这个 class的serialVersionUID了
     */
    private static final long serialVersionUID = 1L;

    private int id;
    private String name;
    private int age;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        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 Student(int id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }
    public Student() {
    }
    public String toString() {
        return "Student [id=" + id + ", name=" + name + ", age=" + age + "]";
    }
   }

   public class ObjectInputStream {

    public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
        //序列化
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("d:\test\test02.txt"));
        oos.writeObject(new Student(1,"小明",24));
        oos.writeObject(new Student(2,"小张",25));
        oos.writeObject(new Student(3,"小李",26));
        oos.writeObject(new Student(4,"小王",27));
        oos.writeObject(new Student(5,"小吕",28));
        oos.close();
        //反序列化
        java.io.ObjectInputStream ois = new java.io.ObjectInputStream(new FileInputStream("d:\test\test02.txt"));
        Object o = null;
        while((o = ois.readObject())!=null) {
            Student s = (Student)o;
            System.out.println(s);
        }
        ois.close();
    }

}

   写入文件内容：
 sr IOObject.Student       I ageI idL namet Ljava/lang/String;xp     t 灏忔槑sq ~       t 灏忓紶sq ~       t 灏忔潕sq ~       t 灏忕帇sq ~       t 灏忓悤
   
   运行打印内容：
Student [id=1, name=小明, age=24]
Student [id=2, name=小张, age=25]
Student [id=3, name=小李, age=26]
Student [id=4, name=小王, age=27]
Student [id=5, name=小吕, age=28]
反序列化时抛出java.io.EOFException异常

问题描述:在反序列化对象时,当对象出入流将文件的全部类反序列化之后,始终会抛出java.io.EOFException.

原因:java API文档中对于反序列化对象时使用的java.io.ObjectInputStream类的readObject()方法的描述有一句话是"该方法始终会抛出异常",也就是说该异常无法避免的.

解决方法:

　　该异常是输入流已经到结尾了的标志,我们可以将其捕获,然后不做任何操作,即结束了该次反序列化操作

   public class ObjectStreamTest {
 
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        FileOutputStream out = new FileOutputStream("test3.txt");
        ObjectOutputStream outputStream = new ObjectOutputStream(out);
        outputStream.writeObject(new Student("魏金浩" , 23, 138896));
        outputStream.close();
        Student i;
        FileInputStream in = new FileInputStream("test3.txt");
        ObjectInputStream inputStream = new ObjectInputStream(in);
        i = (Student)inputStream.readObject();//容易造成异常的发生，可能读取超界
        System.out.println(i);
        inputStream.close();
    }
   }
   优化代码：
   public static void main(String[] args) throws IOException, ClassNotFoundException {
        FileOutputStream out = new FileOutputStream("test3.txt");
        ObjectOutputStream outputStream = new ObjectOutputStream(out);
        ArrayList<Student> a = new ArrayList<>();
        a.add(new Student("魏金浩" , 23, 138896));
        outputStream.writeObject(a);
        outputStream.close();
        ArrayList<Student> b;
        FileInputStream in = new FileInputStream("test3.txt");
        ObjectInputStream inputStream = new ObjectInputStream(in);
        b = (ArrayList)inputStream.readObject();//我们只需要读取一次所以不会造成越界
        inputStream.close();
        for (Student student : b) {
            System.out.println(student);
        }
   }

   transient关键字：
   当你不想要某些字段序列化时候，可以用transient关键字修饰
    private int id;
    private String name;
    private int age;
    private transient String sex;//新添加的成员变量//添加关键字transient后，序列化时忽略

   总结：

   1. 如果对象需要被写出到文件上，那么对象所属的类必须要实现Serializable接口。 Serializable接口没有任何的方法，是一个标识接口而已。
   2. 对象的反序列化创建对象的时候并不会调用到构造方法的。
   3. serialVersionUID 是用于记录class文件的版本信息的，serialVersionUID这个数字是通过一个类的类名、成员、包名、工程名算出的一个数字。
   4. 使用ObjectInputStream反序列化的时候，ObjeectInputStream会先读取文件中的serialVersionUID，然后与本地的class文件的serialVersionUID进行对比，如果这两个id不一致，反序列则失败。
   5. 如果序列化与反序列化的时候可能会修改类的成员，那么最好一开始就给这个类指定一个serialVersionUID，如果一类已经指定的serialVersionUID，然后在序列化与反序列化的时候，jvm都不会再自己算这个 class的serialVersionUID了。
   6. 如果一个对象某个数据不想被序列化到硬盘上，可以使用关键字transient修饰。
   7. 如果一个类维护了另外一个类的引用，则另外一个类也需要实现Serializable接口。

2、Poperties类

   Java中有个比较重要的类Properties（Java.util.Properties），主要用于读取Java的配置文件，各种语言都有自己所支持的配置文件，配置文件中很多变量是经常改变的，这样做也是为了方便用户，让用户能够脱离程序本身去修改相关的变量设置
   在Java中，其配置文件常为.properties文件，格式为文本文件，文件的内容的格式是“键=值”的格式，文本注释信息可以用"#"来注释。
   
   主要的方法：
1． getProperty ( String key)，用指定的键在此属性列表中搜索属性。也就是通过参数 key ，得到 key 所对应的 value。

2． load ( InputStream inStream)，从输入流中读取属性列表（键和元素对）。通过对指定的文件（比如说上面的 test.properties 文件）进行装载来获取该文件中的所有键 - 值对。以供 getProperty ( String key) 来搜索。

3． setProperty ( String key, String value) ，调用 Hashtable 的方法 put 。他通过调用基类的put方法来设置 键 - 值对。

4． store ( OutputStream out, String comments)，以适合使用 load 方法加载到 Properties 表中的格式，将此 Properties 表中的属性列表（键和元素对）写入输出流。与 load 方法相反，该方法将键 - 值对写入到指定的文件中去。

5． clear ()，清除所有装载的 键 - 值对。该方法在基类中提供。

   Java读取Properties文件
   最常用的还是通过java.lang.Class类的getResourceAsStream(String name)方法来实现，如下可以这样调用：
   InputStream in = getClass().getResourceAsStream("资源Name");

   或者下面这种也常用：
   InputStream in = new BufferedInputStream(new FileInputStream(filepath));
   综合实例：
   public class PopertyTest {

    public static void main(String[] args) throws IOException {
        Properties pp = new Properties();
        //读取文件中的信息并写入Properties
        FileInputStream f = new FileInputStream("a.poperties");
        pp.load(f);
        String s = pp.getProperty("name");
        System.out.println(s);
        //返回Properties表中的键的Set集合
        Set<String > set = pp.stringPropertyNames();
        Iterator<String> it = set.iterator();
        while(it.hasNext()) {
            String ss= it.next();
            System.out.println(ss+"="+pp.getProperty(ss));
        }
        
        FileOutputStream fos = new FileOutputStream("a.poperties");
        //增加Properties中的属性
        pp.setProperty("sex", "女");
        //将此 Properties 表中的属性列表（键和元素对）写入输出流  
        pp.store(fos, "alfj");
    }
   }