blocks|key|1779648|text|看看：http://www.javaworld.com/javaworld/javaqa/2003-12/02-qa-1226-sizeof.html|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1779649|想到的最接近的事情是序列化它并读取字节的num。|1779650|entityMap|0|LINK|mutability|MUTABLE|url|http://www.javaworld.com/javaworld/javaqa/2003-12/02-qa-1226-sizeof.html^0|3|20|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]]|C|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]]]

have a look at: <a href="http://www.javaworld.com/javaworld/javaqa/2003-12/02-qa-1226-sizeof.html" rel="nofollow">http://www.javaworld.com/javaworld/javaqa/2003-12/02-qa-1226-sizeof.html</a>

closest thing that comes to mind would be serializing it and reading the num of bytes

blocks|key|581064|text|可以使用ObjectOutputStream和ByteArrayOutputStream将对象转换为字节数组。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|581065|public+static+int+sizeof(Object+obj)+throws+IOException+{

++++ByteArrayOutputStream+byteOutputStream+=+new+ByteArrayOutputStream();
++++ObjectOutputStream+objectOutputStream+=+new+ObjectOutputStream(byteOutputStream);

++++objectOutputStream.writeObject(obj);
++++objectOutputStream.flush();
++++objectOutputStream.close();

++++return+byteOutputStream.toByteArray().length;
}|code-block|syntax|javascript|581066|我刚测试过这个。您要计算的对象的大小需要实现Serializable+(这意味着您可能必须将每个对象标记为这样简单地得到它的大小。可能不可取)。我编写了一个快速而肮脏的程序来测试这一点：|581067|import+java.io.ByteArrayOutputStream;
import+java.io.IOException;
import+java.io.ObjectOutputStream;
import+java.io.Serializable;

public+class+Sizeof+{

++++public+static+class+Person+implements+Serializable+{
++++++++private+String+name;
++++++++private+String+age;

++++++++public+Person(String+name,+String+age)+{
++++++++++++this.name+=+name;
++++++++++++this.age+=+age;
++++++++}

++++++++public+String+getName()+{
++++++++++++return+name;
++++++++}

++++++++public+void+setName(String+name)+{
++++++++++++this.name+=+name;
++++++++}

++++++++public+String+getAge()+{
++++++++++++return+age;
++++++++}

++++++++public+void+setAge(String+age)+{
++++++++++++this.age+=+age;
++++++++}
++++}

++++public+static+void+main(String[]+args)+{
++++++++Person+p1+=+new+Person("Alby",+"20");
++++++++Person+p2+=+new+Person("VeryLongName",+"100");
++++++++String+s1+=+"This+is+it";
++++++++String+s2+=+"This";

++++++++try+{
++++++++++++System.out.println("p1+"+%2B+sizeof(p1));
++++++++++++System.out.println("p2+"+%2B+sizeof(p2));
++++++++++++System.out.println("s1+"+%2B+sizeof(s1));
++++++++++++System.out.println("s2+"+%2B+sizeof(s2));+++++++++++++++++++++++++++++++++
++++++++}

++++++++catch(Exception+e)+{
++++++++++++e.printStackTrace();
++++++++}
++++}

++++public+static+int+sizeof(Object+obj)+throws+IOException+{

++++++++ByteArrayOutputStream+byteOutputStream+=+new+ByteArrayOutputStream();
++++++++ObjectOutputStream+objectOutputStream+=+new+ObjectOutputStream(byteOutputStream);

++++++++objectOutputStream.writeObject(obj);
++++++++objectOutputStream.flush();
++++++++objectOutputStream.close();

++++++++return+byteOutputStream.toByteArray().length;
++++}
}|581068|这给了我：|581069|p1+85
p2+94
s1+17
s2+11|581070|编辑|BOLD|581071|Stephen的回答强调了这种方法的一些注意事项。|581072|entityMap|0|LINK|mutability|MUTABLE|url|http://download.oracle.com/javase/6/docs/api/java/io/ObjectOutputStream.html|1|http://download.oracle.com/javase/6/docs/api/java/io/ByteArrayOutputStream.html|2|http://download.oracle.com/javase/6/docs/api/java/io/Serializable.html^0|4|I|N|L|4|I|0|N|L|1|0|0|M|C|M|C|2|0|0|0|0|0|2|0|0^^$0|@$1|2|3|4|5|6|7|19|8|@$9|1A|A|1B|B|C]|$9|1C|A|1D|B|C]]|D|@$9|1E|A|1F|1|1G]|$9|1H|A|1I|1|1J]]|E|$]]|$1|F|3|G|5|H|7|1K|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1L|8|@$9|1M|A|1N|B|C]]|D|@$9|1O|A|1P|1|1Q]]|E|$]]|$1|M|3|N|5|H|7|1R|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1S|8|@]|D|@]|E|$]]|$1|Q|3|R|5|H|7|1T|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|1U|8|@$9|1V|A|1W|B|U]]|D|@]|E|$]]|$1|V|3|W|5|6|7|1X|8|@]|D|@]|E|$]]|$1|X|3|-4|5|6|7|1Y|8|@]|D|@]|E|$]]]|Y|$Z|$5|10|11|12|E|$13|14]]|15|$5|10|11|12|E|$13|16]]|17|$5|10|11|12|E|$13|18]]]]

