（一）序列化作用：

把内存中的对象转化为另一种形式，以供传输或存储。

（二）序列化前提：

（1）要序列化对象必须是可序列化的，即必须实现 Serializable 接口。

（2）要序列化对象的属性也都是可序列化的。

（3）要序列化对象引用的对象也必须是可序列化的，如：要序列化一个 HashMap 实例，需要把放入到HashMap中的对象也都序列化。

（4）要序列化一个内部类，该内部类必须可序列化，并且外部类也必须可序列化。

（5）基本数据类型都是可以序列化的。

（三）序列化举例：

下面是一个User类，演示了把一个User实例写入文件，然后在再文件中读出。

Java代码

1. package serialize;

2.

3. import java.io.FileInputStream;

4. import java.io.FileOutputStream;

5. import java.io.IOException;

6. import java.io.ObjectInputStream;

7. import java.io.ObjectOutputStream;

8. import java.io.Serializable;

9.

10. public class User implements Serializable {

11. private static final long serialVersionUID = 2143L;

12.

13. private String name;

14. private int age;

15.

16. public String getName() {

17. return name;

18. }

19.

20. public void setName(String name) {

21. this.name = name;

22. }

23.

24. public int getAge() {

25. return age;

26. }

27.

28. public void setAge(int age) {

29. this.age = age;

30. }

31.

32. public User(String name, int age) {

33. this.name = name;

34. this.age = age;

35. }

36.

37. /**

38. * @todo 将一个可以序列化的对象写入文件

39. * @param obj

40. * 要保存的对象

41. * @param fileName

42. * 目标文件

43. */

44. public void writeToFile(Object obj, String fileName) {

45. ObjectOutputStream oos = null;

46. FileOutputStream fos = null;

47. try {

48. fos = new FileOutputStream(fileName);

49. oos = new ObjectOutputStream(fos);

50. oos.writeObject(obj);

51. oos.flush();

52. System.out.println("write ok!");

53. } catch (Exception e) {

54. System.out.println("write false! The error : " + e.getStackTrace());

55.

56. } finally {

57. //关闭文件流

58. try {

59. if (oos != null) {

60. oos.close();

61. }

62. if(fos != null){

63. fos.close();

64. }

65. } catch (IOException e) {

66. System.out.println("close flus false! The error : " + e.getStackTrace());

67. }

68. }

69. }

70.

71. /**

72. * @param fileName

73. * 保存对象的文件

74. * @return 从文件中得到的对象

75. */

76. public Object getObjFromFile(String fileName) {

77. Object obj = null;

78. FileInputStream fis = null;

79. ObjectInputStream ois = null;

80. try {

81. fis = new FileInputStream(fileName);

82. ois = new ObjectInputStream(fis);

83. obj = ois.readObject();

84. ois.close();

85. System.out.println("read ok!");

86. } catch (Exception e) {

87. e.printStackTrace();

88. } finally {

89. //关闭文件流

90. try {

91. if (ois != null) {

92. ois.close();

93. }

94. if(fis != null){

95. fis.close();

96. }

97. } catch (IOException e) {

98. System.out.println("close flus false! The error : " + e.getStackTrace());

99. }

100. }

101. return obj;

102. }

103.

104. public static void main(String[] args) {

105.

106. String fileName = "c://user.txt"; // 保存对象的文件

107. User user = new User("@pony", 28); // 创建一个User对象

108. user.writeToFile(user, fileName); // 将对象写入文件

109. User u = (User) (user.getObjFromFile(fileName)); // 从文件中取得对象

110. // 输出对象名

111. if (u != null)

112. System.out.println("ok, get the user object from the file. /nThe user's name is : " + u.name);

113. }

114.

115. }

看过该Java开发的还看过

• Java实现序列化作用及实例

本文标题：Java实现序列化作用及实例，责任编辑：宏鹏，来源：武汉北大青鸟鲁广校区栏目，于2013-02-20 10:19:58发布于北大青鸟鲁广校区。序列化作用：把内存中的对象转化为另一种形式，以供传输或存储。