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");
}
}
199
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
