标准IO流的应用(存储键值对Propreties类以及序列化存储类)

1.使用Propreties类进行存储键值对

使用Propreties的好处

• 存储方便快捷
• 存放数据为键值对形式,好操作也可以在文档中查看
• 十分的简单

在我们平常的应用中常常有很多时候需要简单的存储一对信息
比如序号与人名 账号和密码 而是用IO的其他存储会显得麻烦
我们可以使用这种十分方便的Propreties进行存储

代码如下

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

/*
 * 集合对象Propreties 继承hashtable 实现Map接口
 * 可以喝IO对象结合使用 实现数据的持久储存
 */
public class PropertiesDemo {
    public static void main(String[] args) throws IOException {
        func2();
    }
    /*
     * 试用Properties集合 存储键值对
     * setProperty等同于Map接口的put
     * setProperty(String key,String value);
     * 通过键获取值,getProperty(String key)
     * 
     */
    public static void func() {
        Properties pro=new Properties();
        pro.setProperty("a", "1");
        pro.setProperty("b", "2");
        System.out.println(pro.setProperty("b", "2"));

        System.out.println(pro.getProperty("a"));
        Set<String> p=pro.stringPropertyNames();
        for(String a:p){
            System.out.println(a+"..."+pro.getProperty(a));
        }

    }
    /*
     * Properties集合特有方法load
     * load(InputStream in)
     * load(Reader r)
     * 传递任意的字节或字符输入流
     * 流对象读取文件中的键值对 保存到集合
     * 
     */
    public static void func2() throws IOException {
        Properties pro=new Properties();
        FileReader fr=new FileReader("f:\\a.properties");
        //调用集合的方法load 传递字符输入流
        pro.load(fr);
        fr.close();
        System.out.println(pro);
    }
    /*
     * Properties集合特有方法store
     * store(OutputStream out)
     * store(Writer w)
     * 接受所有字节或字符的输出流 将键值对存到文件中
     *  
     */
    public static void func3() throws IOException {
        Properties pro=new Properties();
        pro.setProperty("name", "yxh");
        pro.setProperty("age", "18");
        pro.setProperty("email", "1800000@qq.com");
        FileWriter fr=new FileWriter("f:\\a.properties");
        pro.store(fr,"");
        fr.close();
    }
}

但是这种方法却只能存储一对信息 如果要让很多信息连在一起 我们就要使用序列化存储 将一个定义好的类进行存储

2.序列化的存储

比如我们先定义一个person类来存储一个人的信息
人: 名字 年龄 还有他的说话方式(to String)等

import java.io.Serializable;

public class person implements Serializable{
    private String name;
    private int age;
    private static final long seriaLVersionUID=42231231322213L;
    //自定义序列号 计算器就不计算序列号
    public person() {
        super();
    }
    public person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "person [name=" + name + ", 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;
    }
}

在这里我们看到人的类有一个接口Serializable 这个接口可以让这个类被序列化 因为这样便可以有一个度量来方便序列化
然后 我们进行序列化存储
代码如下

package c.c.de2;

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

import com.sun.xml.internal.rngom.parse.compact.EOFException;

/*
 * IO流对象  实现对象preson序列化 和反序列化
 * ObjectOutputStream 写对象 实现序列化     netbens 
 * ObjectInputStream 写对象 实现反序列化
 */
public class ObjectOutputStreamDemo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {

        ReadObject();

    }
    /*
     * ObjectOutputStream 写对象 实现序列化
     * 构造方法 :ObjectOutputStream(OutputSteam out)
     * 传递任意的字节输出流
     * void writeObject(Object obj)谢处对象的方法
     */
    public static void WriteObject(String name,int age) throws IOException {
        //创建字节输出流  封装文件
        FileOutputStream fos=new FileOutputStream("f:\\a.txt",true);
        //创建对象的序列化流的对象 构造方法传递字节输出流
        ObjectOutputStream oos=new ObjectOutputStream(fos);
        person p=new person(name,age);

        oos.writeObject(p);

        oos.close();
    }
    /*
     * ObjectInputStream 写对象 实现反序列化
     *  ObjectInputStream(InputStream in)
     *  传递任意的字节输入流 输入流封装文件  必须是序列化文件
     *  Object readObject()读取对象
     */ 
    public static void ReadObject() throws ClassNotFoundException, IOException {
        FileInputStream fos=new FileInputStream("f:\\a.txt");
        //创建反序列化流  构造方法中 传递字节输入流
        ObjectInputStream ois=new ObjectInputStream(fos);

        Object obj;
        while(true) {
            try {
                obj=ois.readObject();
                System.out.println(obj);
            }catch(java.io.EOFException ex) {
                break;
            }finally {

            }
        }
        ois.close();
    }
}

这就是简单的序列化存储与反序列化读取