You can convert your object into a byte array using <a href="http://download.oracle.com/javase/6/docs/api/java/io/ObjectOutputStream.html" rel="noreferrer"><code>ObjectOutputStream</code></a> and <a href="http://download.oracle.com/javase/6/docs/api/java/io/ByteArrayOutputStream.html" rel="noreferrer"><code>ByteArrayOutputStream</code></a>:

<pre><code>public static int sizeof(Object obj) throws IOException {

 ByteArrayOutputStream byteOutputStream = new ByteArrayOutputStream();
 ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteOutputStream);

 objectOutputStream.writeObject(obj);
 objectOutputStream.flush();
 objectOutputStream.close();

 return byteOutputStream.toByteArray().length;
}
</code></pre>

I just tested this out. The object who's size you're trying to calculate, needs to implement <a href="http://download.oracle.com/javase/6/docs/api/java/io/Serializable.html" rel="noreferrer"><code>Serializable</code></a> (which means you may have to mark every object as such simply to get its size. Might not be desirable). I wrote a quick and dirty program to test this out:

<pre><code>import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class Sizeof {

 public static class Person implements Serializable {
 private String name;
 private String age;

 public Person(String name, String age) {
 this.name = name;
 this.age = age;
 }

 public String getName() {
 return name;
 }

 public void setName(String name) {
 this.name = name;
 }

 public String getAge() {
 return age;
 }

 public void setAge(String age) {
 this.age = age;
 }
 }

 public static void main(String[] args) {
 Person p1 = new Person("Alby", "20");
 Person p2 = new Person("VeryLongName", "100");
 String s1 = "This is it";
 String s2 = "This";

 try {
 System.out.println("p1 " + sizeof(p1));
 System.out.println("p2 " + sizeof(p2));
 System.out.println("s1 " + sizeof(s1));
 System.out.println("s2 " + sizeof(s2)); 
 }

 catch(Exception e) {
 e.printStackTrace();
 }
 }

 public static int sizeof(Object obj) throws IOException {

 ByteArrayOutputStream byteOutputStream = new ByteArrayOutputStream();
 ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteOutputStream);

 objectOutputStream.writeObject(obj);
 objectOutputStream.flush();
 objectOutputStream.close();

 return byteOutputStream.toByteArray().length;
 }
}
</code></pre>

Which gave me:

<pre><code>p1 85
p2 94
s1 17
s2 11
</code></pre>

EDIT

Stephen C's answer highlights some caveats with this method.

blocks|key|2134729|text|您可以将每个对象序列化为数组，并比较每个数组的长度。这不是很准确，在一般情况下，但往往给出一个很好的近似。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2134730|看看ObjectOutputStream+(可以用来序列化对象并将其转换为bytes)和ByteArrayOutputStream+(可以用来保存序列化的字节)。|2134731|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

You can serialise each object into arrays and compare the length of each array. This is not very accurate, in the general case, but often gives a good approximation. 

