序列化、反序列化：将对象以字节流的方式，进行写入或读取

已于 2024-04-10 18:59:40 修改
阅读量430 收藏 1
点赞数 13
文章标签： windows 蓝桥杯 java 开发语言
于 2024-04-10 18:58:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_68041576/article/details/137606387
版权
本文详细介绍了Java中的序列化（将对象写入文件）和反序列化（从文件读取对象恢复成原对象）过程，以及Serializable接口和transient关键字的作用。通过示例展示了如何在ArrayList和自定义类Order中运用这些技术。
摘要由CSDN通过智能技术生成

序列化：将指定对象，以"字节流"的方式写入一个文件或网络中。

反序列化：从一个文件或网络中，以"字节流"的方式读取到对象。

package com.ztt.Demo01;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.ArrayList;

public class demo16 {
	public static void main(String[] args) {
		ArrayList<String> list=new ArrayList<String>();
		list.add("张甜甜");
		list.add("张文印");
		list.add("甜甜");
		
		//序列化：将"对象"写入至文件
		try(ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("D:\\test\\tt\\list.bin"));){
			
			//将list集合对象，写入list.bin文件中
			oos.writeObject(list);
		} catch (FileNotFoundException e) {
			
			e.printStackTrace();
		} catch (IOException e) {
		
			e.printStackTrace();
		}
		
		
	}

}

输出结果：

package com.ztt.Demo01;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.ArrayList;

public class demo17 {
	public static void main(String[] args) {
        try (ObjectInputStream in = new ObjectInputStream(new FileInputStream("D:\\test\\tt\\list.bin"))) {
            // 读取对象并尝试转换为ArrayList<String>
            ArrayList<String> list = (ArrayList<String>) in.readObject();
            System.out.println(list);
        } catch (IOException | ClassNotFoundException e) {
           
            e.printStackTrace();
        } catch (ClassCastException e) {
            
            e.printStackTrace();
        }
    }
}

输出结果：

[张甜甜, 张文印, 甜甜]
package com.ztt.Demo01;

import java.io.BufferedOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class demo18 {
	public static void main(String[] args) {
		Order order=new Order("SN002",1234.56,"AX59",0.5);
		
		//序列化时，该对象的类型，必须实现Serializable接口
		try(ObjectOutputStream oos=new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream("D:\\test\\tt\\order.ser")))){
			//写入对象
			oos.writeObject(order);
		
		} catch (IOException e) {
			
			e.printStackTrace();
		}
		
	}
}
	
	class Order implements Serializable{
	
		/*
		 * 序列化版本号
		 */
		private static final long serialVersionUID=6607463456938102524L;
		private String orderNo;//订单编号
		private double pay;//支付金额
		private double sale;//折扣
		
		//transient关键字修饰的成员变量，在序列化时，不会被写入
		private transient String validateCode;//验证码
		
		//无参构造方法
		public Order() {
			this.orderNo="SN00X";
			this.pay=0.1;
			
		}
		
		//有参构造方法
		public Order(String orderNo, double pay,String validateCode,double sale) {
		this .orderNo = orderNo ;
		this.pay = pay;
		this.validateCode=validateCode;
		this.sale=sale;
		}
		
		public Order(String orderNo) {
			this.orderNo=orderNo;
		}
		

		@Override
		public String toString() {
			return "Order [orderNo=" + orderNo + ", pay=" + pay + ", sale=" + sale + ", validateCode=" + validateCode
					+ "]";
		}

		public String getOrderNo() {
			return orderNo;
		}
		public void setOrderNo(String orderNo) {
			this.orderNo = orderNo;
		}
		public double getPay() {
			return pay;
		}
		public void setPay(double pay) {
			this.pay = pay;
		}
		
		
		
		
		
		
	}



package com.ztt.Demo01;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectInputStream;


public class demo19 {
	public static void main(String[] args) {
		//反序列化：从文件中读取一个对象
		try(ObjectInputStream in =new ObjectInputStream(
				new BufferedInputStream(
						new FileInputStream("d:\\test\\tt\\order.ser")))){
			Order order =(Order)in.readObject();
			System.out.println(order);
		} catch (ClassNotFoundException| IOException e) {
			e. printStackTrace();
		}
	}
}

输出结果：

