blocks|key|1686313|text|在选择下一步要调用哪个类/writeObject/readObject时，仍然有些头脑发热。但它明显减少了。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1686314|这可以执行与Externalizable相同的操作，这取决于您正在做什么，以及您是否使用它提供的额外选项。例如，readObject假设您每次创建一个新对象，Externalizable有readResolve，这意味着您可以重用对象。|1686315|http://docs.oracle.com/javase/1.5.0/docs/guide/serialization/spec/input.html|offset|length|1686316|在许多情况下，回收对象是加快反序列化的“下一步”。(假设这是你的选择)|1686317|http://vanillajava.blogspot.co.uk/2011/10/recycling-objects-to-improve.html|1686318|entityMap|0|LINK|mutability|MUTABLE|url|1^0|0|0|0|24|0|0|0|0|23|1|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|U|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|V|8|@]|9|@$F|W|G|X|1|Y]]|A|$]]|$1|H|3|I|5|6|7|Z|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|10|8|@]|9|@$F|11|G|12|1|13]]|A|$]]|$1|L|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|M|$N|$5|O|P|Q|A|$R|E]]|S|$5|O|P|Q|A|$R|K]]]]

There is still some over head in choosing which class/writeObject/readObject to call next. but it is significantly reduced.

This can perform the same as Externalizable depending on what you are doing and whether you use the extra options it gives you. e.g. readObject assumes you to create a new object each time, Externalizable has readResolve which means you can reuse objects.

<a href="http://docs.oracle.com/javase/1.5.0/docs/guide/serialization/spec/input.html" rel="noreferrer">http://docs.oracle.com/javase/1.5.0/docs/guide/serialization/spec/input.html</a>

In many cases, recycling objects is the "next" step in speeding up deserialization. (Assuming that's an option for you)

<a href="http://vanillajava.blogspot.co.uk/2011/10/recycling-objects-to-improve.html" rel="noreferrer">http://vanillajava.blogspot.co.uk/2011/10/recycling-objects-to-improve.html</a>

blocks|key|2563369|text|在实验和遍历序列化机制的代码时，发现了一些东西：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2563370|1)如果发现该对象是Externalizable，则将其强制转换为Externalizable，并在其上调用相应的方法；而对于可序列化对象，则会对它是否具有readObject/writeObject进行反射检查。所以也许这会让它慢一点，|2563371|2)为Externalizable编写的数据量略小于readObject/writeObject可序列化的数据量(我在编写B对象时发现以下代码的差异为1字节)。|2563372|对于Externalizable：|2563373|static+class+A+implements+Externalizable
{
++++@Override
++++public+void+writeExternal(ObjectOutput+out)+throws+IOException+
++++{
++++++++System.out.println("A+write+called");
++++}

++++@Override
++++public+void+readExternal(ObjectInput+in)+throws+IOException,+ClassNotFoundException+
++++{
++++++++System.out.println("A+read+called");
++++}+++++++
}

static+class+B+extends+A+implements+Externalizable
{+++++++
++++@Override
++++public+void+writeExternal(ObjectOutput+out)+throws+IOException+
++++{
++++++++super.writeExternal(out);
++++++++System.out.println("B+write+called");
++++}

++++@Override
++++public+void+readExternal(ObjectInput+in)+throws+IOException,+ClassNotFoundException+
++++{
++++++++super.readExternal(in);
++++++++System.out.println("B+read+called");
++++}+++++++
}|code-block|syntax|javascript|2563374|可序列化：|2563375|static+class+A+implements+Serializable
{
++++private+void+writeObject(ObjectOutputStream+out)+throws+IOException+
++++{
++++++++System.out.println("A+write+called");
++++}

++++private+void+readObject(ObjectInputStream+in)+throws+IOException,+ClassNotFoundException+
++++{
++++++++System.out.println("A+read+called");
++++}+++++++
}

