爪哇序列化面试问答
序列化是Java中最重要的概念之一。如果您要面对核心Java面试，那么可能会从序列化中询问您一些问题。
爪哇序列化教程：
以下是序列化可能会问的问题列表。
问题1：什么是序列化？
爪哇提供了一种称为序列化的机制，以包含对象的字节序或有序序列的形式持久化Java对象’的数据以及有关对象的信息’类型和存储在对象中的数据类型。因此，如果我们需要序列化任何对象，则可以使用对象对其进行读取和反序列化’的类型和其他信息，以便我们可以检索原始对象。类ObjectInputStream和ObjectOutputStream是高级流，其中包含用于序列化和反序列化对象的方法。
对象输出Stream有许多方法可以序列化对象，但常用的方法是
|
1 2 3 4 5 6 |
私人的 虚空 writeObject(对象输出Stream 操作系统) 抛出 IOException { } |
同样，ObjectInputStream具有
|
1 2 3 4 5 6 |
私人的 虚空 readObject(对象输入Stream 是) 抛出 IOException, ClassNotFoundException { } |
问题2：需要序列化吗？
回答：
序列化通常用于需要通过网络发送数据或存储在文件中的情况。数据是对象，而不是文本。
现在的问题是您的网络基础结构，硬盘是可以理解位和字节但不能理解Java对象的硬件组件。
序列化是Java对象的翻译’s的值/状态转换为字节以通过网络发送或保存它。另一方面，反序列化是将字节码转换为相应的java对象。
问题3：您能解释一下serialVersionUID的概念吗？
回答：
serialVersionUID用于确保在反序列化期间加载相同的类（在序列化期间使用的类）。serialVersionUID用于对象的版本控制。有关更多信息，请参见 爪哇序列化中的serialVersionUID
问题4：如果要序列化任何对象，是否有必要实现Serializable接口？
回答：
是的，如果要序列化任何对象，则必须实现Serializable接口。可序列化是标记接口。Java中的标记接口是没有字段或方法的接口，或者在Java中简单单词为空的接口称为标记接口。
问题5：您可以序列化静态变量吗？
答：
不可以’t。如您所知，静态变量在类级别而不在对象级别，因此您可以序列化一个对象，这样您就可以’t序列化静态变量。
问题6：如何自定义序列化过程？
答：
您可以通过定义writeObject和readObject方法来自定义序列化过程。Java序列化提供了一种机制，如果您具有带有特定签名的私有方法，则在序列化和反序列化过程中将调用它们，因此，我们可以自定义序列化过程。
例如：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
私人的 虚空 writeObject(对象输出Stream 操作系统) 抛出 IOException, ClassNotFoundException { 尝试 { 操作系统.defaultWriteObject(); 操作系统.writeInt(地址.getHomeNo()); 操作系统.writeObject(地址.getStreet()); 操作系统.writeObject(地址.getCity()); } 抓住 (例外 e) { e.printStackTrace(); } } 私人的 虚空 readObject(对象输入Stream 是) 抛出 IOException, ClassNotFoundException { 尝试 { 是.defaultReadObject(); 整型 没有=是.readInt(); 串 街=(串) 是.readObject(); 串 市=(串) 是.readObject(); 地址=新 地址(没有,街,市); } |
应该记住的一点是，ObjectInputStream应该以我们将数据写入ObjectOutputStream的相同顺序读取数据。
问题7：如何避免类的某些成员变量被序列化？
回答：
You can mark that variable as either 静态的 or 短暂的. 让’看一个使用瞬态变量的简单示例。
瞬态变量 是其值在执行期间未序列化的变量 序列化。反序列化时，将获得这些变量的默认值。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 |
包 组织.Arpit.爪哇2blog; 进口 爪哇.io.可序列化; 上市 类 国家 实施 可序列化 { 串 名称; 短暂的 长 人口; 上市 国家() { 超(); } 上市 国家(串 名称, 长 人口) { 超(); 这个.名称 = 名称; 这个.人口 = 人口; } 上市 串 getName() { 返回 名称; } 上市 虚空 setName(串 名称) { 这个.名称 = 名称; } 上市 长 getPopulation() { 返回 人口; } 上市 虚空 setPopulation(长 人口) { 这个.人口 = 人口; } } |
创造 序列化Main.java 如下：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
包 组织.Arpit.爪哇2blog; 进口 爪哇.io.FileOutputStream; 进口 爪哇.io.IOException; 进口 爪哇.io.对象输出Stream; 上市 类 SerializeMain { / ** * @作者Arpit Mandliya */ 上市 静态的 虚空 主要(串[] args) { 国家 印度 = 新 国家(); 印度.setName(“印度”); 印度.setPopulation(100000); 尝试 { FileOutputStream fileOut = 新 FileOutputStream(“ country.ser”); 对象输出Stream 外流 = 新 对象输出Stream(fileOut); 外流.writeObject(印度); 外流.关(); fileOut.关(); }抓住(IOException i) { i.printStackTrace(); } 系统.出.打印(“序列化”); } } |
当您运行上述程序时，将获得以下输出：
|
1 2 3 |
序列化 |
现在创建一个名为 DeserializeMain.java 如下：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 |
包 组织.Arpit.爪哇2blog; 进口 爪哇.io.FileInputStream; 进口 爪哇.io.IOException; 进口 爪哇.io.对象输入Stream; 上市 类 DeserializeMain { / ** * @作者Arpit Mandliya */ 上市 静态的 虚空 主要(串[] args) { 国家 印度 = 空值; 尝试 { FileInputStream fileIn =新 FileInputStream(“ country.ser”); 对象输入Stream 在 = 新 对象输入Stream(fileIn); 印度 = (国家) 在 .readObject(); 在 .关(); fileIn.关(); }抓住(IOException i) { i.printStackTrace(); 返回; }抓住(ClassNotFoundException c) { 系统.出.打印(“找不到国家班级”); c.printStackTrace(); 返回; } 系统.出.打印(“反序列化的国家...”); 系统.出.打印(“国家的名字 ： ” + 印度.getName()); 系统.出.打印(“人口：” + 印度.getPopulation()); } } |
当您运行上述程序时，将获得以下输出：
|
1 2 3 4 5 |
反序列化 国家... 国家 名称 : 印度 人口 : 0 |
如您在上面的示例中看到的，我们已将填充声明为瞬态，因此在反序列化之后，其值变为0（长整数的默认值）
问题8： 如果超类是可序列化的怎么办？这是否意味着子类可以自动序列化？
问题9： 如果超类是可序列化的，但您却不知道该怎么办’希望子类可序列化？
问题10：什么是可外部化的接口？
回答： 顾名思义，这是对序列化进行外部化。如果要自定义序列化机制，则可以使用它。它使用自定义的书面机制来执行对象的编组和解组.Externalizable接口扩展了Serializable接口。如果实现此接口，则需要重写以下方法。
|
1 2 3 4 5 6 7 8 9 10 11 |
@覆写 上市 虚空 readExternal(对象输入 arg0) 抛出 IOException,ClassNotFoundException { } @覆写 上市 虚空 writeExternal(对象输出 arg0) 抛出 IOException { } |
问题11：Java中的Serializable和Externalizable之间有什么区别？
答：
|
参数
|
可序列化
|
可外部化
|
|---|---|---|
|
标记界面
|
它是标记器界面。你不’不必提供任何方法的实现。
|
外部化不是标记接口，您必须重写writeExternal和readExternal方法。
|
|
控制
|
可序列化的接口对序列化过程的控制较少，可以选择重写readObject和writeObject。
|
可外部化的接口具有对序列化过程的更多控制，并且必须重写writeExternal和readExternal。
|
|
在Serializable接口的情况下，JVM使用反射来执行序列化，这很慢。
|
程序员必须实现readExternal和writeExternal方法，但相对而言会带来更好的性能
|
|
|
取代
|
不适用
|
如果您实现Externalizable接口并提供readExternal和writeExternal的实现，则它将取代该类中的readObject和writeObject方法。这是由于Externalizable扩展了Serializable接口。
|
|
反序列化期间调用的构造方法
|
反序列化过程中不会调用默认构造函数。
|
反序列化过程中将调用默认构造函数。
|
您可能还喜欢：
Comments
嗨Arpit，
您能否举例说明可外部化和可串行化接口之间的区别的最后一点