Order [orderNo=SN002, pay=1234.56, sale=0.5, validateCode=null]

注意：
需要进行序列化操作的对象，必须实现Serializable接口,使用transient关键字修饰的成员变量，在序列化时，不会被写入；在反序列化时，不会被读取。
使用场景：本地缓存，在网络环境下，将对象以流的方式，进行传输。

例如：工作列表（备忘录）： 

package com.ztt.Demo01;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.Scanner;

//工作列表（备忘录）
public class demo20 {
	static ArrayList<String> todoList;
	static {
		//程序启动时，从文件中，反序列化得到一个todoList集合对象
		try(ObjectInputStream in=new ObjectInputStream(new BufferedInputStream(new FileInputStream("D:\\test\\tt\\todo.bin")));){
			//读取对象
			Object data=in.readObject();
			if(data==null) {
				todoList=new ArrayList<String>();
			}else {
				todoList=(ArrayList<String>)data;
			}
		} catch (FileNotFoundException e) {
			todoList=new ArrayList<String>();
	
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	public static void main(String[] args) {
		
		
		System.out.println("程序启动完毕！");
		System.out.println("当前备忘录工作列表中包含：");
		System.out.println(todoList);
		
		System.out.println("是否添加新的备忘？");
		try(Scanner input=new Scanner(System.in)){
			String line=input.nextLine();
			while(line.equalsIgnoreCase("yes")) {
				//添加一个工作备忘
				String work=input.nextLine();
				todoList.add(work);
				
				System.out.println("是否继续添加？");
				line=input.nextLine();
			}
		}
		System.out.println("添加完毕！");
		System.out.println("当前备忘录工作列表中包含：");
		System.out.println(todoList);
		
		//程序退出时，将todoList集合对象，序列化至文件
		try(ObjectOutputStream out=new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream("D:\\test\\tt\\todo.bin")));){
			
			out.writeObject(todoList);
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
			
		
	}

}

package com.ztt.Demo01;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectInputStream;


public class demo19 {
	public static void main(String[] args) {
		//反序列化：从文件中读取一个对象
		try(ObjectInputStream in =new ObjectInputStream(
				new BufferedInputStream(
						new FileInputStream("d:\\test\\tt\\order.ser")))){
			Order order =(Order)in.readObject();
			System.out.println(order);
		} catch (ClassNotFoundException| IOException e) {
			e. printStackTrace();
		}
	}
}

输出结果： 

程序启动完毕！
当前备忘录工作列表中包含：
[AAA, BBB]
是否添加新的备忘？
yes
CCC
是否继续添加？
no
添加完毕！
当前备忘录工作列表中包含：
[AAA, BBB, CCC]

Properties

