java——序列化的反序列化 和 IO 流 和 单例模式下将信息存储到properties文件中
1.序列化反序列化
为什么要序列化？
因为在保存一个对象或者大型数据类型时，因为平台的不同（比如操作系统不同），需要通过网络传递时，需要适应对方的环境或者网络的协议，要将对象的数据转化成一种标准的字节流序列，从而能在其他平台还原出来和符合网络传输的要求。
所有分布式应用常常需要跨平台，跨网络，因此要求所有传的参数、返回值都必须实现序列化。
序列化：把Java对象转换为字节序列的过程。序列化之后的存储文件内容只是二进制数据，人不能读懂，需要反序列化输出到控制台查看；
反序列化：把字节序列恢复为Java对象的过程。
实现Serializable接口
transient 修饰的变量不能序列化，反序列化会变为null
jvm可以暂存修改static变量的值，但static变量不能实例化，反序列化会变为默认值；
public class Student implements Serializable{
private int id;;
private String name;
public static String sex="女";
public transient String hobby="吃吃吃";
public Student() {
this.id=1;
}
public Student(int id, String name) {
super();
this.id = id;
this.name = name;
this.id=2;
}
@Override
public String toString() {
return "Student [id=" + id + ", name=" + name +",sex="+sex+ ",hobby="+hobby+"]";
}
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 String getHobby() {
return hobby;
}
public void setHobby(String hobby) {
this.hobby = hobby;
}
}
---------------------
版权声明：本文为CSDN博主「哔哔小子」的原创文章，遵循CC 4.0 by-sa版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/bibiboyx/article/details/80100479
第一个测试方法：
public class Test {
public static void main(String[] args) throws Exception {
Student student = new Student(1, "丽日御茶子");
System.out.println(student);
student.sex="男";
student.setId(3);
student.setHobby("玩玩玩");
FileOutputStream fos=new FileOutputStream("F:"+File.separator+"TestFiles"+File.separator+"MyTest.txt");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(student);
System.out.println(student);
oos.close();
FileInputStream fis = new FileInputStream("F:"+File.separator+"TestFiles"+File.separator+"MyTest.txt");
ObjectInputStream ois = new ObjectInputStream(fis);
Student student2= (Student) ois.readObject();
System.out.println(student2);
}
}
结果：
Student [id=2, name=丽日御茶子,sex=女,hobby=吃吃吃]
Student [id=3, name=丽日御茶子,sex=男,hobby=玩玩玩]
Student [id=3, name=丽日御茶子,sex=男,hobby=null]
第一次测试结果：
从第一个结果来看，第一次打印的是默认实例化后的结果
第二次对变量设置过后的打印也没有什么问题
第三次打印发现hobby变成了null
原因：transient修饰过的变量不参与序列化，String默认值是为null，数值则为0
·
第二个测试方法：
public class Test {
public static void main(String[] args) throws Exception {
FileInputStream fis = new FileInputStream("F:"+File.separator+"TestFiles"+File.separator+"MyTest.txt");
ObjectInputStream ois = new ObjectInputStream(fis);
Student student2= (Student) ois.readObject();
System.out.println(student2);
}
}
结果：
Student [id=3, name=丽日御茶子,sex=女,hobby=null]
第二次测试结果：
性别变成了女，id还是3，hobby是null；
原因：id在序列化前已经被设置成3，序列化后该值被保存了起来，再次读取依旧是3，没有执行构造方法，所以得出反序列化是不会执行构造方法的。
hobby因为是加了transient所以不参与序列化没有被保存起来。
sex回到了原来的值女，而在第一次测试里第三次打印的结果是男，因为第一次测试里jvm并没有停止，所以方法区里sex的值被设置后确实变成了男，而静态变量是不参与序列化的，所以第一个测试程序里读取反序列化对象时，因为都是Student类所以都使用同一个地址上的值，而sex这个地址上的值已经被改变，所以打印的结果也被改变。而第二次测试里jvm已经重启，原来方法区里的sex的地址已经消失，在读取反序列化对象时又会进行一次类加载，加载时就会按照Student里写的static的默认值重新分配地址和默认值，所以读取的结果就是原来的值了。
版权声明：本文为CSDN博主「哔哔小子」的原创文章，遵循CC 4.0 by-sa版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/bibiboyx/article/details/80100479
2.IO流：OutputStraeam输出信息到文件
public class Book {
private Integer bookId;
private String bookName;
private Double price;
private Integer quantity;
Book(){}
Book(Integer bookId,String bookName,
Double price,Integer quantity){
this.bookId=bookId;
this.bookName=bookName;
this.price=price;
this.quantity=quantity;
}
@Override
public String toString() {
return "Book{" +
"bookId=" + bookId +
", Book='" + bookName + '\'' +
", price=" + price +
", quantity=" + quantity +
'}';
}
//======================================
public class Test {
public static void main(String[] args) {
List<Book> list=new ArrayList<>();
list.add(new Book(1,"java",10.0,100));
list.add(new Book(2,"linux",20.0,100));
list.add(new Book(3,"python",30.0,100));
list.add(new Book(4,"python",30.0,100));
// Book book=new Book(1,"java",10.0,100);
File file=new File("g:"+File.separator+"book.txt");
try {
OutputStream outputStream=new FileOutputStream(file,false);
Thread.sleep(100);
for (Object o:
list) {
System.out.println(o);
o=o+"\n";
outputStream.write(o.toString().getBytes());
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}catch (Exception e){
e.printStackTrace();
}
}
}
文本文件和控制台结果：
Book{bookId=1, Book=‘java’, price=10.0, quantity=100}
Book{bookId=2, Book=‘linux’, price=20.0, quantity=100}
Book{bookId=3, Book=‘python’, price=30.0, quantity=100}
Book{bookId=4, Book=‘python’, price=30.0, quantity=100}
单例模式下信息存储到properties文件
//单例类
public class DBdataSingle {
private String name;
private String passwd;
private String ip;
private DBdataSingle(){}
private static DBdataSingle dBdataSingle=null;
public static synchronized DBdataSingle getdBdataSingle() {
if (dBdataSingle==null){
dBdataSingle=new DBdataSingle();
}
return dBdataSingle;
}
//信息存储文件的方法
public void SetFile(String name,String passwd,String ip){
Properties properties=new Properties();
properties.setProperty("name",name);
properties.setProperty("passwd",passwd);
properties.setProperty("ip",ip);
try {
OutputStream outputStream=new FileOutputStream("db,properties");
properties.store(outputStream,"2019.8.13");//“ 备注 ”
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
//-=================================
public class Job1 {
public static void main(String[] args) {
DBdataSingle dBdataSingle=DBdataSingle.getdBdataSingle();
dBdataSingle.SetFile("abc","123","1.1.1.1");
}
}
结果：
#2019.8.13
#Tue Aug 13 12:20:01 GMT+08:00 2019
passwd=123
name=abc
ip=1.1.1.1