- 浏览: 485866 次
- 性别:
- 来自: 武汉
-
最新评论
-
zyzyzy123：
请问有工程吗，我现在正在实现打电话的功能，但是一直不通，怀疑是 ...
实用的java 串口通信程序 -
wuhaitong：
引用[img][/img][*][url][/url] ...
jbpm -
迷糊_le：
maven命令， 蛮好的，谢谢
maven eclipse -
Wuaner：
不错的文章 ， 谢谢分享！
Hadoop -
yuqihengsheng：
strong 很细
HighLighter
Java序列化与反序列化
基本概念：
序列化是将对象状态转换为可保持或传输的格式的过程。与序列化相对的是反序列化，它将流转换为对象。这两个过程结合起来，可以轻松地存储和传输数据。
序列化为一般文件，也序列化为XML文件（使用XStream）。
用于序列化的实体类Person.java 代码如下（记得需要实现Serializable接口）：
import java.io.Serializable;
@SuppressWarnings("serial")
public class Person implements Serializable{
private String name;
private int age;
public Person(){
}
public Person(String str, int n){
System.out.println("Inside Person's Constructor");
name = str;
age = n;
}
String getName(){
return name;
}
int getAge(){
return age;
}
}
--------------------------------------------------------------------------------
序列化、反序列化为一般的文件，SerializeToFlatFile.java类的代码如下：
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
public class SerializeToFlatFile {
public static void main(String[] args) {
SerializeToFlatFile ser = new SerializeToFlatFile();
ser.savePerson();
ser.restorePerson();
}
public void savePerson(){
Person myPerson = new Person("Jay",24);
try {
FileOutputStream fos = new FileOutputStream("E:\\workspace\\2010_03\\src\\myPerson.txt");
ObjectOutputStream oos = new ObjectOutputStream(fos);
System.out.println("Person--Jay,24---Written");
System.out.println("Name is: "+myPerson.getName());
System.out.println("Age is: "+myPerson.getAge());
oos.writeObject(myPerson);
oos.flush();
oos.close();
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}
}
public void restorePerson() {
try {
FileInputStream fis = new FileInputStream("E:\\workspace\\2010_03\\src\\myPerson.txt");
ObjectInputStream ois = new ObjectInputStream(fis);
Person myPerson = (Person)ois.readObject();
System.out.println("\n--------------------\n");
System.out.println("Person--Jay,24---Restored");
System.out.println("Name is: "+myPerson.getName());
System.out.println("Age is: "+myPerson.getAge());
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}
}
}
运行结果为（console输出），当然可以查看到myPerson.txt文件已经生成：
Inside Person's Constructor
Person--Jay,24---Written
Name is: Jay
Age is: 24
--------------------
Person--Jay,24---Restored
Name is: Jay
Age is: 24
--------------------------------------------------------------------------------
序列化、反序列化为XML文件，我使用了XStream来序列化，需要引入xstream-1.3.1.jar包的支持，
http://xstream.codehaus.org/download.html 处可以下载jar，然后引入到Eclipse中的build path中。
Serialize.java的代码如下：
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import com.thoughtworks.xstream.*;
public class Serialize {
public static void main(String[] args) {
Serialize ser = new Serialize();
ser.serializeToXml();
ser.deSerializeFromXml();
}
public void serializeToXml(){
Person[] myPerson = new Person[2];
myPerson[0] = new Person("Jay",24);
myPerson[1] = new Person("Tom",23);
XStream xstream = new XStream();
try {
FileOutputStream fos = new FileOutputStream("E:\\workspace\\2010_03\\src\\myPerson.xml");
xstream.toXML(myPerson,fos);
} catch (FileNotFoundException ex) {
ex.printStackTrace();
}
System.out.println(xstream.toXML(myPerson));
}
public void deSerializeFromXml(){
XStream xs = new XStream();
Person[] myPerson = null;
try {
FileInputStream fis = new FileInputStream("E:\\workspace\\2010_03\\src\\myPerson.xml");
myPerson=(Person[])xs.fromXML(fis);
if (myPerson != null)
{
int len = myPerson.length;
for (int i=0;i<len;i++)
{
System.out.println(myPerson[i].getName());
System.out.println(myPerson[i].getAge());
}
}
} catch (FileNotFoundException ex) {
ex.printStackTrace();
}
}
}
运行结果为（console输出），当然可以查看到myPerson.xml文件已经生成：
Inside Person's Constructor
Inside Person's Constructor
<Person-array>
<Person>
<name>Jay</name>
<age>24</age>
</Person>
<Person>
<name>Tom</name>
<age>23</age>
</Person>
</Person-array>
一、两个概念，何为序列化？何为反序列化？
序列化：将对象转化成流的过程称为序列化。
反序列化：将流转化成对象的过程称之为反序列化。
二、序列化机制一般用途？
1.需要将对象的状态保存到文件中，而后能够通过读入对象状态来重新构造对象，恢复程序状态
2.使用套接字在网络上传送对象的程序来说，是很有用的。
3.通过序列化在进程间传递对象。
三、Java对象序列化究竟保存的是什么？
Java的序列化机制只序列化对象的属性值，而不会去序列化什么所谓的方法。其实这个问题简单思考一下就可以搞清楚，方法是不带状态的，就是一些指令，指令是不需要序列化的，只要你的JVM classloader可以load到这个类，那么类方法指令自然就可以获得。序列化真正需要保存的只是：对象的类型，对象属性的类型，对象属性的值。
四、序列化和反序列化的操作
a) Java对象和java.io.Serializable接口
在java中要想使一个java对象可以实现序列化与反序列化,必须让该类实现java.io.Serializable接口,它并未指定要实现的方法，所以Serializable被称为"tagging interface" ，但是它仅仅"tags"它自己的对象是一个特殊的类型。任一个您希望serialize的对象都应该实现这个接口。这是必须的。否则，用到流技术时将根本不工作。例如，如果您试着去serialize 一个没有实现这个接口的对象，一个 NotSerializableException将产生。 类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。可序列化类的所有子类型本身都是可序列化的。序列化接口没有方法或字段，仅用于标识可序列化的语义。
java.io.Serializable接口定义如下:
public interface Serializable {
}
b) 序列化和反序列化
序列化主要依赖java.io.ObjectOutputStream类，该类对java.io.FileOutputStream进一步做了封装，这里主要使用ObjectOutputStream类的writeObject()方法实现序列化功能。
反序列化主要依赖java.io.ObjectInputStream类，这里主要使用ObjectInputStream类的readObject()方法实现序列化功能。
在序列化的时候，writeObject与 readObject之间的先后顺序。readObject将最先write的object read出来。用数据结构的术语来讲就姑且称之为先进先出吧！
在序列化时，有几点要注意的：
１：当一个对象被序列化时，只保存对象的非静态成员变量，不能保存任何的成员方法和静态的成员变量。
２：如果一个对象的成员变量是一个对象，那么这个对象的数据成员也会被保存。
３：如果一个可序列化的对象包含对某个不可序列化的对象的引用，那么整个序列化操作将会失败，并且会抛出一个NotSerializableException。我们可以将这个引用标记为transient，那么对象仍然可以序列化。
还有我们对某个对象进行序列化时候，往往对整个对象全部序列化了，比如说对象里有些数据不希望序列化，一个方法可以用transient来标识，另一个方法我们可以在这个类里重写二个方法
private void readObject(java.io.ObjectInputStream stream)
throws IOException, ClassNotFoundException;
private void writeObject(java.io.ObjectOutputStream stream)
throws IOException
Java代码
1.class ObjectSerialTest
2.{
3. public static void main(String[] args) throws Exception
4. {
5. Employee e1 = new Employee( " zhangsan " , 25 , 3000.50 );
6. Employee e2 = new Employee( " lisi " , 24 , 3200.40 );
7. Employee e3 = new Employee( " wangwu " , 27 , 3800.55 );
8.
9. FileOutputStream fos = new FileOutputStream( " employee.txt " );
10. ObjectOutputStream oos = new ObjectOutputStream(fos);
11. oos.writeObject(e1);
12. oos.writeObject(e2);
13. oos.writeObject(e3);
14. oos.close();
15.
16. FileInputStream fis = new FileInputStream( " employee.txt " );
17. ObjectInputStream ois = new ObjectInputStream(fis);
18. Employee e;
19. for ( int i = 0 ;i < 3 ;i ++ )
20. {
21. e = (Employee)ois.readObject();
22. System.out.println(e.name + " : " + e.age + " : " + e.salary);
23. }
24. ois.close();
25. }
26.}
27.
28.class Employee implements Serializable
29.{
30. String name;
31. int age;
32. double salary;
33. transient Thread t = new Thread();
34. public Employee(String name, int age, double salary)
35. {
36. this .name = name;
37. this .age = age;
38. this .salary = salary;
39. }
40. private void writeObject(java.io.ObjectOutputStream oos) throws IOException
41. {
42. oos.writeInt(age);
43. oos.writeUTF(name);
44. System.out.println( " Write Object " );
45. }
46. private void readObject(java.io.ObjectInputStream ois) throws IOException
47. {
48. age = ois.readInt();
49. name = ois.readUTF();
50. System.out.println( " Read Object " );
51. }
52.
53.}
其实还有一个接口java.io.Externalizable，它继承了Serializable接口，所以也可以通过实现它,定义readExternal和writeExternal方法来实现序列化。
ObjectOutputStream调用类的writeExternal方法对Customer对象的非transient实例变量进行序列化；
ObjectInputStream首先通过类的无参数构造函数实例化一个对象，再用readExternal方法对对象的非transient实例变量进行反序列化。
五、总结
如果采用默认的序列化方式，只要让一个类实现Serializable接口，其实例就可以被序列化。通常，专门为继承而设计的类应该尽量不要实现 Serializable接口，因为一旦父类实现了Serializable接口，其所有子类也都是可序列化的了。
默认的序列化方式的不足之处：
1.直接对对象的不宜对外公开的敏感数据进行序列化，这是不安全的；
2.不会检查对象的成员变量是否符合正确的约束条件，有可能被传改数据而导致运行异常；
3.需要对对象图做递归遍历，如果对象图很复杂，会消耗很多资源，设置引起Java虚拟机的堆栈溢出；
4.使类的接口被类的内部实现约束，制约类的升级与维护。
通过实现Serializable接口的private类型的writeObject()和readObject()，或是实现 Externalizable接口，并实现writeExternal()与readExternal()方法，并提供public类型的无参数构造函数两种方式来控制序列化过程可以有效规避默认序列化方式的不足之处。
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package phprpchessiantest;
import com.caucho.burlap.io.BurlapInput;
import com.caucho.burlap.io.BurlapOutput;
import com.caucho.hessian.io.HessianInput;
import com.caucho.hessian.io.HessianOutput;
import com.caucho.hessian.io.Hessian2StreamingInput;
import com.caucho.hessian.io.Hessian2StreamingOutput;
import com.exadel.flamingo.flex.messaging.amf.io.AMF3Deserializer;
import com.exadel.flamingo.flex.messaging.amf.io.AMF3Serializer;
import com.googlecode.jsonplugin.JSONUtil;
import java.beans.XMLDecoder;
import java.beans.XMLEncoder;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.lang.reflect.InvocationTargetException;
import java.util.Date;
import java.util.HashMap;
import net.sf.json.JSON;
import net.sf.json.JSONSerializer;
import org.phprpc.util.PHPSerializer;
class TestClass implements Serializable {
private int id;
private String userName;
private String password;
private int age;
/**
* @return the id
*/
public int getId() {
return id;
}
/**
* @param id the id to set
*/
public void setId(int id) {
this.id = id;
}
/**
* @return the userName
*/
public String getUserName() {
return userName;
}
/**
* @param userName the userName to set
*/
public void setUserName(String userName) {
this.userName = userName;
}
/**
* @return the password
*/
public String getPassword() {
return password;
}
/**
* @param password the password to set
*/
public void setPassword(String password) {
this.password = password;
}
/**
* @return the birthday
*/
public int getAge() {
return age;
}
/**
* @param birthday the birthday to set
*/
public void setAge(int age) {
this.age = age;
}
}
public class Main {
public static void runTest(int times, Object data, String info, String filename) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, IOException, ClassNotFoundException {
Date start, end;
long size = 0;
long stime = 0;
long dtime = 0;
StringBuilder sb = new StringBuilder();
StringBuilder categories = new StringBuilder();
StringBuilder dataset1 = new StringBuilder();
StringBuilder dataset2 = new StringBuilder();
StringBuilder dataset3 = new StringBuilder();
sb.append("<chart caption='" + times + "次" + info + "序列化与反序列化的比较' shownames='1' showvalues='1' decimals='0' formatNumberScale='0' baseFont='Tahama' baseFontSize='12'>");
categories.append("<categories>");
dataset1.append("<dataset seriesName='序列化时间'>");
dataset2.append("<dataset seriesName='反序列化时间'>");
dataset3.append("<dataset seriesName='空间'>");
System.out.println("--------------------------------------------------------------------------------");
System.out.println(times + "次" + info);
try {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos);
oos.writeObject(data);
oos.close();
byte[] b = bos.toByteArray();
size = b.length;
ByteArrayInputStream bis = new ByteArrayInputStream(b);
ObjectInputStream ois = new ObjectInputStream(bis);
ois.readObject();
ois.close();
start = new Date();
for (int i = 0; i < times; i++) {
bos = new ByteArrayOutputStream();
oos = new ObjectOutputStream(bos);
oos.writeObject(data);
oos.close();
}
end = new Date();
stime = end.getTime() - start.getTime();
start = new Date();
for (int i = 0; i < times; i++) {
bis = new ByteArrayInputStream(b);
ois = new ObjectInputStream(bis);
ois.readObject();
ois.close();
}
end = new Date();
dtime = end.getTime() - start.getTime();
categories.append("<category label='Java' />");
dataset1.append("<set value='" + stime + "'/>");
dataset2.append("<set value='" + dtime + "'/>");
dataset3.append("<set value='" + size + "'/>");
System.out.println("Java - " + "时间：" + stime + "|" + dtime + " 长度：" + size);
} catch (Exception e) {
System.out.println("Java 不支持该类型");
}
try {
PHPSerializer formator1 = new PHPSerializer();
byte[] b = formator1.serialize(data);
size = b.length;
formator1.unserialize(b);
start = new Date();
for (int i = 0; i < times; i++) {
formator1.serialize(data);
}
end = new Date();
stime = end.getTime() - start.getTime();
start = new Date();
for (int i = 0; i < times; i++) {
formator1.unserialize(b);
}
end = new Date();
dtime = end.getTime() - start.getTime();
categories.append("<category label='PHPRPC' />");
dataset1.append("<set value='" + stime + "'/>");
dataset2.append("<set value='" + dtime + "'/>");
dataset3.append("<set value='" + size + "'/>");
System.out.println("PHPRPC - " + "时间：" + stime + "|" + dtime + " 长度：" + size);
} catch (Exception e) {
System.out.println("PHPRPC 不支持该类型");
}
try {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
HessianOutput oos = new HessianOutput(bos);
oos.writeObject(data);
oos.close();
byte[] b = bos.toByteArray();
size = b.length;
ByteArrayInputStream bis = new ByteArrayInputStream(b);
HessianInput ois = new HessianInput(bis);
ois.readObject();
ois.close();
start = new Date();
for (int i = 0; i < times; i++) {
bos = new ByteArrayOutputStream();
oos = new HessianOutput(bos);
oos.writeObject(data);
oos.close();
}
end = new Date();
stime = end.getTime() - start.getTime();
start = new Date();
for (int i = 0; i < times; i++) {
bis = new ByteArrayInputStream(b);
ois = new HessianInput(bis);
ois.readObject();
ois.close();
}
end = new Date();
dtime = end.getTime() - start.getTime();
categories.append("<category label='Hessian' />");
dataset1.append("<set value='" + stime + "'/>");
dataset2.append("<set value='" + dtime + "'/>");
dataset3.append("<set value='" + size + "'/>");
System.out.println("Hessian - " + "时间：" + stime + "|" + dtime + " 长度：" + size);
} catch (Exception e) {
System.out.println("Hessian 不支持该类型");
}
try {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
Hessian2StreamingOutput oos = new Hessian2StreamingOutput(bos);
oos.writeObject(data);
oos.close();
byte[] b = bos.toByteArray();
size = b.length;
ByteArrayInputStream bis = new ByteArrayInputStream(b);
Hessian2StreamingInput ois = new Hessian2StreamingInput(bis);
ois.readObject();
ois.close();
start = new Date();
for (int i = 0; i < times; i++) {
bos = new ByteArrayOutputStream();
oos = new Hessian2StreamingOutput(bos);
oos.writeObject(data);
oos.close();
}
end = new Date();
stime = end.getTime() - start.getTime();
start = new Date();
for (int i = 0; i < times; i++) {
bis = new ByteArrayInputStream(b);
ois = new Hessian2StreamingInput(bis);
ois.readObject();
ois.close();
}
end = new Date();
dtime = end.getTime() - start.getTime();
categories.append("<category label='Hessian2' />");
dataset1.append("<set value='" + stime + "'/>");
dataset2.append("<set value='" + dtime + "'/>");
dataset3.append("<set value='" + size + "'/>");
System.out.println("Hessian2 - " + "时间：" + stime + "|" + dtime + " 长度：" + size);
} catch (Exception e) {
System.out.println("Hessian2 不支持该类型");
}
try {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
BurlapOutput oos = new BurlapOutput(bos);
oos.writeObject(data);
oos.close();
byte[] b = bos.toByteArray();
size = b.length;
ByteArrayInputStream bis = new ByteArrayInputStream(b);
BurlapInput ois = new BurlapInput(bis);
ois.readObject();
ois.close();
start = new Date();
for (int i = 0; i < times; i++) {
bos = new ByteArrayOutputStream();
oos = new BurlapOutput(bos);
oos.writeObject(data);
oos.close();
}
end = new Date();
stime = end.getTime() - start.getTime();
start = new Date();
for (int i = 0; i < times; i++) {
bis = new ByteArrayInputStream(b);
ois = new BurlapInput(bis);
ois.readObject();
ois.close();
}
end = new Date();
dtime = end.getTime() - start.getTime();
categories.append("<category label='Burlap' />");
dataset1.append("<set value='" + stime + "'/>");
dataset2.append("<set value='" + dtime + "'/>");
dataset3.append("<set value='" + size + "'/>");
System.out.println("Burlap - " + "时间：" + stime + "|" + dtime + " 长度：" + size);
} catch (Exception e) {
System.out.println("Burlap 不支持该类型");
}
try {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
AMF3Serializer oos = new AMF3Serializer(bos);
oos.writeObject(data);
oos.close();
byte[] b = bos.toByteArray();
size = b.length;
ByteArrayInputStream bis = new ByteArrayInputStream(b);
AMF3Deserializer ois = new AMF3Deserializer(bis);
ois.readObject();
ois.close();
start = new Date();
for (int i = 0; i < times; i++) {
bos = new ByteArrayOutputStream();
oos = new AMF3Serializer(bos);
oos.writeObject(data);
oos.close();
}
end = new Date();
stime = end.getTime() - start.getTime();
start = new Date();
for (int i = 0; i < times; i++) {
bis = new ByteArrayInputStream(b);
ois = new AMF3Deserializer(bis);
ois.readObject();
ois.close();
}
end = new Date();
dtime = end.getTime() - start.getTime();
categories.append("<category label='AMF3' />");
dataset1.append("<set value='" + stime + "'/>");
dataset2.append("<set value='" + dtime + "'/>");
dataset3.append("<set value='" + size + "'/>");
System.out.println("AMF3 - " + "时间：" + stime + "|" + dtime + " 长度：" + size);
} catch (Exception e) {
System.out.println("AMF3 不支持该类型");
}
try {
JSON json = JSONSerializer.toJSON(data);
size = json.toString().getBytes("UTF-8").length;
JSONSerializer.toJava(json);
start = new Date();
for (int i = 0; i < times; i++) {
JSONSerializer.toJSON(data);
}
end = new Date();
stime = end.getTime() - start.getTime();
start = new Date();
for (int i = 0; i < times; i++) {
JSONSerializer.toJava(json);
}
end = new Date();
dtime = end.getTime() - start.getTime();
categories.append("<category label='json-lib' />");
dataset1.append("<set value='" + stime + "'/>");
dataset2.append("<set value='" + dtime + "'/>");
dataset3.append("<set value='" + size + "'/>");
System.out.println("json-lib - " + "时间：" + stime + "|" + dtime + " 长度：" + size);
}
catch (Exception e) {
System.out.println("json-lib 不支持该类型");
}
try {
String json = JSONUtil.serialize(data);
size = json.getBytes("UTF-8").length;
JSONUtil.deserialize(json);
start = new Date();
for (int i = 0; i < times; i++) {
JSONUtil.serialize(data);
}
end = new Date();
stime = end.getTime() - start.getTime();
start = new Date();
for (int i = 0; i < times; i++) {
JSONUtil.deserialize(json);
}
end = new Date();
dtime = end.getTime() - start.getTime();
categories.append("<category label='jsonplugin' />");
dataset1.append("<set value='" + stime + "'/>");
dataset2.append("<set value='" + dtime + "'/>");
dataset3.append("<set value='" + size + "'/>");
System.out.println("jsonplugin - " + "时间：" + stime + "|" + dtime + " 长度：" + size);
}
catch (Exception e) {
System.out.println("jsonplugin 不支持该类型");
}
// 以下被注释掉的是 XML 的测试内容，之所以注释掉是因为它太慢了。
// 如果您有足够耐心，可以取消掉注释，但不要怪我没提醒您。
/*
try {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
XMLEncoder oos = new XMLEncoder(bos);
oos.writeObject(data);
oos.close();
byte[] b = bos.toByteArray();
size = b.length;
ByteArrayInputStream bis = new ByteArrayInputStream(b);
XMLDecoder ois = new XMLDecoder(bis);
ois.readObject();
ois.close();
start = new Date();
for (int i = 0; i < times; i++) {
bos = new ByteArrayOutputStream();
oos = new XMLEncoder(bos);
oos.writeObject(data);
oos.close();
}
end = new Date();
stime = end.getTime() - start.getTime();
start = new Date();
for (int i = 0; i < times; i++) {
bis = new ByteArrayInputStream(b);
ois = new XMLDecoder(bis);
ois.readObject();
ois.close();
}
end = new Date();
dtime = end.getTime() - start.getTime();
categories.append("<category label='XML' />");
dataset1.append("<set value='" + stime + "'/>");
dataset2.append("<set value='" + dtime + "'/>");
dataset3.append("<set value='" + size + "'/>");
System.out.println("XML - " + "时间：" + stime + "|" + dtime + " 长度：" + size);
} catch (Exception e) {
System.out.println("XML 不支持该类型");
}
*/
categories.append("</categories>");
dataset1.append("</dataset>");
dataset2.append("</dataset>");
dataset3.append("</dataset>");
sb.append(categories);
sb.append(dataset1);
sb.append(dataset2);
sb.append(dataset3);
sb.append("</chart>");
FileWriter fw = new FileWriter(filename);
fw.write(sb.toString());
fw.close();
System.out.println("--------------------------------------------------------------------------------");
}
public static void main(String[] args) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, IOException, ClassNotFoundException {
runTest(20000, 12, "对整数12", "1.xml");
runTest(20000, true, "对布尔值true", "2.xml");
runTest(20000, null, "对 null", "3.xml");
runTest(20000, 1.2, "对浮点数1.2", "4.xml");
runTest(20000, 1234567890987654321L, "对UInt64型1234567890987654321", "5.xml");
runTest(20000, Double.POSITIVE_INFINITY, "对无穷大", "6.xml");
String s = "PHPRPC - perfect high performance remote procedure call";
runTest(20000, s, "对字符串“" + s + "”", "7.xml");
byte[] ba = new byte[10000];
for (int i = 0; i < 10000; i++) {
ba[i] = (byte) (i % 255);
}
runTest(2000, ba, "对10000个元素的字节数组", "8.xml");
String[] sa = new String[100];
for (int i = 0; i < 100; i++) {
sa[i] = s;
}
runTest(2000, sa, "对100个相同元素的字符串数组", "9.xml");
sa = new String[100];
for (int i = 0; i < 100; i++) {
sa[i] = s + i;
}
runTest(2000, sa, "对100个不同元素的字符串数组", "10.xml");
HashMap h = new HashMap();
for (int i = 0; i < 100; i++) {
h.put(s + i, s + (i + 100));
}
runTest(2000, h, "对索引不同内容不同具有100个字符串元素和字符串索引的 Hashtable", "11.xml");
TestClass tc = new TestClass();
tc.setId(1);
tc.setUserName("Ma Bingyao");
tc.setPassword("PHPRPC");
tc.setAge(28);
runTest(200000, tc, "对自定义类型对象", "12.xml");
}
}
发表评论
-
安装和使用memcached
2014-04-16 16:24 644如何将 memcached 融入到 ... -
applicationContext.xml
2013-08-09 09:05 948<?xml version="1.0&quo ... -
注释驱动的 Spring cache 缓存介绍
2013-08-08 07:04 665概述 Spring 3.1 引入了激动人心的基于注释（an ... -
Spring2.5 Annotations
2013-08-08 06:33 862完成setXxxx功能，即配置文件的 <propert ... -
Spring基于注解的缓存配置--EHCache AND OSCache
2013-08-07 23:21 1032本文将构建一个普通工程来说明spring注解缓存的使用方式， ... -
Ehcache 整合Spring 使用页面、对象缓存
2013-08-07 22:51 899Ehcache 整合Spring 使用页面、对象缓存 ... -
javassist教程和示例
2013-05-18 08:57 2014Javassist是一个执行字节 ... -
ZooKeeper官方文档
2013-05-16 17:09 1563介绍（源自ZooKeeper官方文档） 学习HBase过程 ... -
ZooKeeper -例子
2013-05-16 17:08 1217ZooKeeper ZooKeepe ... -
Spring整合Hessian访问远程服务
2013-05-15 13:44 860Spring整合Hessian访问远程服务 目录 1.1 ... -
redis
2013-05-14 11:44 773redis是一个key-value存储系统。和Memcach ... -
spring 资源访问
2013-05-13 08:26 1003spring在java基础上封装了资源访问，简单易用。 R ... -
ZooKeeper——入门
2013-05-08 16:12 913ZooKeeper——入门 博客分类： ZooK ... -
分布式服务框架 Zookeeper -- 管理分布式环境中的数据(IBM)
2013-05-08 14:07 788安装和配置详解 本文 ... -
分布式协调服务---Zookeeper
2013-05-08 14:05 7791、Zookeeper overview Zookee ... -
Hibernate
2013-03-28 13:04 927一、简述 Hibernate 和 JD ... -
Apache+Tomcat集群配置详解
2013-02-01 10:52 898Apache + Tomcat集群配置详解（1） 一、 ... -
Apache+Jboss集群基于反向代理的负载均衡
2013-02-01 10:40 2498假设三台机器IP分别为172.29.128.100、172. ... -
spring + ibatis 多数据源事务（分布式事务）管理配置方法
2012-12-17 15:18 1270spring + ibatis 多数据源事务（分布式事务 ... -
Hessian序列化不设SerializerFactory性能问题
2012-10-31 09:47 1504Hessian序列化不设SerializerFactor ...
相关推荐
java序列化与反序列化
### Java序列化与反序列化的深入解析 #### Java序列化的重要性及应用场景 Java序列化是一项核心功能，它允许程序员将对象的状态转化为字节流的形式，从而实现对象的持久化存储或者在网络之间进行传递。这对于诸如...
Java序列化与反序列化是Java编程中一个重要的概念，它允许我们将对象的状态转换为字节流，以便存储或在网络中传输。这个过程被称为序列化，而将字节流恢复为对象的过程则称为反序列化。Java提供了一个内置的机制来...
《Java 序列化与反序列化：基础与应用》
### Java序列化与反序列化详解 #### 一、Java序列化概述 Java序列化（Serialization）是一项重要的功能，它可以将对象的状态转化为一系列字节，从而实现对象的持久化存储或在网络上传输。序列化机制使得Java对象...
java 序列化和反序列化的方法 Java 序列化和反序列化是 Java 语言中的一种机制，用于将对象转换为字节流，以便在网络上传输或存储。序列化是将对象转换为字节流的过程，而反序列化是将字节流转换回对象的过程。 在...
Java对象的序列化和反序列化是Java编程中一项重要的技术，主要用于将对象的状态转换为字节流，以便存储或在网络上传输。这一过程对于理解Java的IO操作、持久化数据以及实现分布式通信等场景非常关键。 首先，我们来...
### Java序列化与反序列化的深入解析 #### 序列化的功能与意义 序列化是Java编程语言中的一项核心功能，其主要目的是将对象的状态转换为可以存储或传输的格式，便于持久化保存或网络传输。序列化并不涉及对象的...
java 序列化与反序列化的实例详解 Java 序列化与反序列化是 Java 编程语言中的一种机制，允许将 Java 对象转换为字节序列，并将其反序列化回 Java 对象。序列化是指将 Java 对象转换为字节序列的过程，而反序列化是...
Java的序列化与反序列化是Java开发中的一项重要技术，它允许我们将对象的状态转换为字节流，以便存储或在网络上传输。`Serializable`接口是Java提供的一个标记接口，用于实现对象的序列化。当一个类实现了这个接口，...
### Java序列化(Serializable)的作用与反序列化详解 #### 一、序列化的概念 序列化是指将程序中的对象转换为一系列字节流的过程，主要用于保存对象的状态或在网络之间传输对象。序列化的主要目的是为了能够持久化...
Java反序列化是一种将已序列化的对象状态转换回对象的过程，它是Java平台中持久化数据的一种常见方式。在Java应用程序中，序列化用于保存对象的状态以便稍后恢复，或者在网络间传输对象。然而，这个过程也可能引入...
Xson是一个Java对象序列化和反序列化程序。支持Java对象到字节数组的序列化，和从字节数组到Java对象的反序列化。 Maven: <groupId>com.github.xsonorg</groupId> <artifactId>xson-core <version>1.0.1 ...
本篇文章将深入探讨C#和Java中的序列化与反序列化机制。 首先，我们要了解什么是序列化。序列化是指将对象的状态转化为可存储或可传输的数据格式的过程。这个过程通常将内存中的对象转换成字节流，以便保存到磁盘、...
Java中的JSON（JavaScript Object Notation）序列化与反序列化是开发过程中常见且重要的操作，主要用于数据交换和存储。JSON是一种轻量级的数据交换格式，它允许我们将Java对象转换为JSON字符串，反之亦然，方便在...
Java 序列化与反序列化（Serialization）知识点总结 Java 序列化与反序列化是 Java 语言中的一种机制，用于将对象的状态信息转化为可以存储或者传输的形式的过程。序列化（Serialization）是将对象的状态信息转化为...