  • *.properties格式的文件，内容是Key-Value键值对格式（key=value）
  • 注释使用#
  • 使用Properties类完成*properties格式文件的读取和写入，读取使用 load()，写入使用store()
  • Properties类本质其实是一个Map集合，是Hashtable类的子类。

 

package com.ztt.Demo01;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Properties;
//properties 类型的文件: key-value键值对文件
//读取

public class demo21 {
	public static void main(String[] args) {
		try(FileInputStream fis=new FileInputStream("D:\\test\\tt\\config.properties")){
		//创建Properties类型的对象props,用于读取* .properties类型的文件

		Properties props=new Properties();
		//读取
		props.load(fis);
		
		//根据key获取value
		System.out.println(props.get("029"));
		
		System.out.println(props);
		} catch (FileNotFoundException e) {
			
			e.printStackTrace();
		} catch (IOException e) {
			
			e.printStackTrace();
		}
	}

}

输出结果：

西安
{2448=杭州, 029=西安, 020=上海}

package com.ztt.Demo01;

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

public class demo22 {
	public static void main(String[] args) {
		//读取classpath路径下的*.properties文件
		//当前类所在的位置: Demo22. class . getResourceAsstream( " config. properties" )
		//当前ClassPath 下的指定位置: Demo22. class. getResourceAsstream( "/com/ .. ./config . properties'

		try(InputStream in=demo22.class.getResourceAsStream("/com/ztt/Demo01/config.properties")){
			Properties props=new Properties();
			props.load(in);
			System.out.println(props);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}

}

输出结果：

{2448=杭州, 025=成都, 029=西安, 020=上海, 010=北京}
package com.ztt.Demo01;

import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;

//properties文件的写入操作
public class demo23 {
	public static void main(String[] args) {
		Properties props=new Properties();
		props.put("version", "v0.0001");
		props.put("active-code", "asdfghjklzxcvbnmqwertyuiop");
		
		try(FileOutputStream fos=new FileOutputStream("D:\\test\\tt\\app.properties")){
			//将键值对，通过输出流写入指定文件，并添加注释
			props.store(fos, "My application basic properties data.");

		} catch (IOException e) {
			
			e.printStackTrace();
		}
	}

}

输出结果：

甜甜不甜-
关注
TXT文件读取 序列化 反序列化
weixin_39412599的博客
06-30 206
unity 序列化
3.IO反序列化(文件读操作)
CC的博客
07-29 180
反序列化: 从文件中读取对象的过程 ObjectInputStream 步骤: 1.属性类中:implements Serializable接口 2.private static final long serialVersionUID = 1L; 3.创建serialVersionUID的构造器 4.主类中:数组转为集合Arrays.asList(数组名) 例子: import java....
java将文本反序列化读取_Java中序列化(ObjectOutputStream)与反序列化(ObjectInputStrea
weixin_36212198的博客
02-24 245
序列化:将对象按照流的方式存储到文本文件中或者再网络中传输对象---->流数据 序列化流 (ObjectOutputStream)反序列化:将文本文件中的流对象或者网络传输中的流对象还原成对象流数据--->对象 反序列化流(ObjectInputStream)关键字：transient 修饰属性，这个属性就不会被序列化注意：1)必须序列化之后才可以反序列化2)自定义类要实现序...
1.1 练习案例：java对象流和文件流的相互转换
xgb2018的博客
12-15 2871
1.1 练习案例：java对象流和文件流的相互转换 1）将若干个Student对象,若干个Teacher对象,写出到d:/0404/a.txt中 2）将该文件中所有Student对象反序列化回来装入List, 所有的Teacher对象反序列化回来转入另外一个List 代码逻辑：建立一个Person类，并实现Serializable。再让Student和Teacher类继承Person。（当然这里没必要，可以直接建立Student和Teacher类） 运用知识点：对象流，文件流 （1）Person类： pac
java对象序列化流 将对象写入文件当中
最新发布
weixin_45966674的博客
10-16 1454
我们先创建了一个对象写入流ObjectOutputStream 参数是一个FileOutputStream实例化出来的一个文件对象 对应的文件在我电脑中是存在的。然后我们通过ObjectOutputStream 的writeObject将实力出来的customException对象写入到文件中 然后通过close释放资源。text测试类和customException类 我们最后要将 customException类对象写入到文件当中。对象序列化流可以写入对象和读取文件中的对象。
C#对象序列化反序列化保存与读取和对象直接保存与读取
12-05
本主题将深入探讨如何在Windows Forms（WF）环境中，利用C#语言进行对象的直接保存与读取，以及通过对象序列化和反序列化的方式实现对象的保存与恢复。 首先，我们来理解什么是对象的直接保存与读取。在C#中，可以...
Java将对象写入文件读出_序列化与反序列化的实例
08-29
Java对象序列化与反序列化是Java语言中的一种机制，用于将对象转换为字节流，以便于对象的存储和传输。在本篇文章中，我们将通过一个实例，来演示如何使用Java将对象写入文件读出，并使用序列化与反序列化来实现对象...
Java IO流对象的序列化和反序列化实例详解
08-30
Java中的对象序列化（Serialization）和反序列化（Deserialization）是Java IO流机制的重要组成部分，它提供了一种标准的方式来将对象状态保存到持久化存储中，以及从存储中恢复对象状态的过程。下面将详细阐述序列...
深入理解Java对象的序列化与反序列化的应用
09-05
通过实现`Serializable`接口，开发者可以轻松地将对象转换为字节流，以便在硬盘或网络中存储和传输，而`Externalizable`接口则提供了额外的灵活性，让开发者可以精确地控制序列化过程。在实际开发中，理解并正确使用...
java 中Spark中将对象序列化存储到hdfs
08-30
在 Spark 中，序列化是将对象转换为字节流的过程。Spark 提供了多种序列化方式，如 Java Serialization、Kryo Serialization 和 Java Serialization 等。在这篇文章中，我们使用 Java Serialization 将对象序列化。 ...
java对象序列化并存储到文件和数据库
热门推荐
刘伟的博客
04-25 3万+
Java中要实现将对象保存起来持久化，需要让对象实现Serializable接口，这样就能将java对象用二进制流保存并恢复。下面我将以保存到文件和保存到mysql来进行解析。先给出序列化类的定义:package model; import java.io.Serializable; import java.util.Date; /* * 实现可序列化接口 */ public class P...
将一个Java对象序列化到文件中
qq_35717240的博客
04-02 1181
public class DomainObject implements Serializable { private static final long serialVersionUID = -6960820659912840745L; private String objName; /** 不参加序列化 */ private transient Stri...
将Java对象写入文件中
k7_slient的博客
06-05 1万+
Java对象序列化 首先介绍一下对象序列化的目标：对象序列化的目标是将对象保存到磁盘中，或允许在网络中直接传输对象。 一、序列化的含义和意义： 序列化机制使得对象可以脱离程序的运行而独立存在。 对象的序列化指将一个Java对象写入IO流中，与此对应的反是，对象的反序列化则指从IO流中恢复该Java对象。 如果需要需要让某个对象支持序列化机制，则必须让它的类是可序列化的（serializa...
java中序列化一个对象保存在文件中的简单过程
入门菜鸟程序员的成长
04-26 6515
为什么要序列化？因为在保存一个对象或者大型数据类型时，因为平台的不同（比如操作系统不同），需要通过网络传递时，需要适应对方的环境或者网络的协议，要将对象的数据转化成一种标准的字节流序列，从而能在其他平台还原出来和符合网络传输的要求。所有分布式应用常常需要跨平台，跨网络，因此要求所有传的参数、返回值都必须实现序列化。简单来说：序列化：把Java对象转换为字节序列的过程。反序列化：把字节序列恢复为Ja...
java对象写入文件_将Java对象写入文件中
weixin_28807463的博客
02-20 3523
Java对象序列化首先介绍一下对象序列化的目标：对象序列化的目标是将对象保存到磁盘中，或允许在网络中直接传输对象。一、序列化的含义和意义：序列化机制使得对象可以脱离程序的运行而独立存在。对象的序列化指将一个Java对象写入IO流中，与此对应的反是，对象的反序列化则指从IO流中恢复该Java对象。如果需要需要让某个对象支持序列化机制，则必须让它的类是可序列化的(serializable)。为了让某个...
如何将一个java对象序列化到文件里?
慕容的博客
03-06 3647
在java中能被序列化的类必须实现Serializable接口,该接口没有任何抽象方法只是起到一个标记作用. ObjectOutputStream objectOutputStream=new ObjectOutputStream(new FileOutputStream("D://obj")); objectOutputStream.writeObject(qDingVo )...
JAVA中对于对象的读写
qq_41359808的博客
03-21 561
import java.io.*; class Person implements Serializable { String name; int age; Person(String name, int age) { this.name=name; this.age=age; } public String toString...
如何将Java对象读取和写入文件
一名可爱的技术搬运工
05-29 2800
Java对象序列化是Java库堆栈提供的一种API，用于序列化Java对象。 序列化是将对象转换为可写字节流的过程。 一旦转换为字节流，就可以将这些对象写入文件。 反向过程称为反序列化。 如果Java对象的类或其任何超类实现java.io.Serializable接口或其子接口java.io.Externalizable ，则该对象是可序列化的。 1. Java对象 人.java ...
文件读写，序列化和反序列化
qq_36096570的博客
06-24 581
现代操作系统不允许普通的程序直接操作磁盘,所以读写文件就是请求操作系统打开一个文件对象(文件描述),然后,通过操作系统提供的接口从这个文件对象中读取数据(读文件),或者把数据写入这个文件对象(写文件) 读文件 写文件 with语句 二进制文件读写 内存中读写字符串 StringIO 内存中读写...
JDK序列化API详解：对象的序列化与反序列化
这由`java.io.ObjectInputStream`完成，它提供了`readObject()`方法，从输入流中读取字节序列，然后执行反序列化操作，创建并返回相应的Java对象。 4. **对象输入流** (ObjectInputStream)： - 类似于输出流，但...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值