时间戳

首页 > 技术文章 > Properties类 序列化和反序列化Object 、Print

Properties类 序列化和反序列化Object 、Print

zs0322 2019-06-18 12:04 原文

Summarize：

Properties：是map的子类，存储String类型键值对的双列集合，它的后缀格式为 .properties 文件  只允许有键值对和注释(不能写中文)，一行 是 一个键值对, 不能有任何符号

序列化流（ObjectOutputStream）和反序列化流（ObjectIutputStream）：对文件的 写和读　　

打印流：分字符和字节打印流 最明显的特点 写什么就打印什么，原样输出，还有自动刷新和换行功能

Properties类：

特点：

①：Hashtable的子类，map集合中的方法都可用

②：该集合没有泛型，键值必须是字符串String类型

③：可以持久化的属性集，键值可存储在集合中，也可存储在持久化的设备上，键值的来源也可以是持久化的设备。

方法：

load(InputStream) 把指定流所对应的文件中的数据，读取出来，保存到Properties集合中

store(OutputStream,comments)把集合中的数据，保存到指定的流所对应的文件中，后面的参数代表对描述信息--一个注释，可以是空字符串

创建后缀名为.properties的文件 

#this is a person
#Tue Jun 18 11:25:42 CST 2019
age=123
name=zhangsan
#this is a person
#Tue Jun 18 11:28:09 CST 2019
name2=zhangsan
age2=123
#this is a person
#Tue Jun 18 16:29:00 CST 2019
name2=zhangsan
age2=123

 Properties存值取值

package com.oracle.demo01;
//Properties存值取值
import java.util.Properties;

public class Demo01 {
    public static void main(String[] args) {
//        空参构造 搭配的文件是.properties文件(只能存键值对)，#是注释 不能写中文，=左右不能有空格，不能换行，不能写任何符号
        Properties pro=new Properties();
//        往集合中存储键值对
        pro.setProperty("a", "1");
        pro.setProperty("b", "2");
        pro.setProperty("c", "3");
//        从集合中取值
        System.out.println(pro.getProperty("a"));
        System.out.println(pro.getProperty("b"));
        System.out.println(pro.getProperty("c"));
    }
}
读取properties到集合
package com.oracle.demo01;
//读取properties到集合
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Properties;

public class Demo02 {
    public static void main(String[] args) throws IOException {
//        1.明确数据源
        FileInputStream fis=new FileInputStream("src/com/oracle/demo01/pro.properties");// ""相对路径，用/
//        2.创建properties集合   读
        Properties pro=new Properties();
//        3.将properties文件中的键值对存到properties集合中
        pro.load(fis);
        System.out.println(pro);//map的子类，无序
    }
}
写入数据properties到集合
package com.oracle.demo01;
//写入数据properties到集合
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;

public class Demo03 {
    public static void main(String[] args) throws IOException {
//        明确目的地
        FileOutputStream fos=new FileOutputStream("src/com/oracle/demo01/pro.properties",true);
//        创建properties集合
        Properties pro=new Properties();
        pro.setProperty("name2","zhangsan");
        pro.setProperty("age2", "123");
//        将集合的键值对存到properties文件中 键不能重复
        pro.store(fos, "this is a person");
    }
}

 pm

序列化流与反序列化流

序列化流 ObjectOutputStream  序列化的目的就是把文件存到本地让你看不懂的

反序列化流：ObjectInputStream 从文件中读取

readObject()从ObjectInputStream读取对象（需向下转型）

序列化接口Serializable无功能

序列化和反序列化 问题

ClassNotFoundException 找不到这个文件

序列化冲突问题：文件在解析时会生成一个序列号，当被序列化流时从流中获得的序列化号时，就会跟文件的序列号对比，只要两个号不一样，会产生序列化异常

解决方法：在类中定死序列化号

瞬态关键字transient ：static类似，可以使属性不被序列化，被写时，输出初始化值

静态不能序列化流，

package com.oracle.demo02;
import java.io.FileInputStream;
//写一个序列化流和反序列化
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class Demo01 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        read();
//        write();
    }
//    序列化 写   将对象存到文件中，目的是将对象存到本地 -静态后的不能序列化
    public static void write() throws IOException{
//        序列化前提：要序列化的类必须实现 Serializable接口
//        明确目的地
        FileOutputStream fos=new FileOutputStream("f:\\java\\person.txt");
//        创建对象
        Person p =new Person("zhangsan",18);
//        创建序列化流
        ObjectOutputStream oos=new ObjectOutputStream(fos);
//        将person对象写入文件中
        oos.writeObject(p);
//        释放资源
        oos.close();
    }
//    反序列化  读 从文件中读取
    public static void read() throws IOException, ClassNotFoundException{
//        明确数据源
        FileInputStream fis=new FileInputStream("f:\\java\\person.txt");
//        创建反序列化流 
        ObjectInputStream ois=new ObjectInputStream(fis);
//        将文件中的对象读到person对象中
        Person p=(Person)ois.readObject();//强转
        System.out.println(p);
//        释放资源
        ois.close();
    }
}

 打印流

 是输出流的一种，只有输出目的，没有数据源，完成数据 自动刷新PrintWriter(OutStream/Writer,true) 

①：字节打印流：PrintStream

②：字符打印流：PrintWriter

package com.oracle.demo02;
//打印流
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintWriter;

public class Demo02 {
    public static void main(String[] args) throws FileNotFoundException {
//        明确目的地        
        FileOutputStream fos=new FileOutputStream("f:\\java\\a.txt",true);//true 开始自动续写功能
//        PrintWriter pw=new PrintWriter("f:\\java\\a.txt");
        PrintWriter pw=new PrintWriter(fos,true);//true开启自动刷新功能
//        向文件中写入字符串
        pw.println(100);
//        pw.flush();//刷新
        pw.print("bbbb");
//        pw.flush();
        pw.println("ccc      cc");
//        释放资源
        pw.close();
    }
}

复制 

package com.oracle.demo02;
//缓冲数据源 打印流目的地
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

public class CopyBufferedPrint {
    public static void main(String[] args) throws IOException {
//        明确数据源
        FileReader fr=new FileReader("f:\\java\\a.txt");
//        创建缓冲输入字符流  只有Buffered才有读一行的功能  
        BufferedReader br=new BufferedReader(fr);
//        明确目的地
        FileWriter fw=new FileWriter("f:\\java\\a1.txt");
//        创建打印流
        PrintWriter pw=new PrintWriter(fw,true);//true 开启刷新
//        开始复制
        String line=null;
        while((line=br.readLine())!=null){  
            pw.println(line);
        }
//        释放资源
        br.close();
        pw.close();
    }
}

 

推荐阅读