0227properties类，序列化流和反序列化流
1、properties类
properties是hashtable的子类，map集合中的方法都可以用
该类没有泛型，键值都是以字符串的形式存在
可以是一个属性集，也可以存储在持久化设备上
有和流相关的技术相结合的方法
代码展示
public static void main(String[] args) {
//创建一个propertise集合
Properties pro=new Properties();
//存值
pro.put("dirver", "com.oracle.jdbc.Dirver");
pro.put("user", "root");
//取值
System.out.println(pro.get("dirver"));
System.out.println(pro.getProperty("user"));
}
常用方法
load（InputStream） 是指定流所指定的文件数据读取出来放在properties类中
load（reader）与上述一致
store(OutputStream,commonts)把集合中的数据写入到指定流所对应的文件，以及描述，描述如果没有也得写个空字符串，必须写
stroe(Writer,comments)与上述一致
代码展示，将指定流的文件中的数据读取出来存到properties类中
public static void main(String[] args) throws IOException {
//明确数据源
FileReader fr=new FileReader("src/com/oracle/demo02/pro.properties");
//创建pro集合
Properties pro=new Properties();
//通过load将文件中的键值对读取得到集合中
pro.load(fr);
System.out.println(pro);
}
代码展示，将集合中的数据写入到流对应的文件
public static void main(String[] args) throws IOException {
//明确目的地
FileWriter fw=new FileWriter("src/com/oracle/demo02/pro.properties",true);
//创建pro集合
Properties pro=new Properties();
pro.put("name", "admin");
pro.put("age", "123");
//写入
pro.store(fw, "");
}
举例之前封装的JDBC工具类
首先先建一个properties文件将要经常改动的那四个属性写在里边
dirver=com.mysql.jdbc.Driver url=jdbc:mysql://localhost:3306/java1127?characterEncoding=utf-8 user=root pwd=123456 这个文件名叫 db.properties
然后我们再在之前封装的JDBC工具类中创建一个properties集合 通过输入流，将db.properties文件中的数据读取并且存在properties集合中，再通过该集合的方法取到键的值
//获取链接对象
public static Connection getConn(){
Connection conn=null;
Properties pro=new Properties();
try {
//明确数据源
FileReader fr=new FileReader("src/com/oracle/tools/db.properties");
//将文件中的键值对读取到集合中
pro.load(fr);
//注册驱动
Class.forName(pro.getProperty("dirver"));
//获得链接对象
String url=pro.getProperty("url");
String user=pro.getProperty("user");
String pwd=pro.getProperty("pwd");
conn=DriverManager.getConnection(url,user,pwd);
} catch (ClassNotFoundException | SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return conn;
}
//增删改释放资源
public static void close(Connection conn,PreparedStatement pst){
if(pst!=null){
try {
pst.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
if(conn!=null){
try {
conn.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
//查询释放资源
public static void close(Connection conn,PreparedStatement pst,ResultSet rs){
if(rs!=null){
try {
rs.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
if(pst!=null){
try {
pst.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
if(conn!=null){
try {
conn.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
//测试
public static void main(String[] args) {
Connection conn=getConn();
System.out.println(conn);
}
2、序列化流，反序列化流
图解
序列化流和反序列化流 是基于对象的操作，可以将对象写入文件，也可以从文件中读取对象（并不是只能new 才能创建对象，反序列化流也能得到一个类对象）
序列化流构造方法
ObjectOutPutStream(OutPutStream out)
常用方法
writeObject(Object obj)
反序列化流构造方法
ObjectInputStream(InputStream in)
常用方法
readObject（）返回值是object类型
我们对对象进行操作的时候，那我们创建的这个实体类需要开启被序列化的功能 否则将不会被序列化，这时就用到了Serializable接口，必须实现这个接口才可以
代码展示
写入（序列化）
public static void main(String[] args) throws IOException {
//明确目的地
FileOutputStream fos=new FileOutputStream("F:\\io1127\\person.txt");
//创建序列化liuw
ObjectOutputStream oos=new ObjectOutputStream(fos);
//创建对象
Person p=new Person("小红帽",18);
//写入
oos.writeObject(p);
//释放资源
oos.close();
}
读取（反序列化）
public static void main(String[] args) throws IOException, ClassNotFoundException {
//明确数据源
FileInputStream fis=new FileInputStream("F:\\io1127\\person.txt");
//创建反序列化
ObjectInputStream ois=new ObjectInputStream(fis);
//读取
Object obj=ois.readObject();
System.out.println(obj);
ois.close();
}
类
public class Person implements Serializable{
private transient String name;
public static int age;
public static final long serialVersionUID=100L;
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public Person() {
super();
}
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 + "]";
}
}
如果我们序列化和反序列化之后，我们对其class文件进行修改，那么我们再进行反序列化时，就会发生异常，发生原因有，版本号不匹配，该类中包含了未知的数据，访问了无参构造
那么如果版本号不匹配 我们可以定死版本号，例如上述代码中的public static final long serialVersionUID=100L;我们将版本号写死，那我们再修改然后编译的时候版本号就不会再变了
如果我们存在不想要被序列化的属性，那我们可以在其属性前加一个static关键字，因为被static关键字修饰的属性属于类，而不再属于属性，所以就不会被序列化，也可以用transient关键字修饰就不会被序列化了。
