当使用JetBrains IntelliJ时，首先在|文件设置|构建，执行，部署|调试器中启用“附加内存代理”。

调试时，右键单击感兴趣的变量，选择“计算保留大小”:

使用java visual VM即可。

它具有分析和调试内存问题所需的一切。

它还有一个OQL(对象查询语言)控制台，可以让你做很多有用的事情，其中之一是sizeof(o)

我的答案是基于Nick提供的代码。该代码测量被序列化对象占用的字节总数。因此，这实际上衡量的是序列化的东西+普通对象的内存占用(只要序列化，例如int，你会看到序列化的字节总数不是4)。所以，如果你想获得对象使用的原始字节数，你需要修改一下代码。像这样:

import java.io.ByteArrayOutputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class ObjectSizeCalculator {
    private Object getFirstObjectReference(Object o) {
        String objectType = o.getClass().getTypeName();

        if (objectType.substring(objectType.length()-2).equals("[]")) {
            try {
                if (objectType.equals("java.lang.Object[]"))
                    return ((Object[])o)[0];
                else if (objectType.equals("int[]"))
                    return ((int[])o)[0];
                else
                    throw new RuntimeException("Not Implemented !");
            } catch (IndexOutOfBoundsException e) {
                return null;
            }
        }

        return o;
    } 

    public int getObjectSizeInBytes(Object o) {
        final String STRING_JAVA_TYPE_NAME = "java.lang.String";

        if (o == null)
            return 0;

        String objectType = o.getClass().getTypeName();
        boolean isArray = objectType.substring(objectType.length()-2).equals("[]");

        Object objRef = getFirstObjectReference(o);
        if (objRef != null && !(objRef instanceof Serializable))
            throw new RuntimeException("Object must be serializable for measuring it's memory footprint using this method !");

        try {
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(baos);
            oos.writeObject(o);
            oos.close();
            byte[] bytes = baos.toByteArray();

            for (int i = bytes.length - 1, j = 0; i != 0; i--, j++) {
                if (objectType != STRING_JAVA_TYPE_NAME) {
                    if (bytes[i] == 112)
                        if (isArray)
                            return j - 4;
                        else
                            return j;
                } else {
                    if (bytes[i] == 0)
                        return j - 1;
                }
            }
        } catch (Exception e) {
            return -1;
        }

        return -1;
    }    

}

我已经用基本类型String和一些普通类测试了这个解决方案。可能也有不包括在内的情况。

更新:示例修改为支持数组对象的内存占用计算。

您必须使用工具来测量它，或者手工估计它，这取决于您正在使用的JVM。

每个对象都有一些固定的开销。它是jvm特有的，但我通常估计有40个字节。然后你要看看这个班级的成员。对象引用在32位(64位)JVM中是4(8)个字节。基本类型是:

布尔值和字节:1字节 Char和short: 2字节 Int和float: 4字节 Long和double: 8字节

数组也遵循同样的规则;也就是说，它是一个对象引用，因此在对象中占用4(或8)个字节，然后它的长度乘以其元素的大小。

试图通过调用Runtime.freeMemory()以编程方式来实现这一点并不能提供很高的准确性，因为对垃圾收集器的异步调用等等。使用-Xrunhprof或其他工具对堆进行分析将为您提供最准确的结果。

long heapSizeBefore = Runtime.getRuntime().totalMemory();

// Code for object construction
...
long heapSizeAfter = Runtime.getRuntime().totalMemory();
long size = heapSizeAfter - heapSizeBefore;

大小提供了由于创建对象而增加的JVM内存使用，通常是对象的大小。

你必须利用反射在物体上行走。做的时候要小心:

仅仅分配一个对象在JVM中就有一些开销。这个量因JVM而异，所以可以将此值作为参数。至少让它成为一个常量(8字节?)，并应用于分配的任何东西。 仅仅因为一个字节理论上是1个字节，并不意味着内存中只需要一个字节。 在对象引用中会有循环，因此您需要使用object-equals作为比较器来保留HashMap或类似的东西，以消除无限循环。

@jodonnell:我喜欢你的解决方案的简单性，但许多对象是不可序列化的(所以这将抛出一个异常)，字段可以是暂时的，对象可以覆盖标准方法。