Have a look at ObjectOutputStream (which can be used to serialise an object and turn it into Bytes) and ByteArrayOutputStream (which can be used to hold the serialised bytes).

blocks|key|581131|text|我认为您没有太多的选择，只能修改代码，以便在运行时测量消息大小。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|581132|您只需序列化示例对象，并捕获和测量序列化的大小。这有以下问题：|581133|您永远无法确定这些对象是典型的。|unordered-list-item|581134|各种聚合效果意味着很难从消息组件对象的序列化大小中推断消息的大小。(例如，每次序列化只编码一次类签名。)|581135|这种方法没有告诉您不同消息类型的相对频率。|581136|如果您能够管理这一点，您将得到更准确的结果，如果您可以测量实际的消息。这很可能需要修改代理框架，以计数、度量和(理想情况下)将消息分类为不同类型。该框架可能已经有用于执行此操作的钩子。|581137|只要方法与物体的实际尺寸成比例，它就不一定是死气沉沉的准确的。例如，长度为4的字符串向量将报告为大于长度为5的字符串向量。|blockquote|581138|(我想你的意思是比.小。)|581139|您的示例说明了尝试估计序列化对象大小的问题之一。大小为4的Vector<String>的序列化可能会更小.或者更大..。大小为5的Vector<String>。它取决于字符串值的大小。此外，如果消息包含两个Vector<String>对象，则向量占用的序列化大小将小于两个向量单独序列化时的大小之和。|offset|length|style|CODE|581140|entityMap^0|0|0|0|0|0|0|0|0|T|E|1T|E|2V|E|0^^$0|@$1|2|3|4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|10|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|11|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|12|8|@]|9|@]|A|$]]|$1|I|3|J|5|F|7|13|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|14|8|@]|9|@]|A|$]]|$1|M|3|N|5|O|7|15|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|16|8|@]|9|@]|A|$]]|$1|R|3|S|5|6|7|17|8|@$T|18|U|19|V|W]|$T|1A|U|1B|V|W]|$T|1C|U|1D|V|W]]|9|@]|A|$]]|$1|X|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]]|Y|$]]

I don't think you've got much choice but to modify your code so that it measures the message sizes at runtime.

You could just serialize example objects and capture and measure the serialized size. This has the following problems:

<ul>
<li>You can never be sure that the objects are typical.</li>
<li>Various aggregation effects mean that it is hard to deduce the size of a message from the serialized size of its component objects. (For instance, class signatures are only encoded once per serialization.)</li>
<li>This approach tells you nothing about the relative frequency of different message types.</li>
</ul>

If you can manage this, you will get more accurate results if you can measure the actual messages. This would most likely entail modifying the agent framework to count, measure and (ideally) classify messages into different kinds. The framework might already have hooks for doing this.

<blockquote>
 The method doesn't have to be dead-on accurate, as long as it scales proportionally to the actual size of the object. E.g. a Vector of strings of length 4 will report as larger than a Vector of strings of length 5. 
</blockquote>

(I assume that you meant smaller than ...)

Your example illustrates one of the problems of trying to estimate serialized object sizes. A serialization of a <code>Vector&lt;String&gt;</code> of size 4 could be smaller ... or larger ... that a <code>Vector&lt;String&gt;</code> of size 5. It depends on what the String values are. Additionally, if a message contains two <code>Vector&lt;String&gt;</code> objects, the serialized size occupied by the vectors will be less that sum of the sizes of the two vectors when they are serialized separately.