static+class+B+extends+A+implements+Serializable
{+++++++
++++private+void+writeObject(ObjectOutputStream+out)+throws+IOException+
++++{+++++++++++
++++++++System.out.println("B+write+called");
++++}

++++private+void+readObject(ObjectInputStream+in)+throws+IOException,+ClassNotFoundException+
++++{+++++++++++
++++++++System.out.println("B+read+called");
++++}+++++++
}|2563376|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|U|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|V|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|W|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|Y|8|@]|9|@]|A|$K|L]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

Found a couple of things while experimenting and going through serialization mechanism's code:

1) if the object is found to be Externalizable, it's cast to Externalizable, and corresponding method is called on it; whereas for Serializable object, it's reflectively checked if it has readObject/writeObject. So maybe this makes it slightly slower,

2) the amount of data written for Externalizable is a little less than Serializable with readObject/writeObject (I found a difference of 1 byte for the following code when I wrote object of B).

For Externalizable:

<pre><code>static class A implements Externalizable
{
 @Override
 public void writeExternal(ObjectOutput out) throws IOException 
 {
 System.out.println("A write called");
 }

 @Override
 public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException 
 {
 System.out.println("A read called");
 } 
}

static class B extends A implements Externalizable
{ 
 @Override
 public void writeExternal(ObjectOutput out) throws IOException 
 {
 super.writeExternal(out);
 System.out.println("B write called");
 }

 @Override
 public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException 
 {
 super.readExternal(in);
 System.out.println("B read called");
 } 
}
</code></pre>

For Serializable:

<pre><code>static class A implements Serializable
{
 private void writeObject(ObjectOutputStream out) throws IOException 
 {
 System.out.println("A write called");
 }

 private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException 
 {
 System.out.println("A read called");
 } 
}

static class B extends A implements Serializable
{ 
 private void writeObject(ObjectOutputStream out) throws IOException 
 { 
 System.out.println("B write called");
 }

 private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException 
 { 
 System.out.println("B read called");
 } 
}
</code></pre>

blocks|key|1714703|text|在类设计方面，Serializable的主要区别在于，任何类都可以使用Externalizable，而Externalizable只适用于具有公共默认(No)构造函数的可变类。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1714704|entityMap^0|7|C|Z|E|1F|E|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|O|8|@]|D|@]|E|$]]]|G|$]]

The major difference, in terms of class design, is that <code>Serializable</code> will work on any class, whereas <code>Externalizable</code> only works on mutable classes with public default (no-arg) constructors.

It's said that Java's default serialization mechanism is not very efficient because a)it discovers which fields to write/read through reflection which is usually slow b) it writes extra data to stream.

One way to make it more efficient is to implement Externalizable and its writeExternal/readExternal methods.

Here's the question: if I instead provide 'writeObject/readObject' methods and don't call deafiltWriteObject/defaultReadObject in them, then this mechanism won't use reflection to figure out which fields to write/read, plus it won't write extra data to stream (or will it? not sure). So from an efficiency perspective, is implementing writeObject/readObject mentioned above same as implementing Externalizable? Or does the latter option give some more practical benefits which the former doesn't?

EDIT: a difference, ofcourse, is when a Serializable class implementing readObject/writeObject is subclassed, and if the subclass has its own readObject/writeObject, they don't need to call super's readObject/writeObject. Not so if the super/subclass instead implement Externalizable. In this case, super's writeExternal/readExternal need to be explicitly called. However, this difference is irrelevant from an efficiency point of view.

Java: efficiency of writeObject vs writeExternal

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

据说Java的默认序列化机制效率不高，因为(A)它发现要通过反射写入/读取哪些字段，这通常比较慢( b)它将额外的数据写入流。使其更有效的一种方法是实现Externalizable及其写外部/readExternal方法。这里有一个问题:如果我提供'writeObject/readObject‘方法，而不是在其中调用d...

问Java: writeObject与writeExternal的效率
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java: writeObject与writeExternal的效率EN