blocks|key|2134801|text|在调查一个超过memcache大小的服务器错误时，我需要准确地检查每个memcache的写入。为了避免大对象的大字节数组的开销，我将OutputStream扩展为一个计数器：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2134802|public+class+CheckSerializedSize+extends+OutputStream+{

++++/**+Serialize+obj+and+count+the+bytes+*/
++++public+static+long+getSerializedSize(Serializable+obj)+{
++++++++try+{
++++++++++++CheckSerializedSize+counter+=+new+CheckSerializedSize();
++++++++++++ObjectOutputStream+objectOutputStream+=+new+ObjectOutputStream(counter);
++++++++++++objectOutputStream.writeObject(obj);
++++++++++++objectOutputStream.close();
++++++++++++return+counter.getNBytes();
++++++++}+catch+(Exception+e)+{
++++++++++++//+Serialization+failed
++++++++++++return+-1;
++++++++}
++++}

++++private+long+nBytes+=+0;

++++private+CheckSerializedSize()+{}

++++@Override
++++public+void+write(int+b)+throws+IOException+{
++++++++%2B%2BnBytes;
++++}

++++@Override
++++public+void+write(byte[]+b,+int+off,+int+len)+throws+IOException+{
++++++++nBytes+%2B=+len;
++++}

++++public+long+getNBytes()+{
++++++++return+nBytes;
++++}
}|code-block|syntax|javascript|2134803|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I needed to check this accurately per-memcache write while investigating a server bug where memcache sizes were exceeded. To avoid the overhead of a big byte array for large objects I extended OutputStream as a counter:

<pre><code>public class CheckSerializedSize extends OutputStream {

 /** Serialize obj and count the bytes */
 public static long getSerializedSize(Serializable obj) {
 try {
 CheckSerializedSize counter = new CheckSerializedSize();
 ObjectOutputStream objectOutputStream = new ObjectOutputStream(counter);
 objectOutputStream.writeObject(obj);
 objectOutputStream.close();
 return counter.getNBytes();
 } catch (Exception e) {
 // Serialization failed
 return -1;
 }
 }

 private long nBytes = 0;

 private CheckSerializedSize() {}

 @Override
 public void write(int b) throws IOException {
 ++nBytes;
 }

 @Override
 public void write(byte[] b, int off, int len) throws IOException {
 nBytes += len;
 }

 public long getNBytes() {
 return nBytes;
 }
}
</code></pre>

blocks|key|1779818|text|可以使用阿帕奇公域检查序列化过程后对象的大小，如下所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1779819|++++//+Create+serialize+objects.
++++final+List<String>+src+=+new+ArrayList<String>();
++++src.add("awsome");
++++src.add("stack");
++++src.add("overflow");

++++System.out.println(
++++++++++++"Size+after+serialization:"+%2B+SerializationUtils.serialize((Serializable)+src).length);|code-block|syntax|javascript|1779820|产出：|1779821|Size+after+serialization:86|1779822|entityMap|0|LINK|mutability|MUTABLE|url|https://commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/SerializationUtils.html#serialize-java.io.Serializable-^0|4|5|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|10|8|@]|9|@]|C|$G|H]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

You can check the size of object after serialization process using <a href="https://commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/SerializationUtils.html#serialize-java.io.Serializable-" rel="nofollow noreferrer">Apache Commons</a> as follows:

<pre class="lang-java prettyprint-override"><code> // Create serialize objects.
 final List&lt;String&gt; src = new ArrayList&lt;String&gt;();
 src.add("awsome");
 src.add("stack");
 src.add("overflow");

 System.out.println(
 "Size after serialization:" + SerializationUtils.serialize((Serializable) src).length);
</code></pre>

Output :

<pre class="lang-none prettyprint-override"><code>Size after serialization:86
</code></pre>

What syntax would I use to get the number of bytes representing a string and compare them to the number of bytes representing an <code>ArrayList</code> holding that string, for example?

I am using a multi-agent agent system to send objects via messages and I want to keep track of how much space each message takes up. The method doesn't have to be dead-on accurate, as long as it scales proportionally to the actual size of the object. E.g. a Vector of strings of length 4 will report as smaller than a Vector of strings of length 5.

How to get amount of serialized bytes representing a Java object?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

例如，我将使用什么语法来获取表示字符串的字节数，并将它们与表示保存该字符串的ArrayList的字节数进行比较？我正在使用一个多代理系统通过消息发送对象，我想要跟踪每条消息占用了多少空间。只要方法与物体的实际尺寸成比例，它就不一定是死气沉沉的准确的。例如，长度为4的字符串向量将报告为小于长度为5的字符串向量。

问如何获得表示Java对象的序列化字节数？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何获得表示Java对象的序列化字节数？EN