没有方法调用，如果这是你想要的。只要稍加研究，我想你就可以自己写了。一个特定的实例具有一个固定的大小，该大小来自引用和原语值的数量以及实例簿记数据。您可以简单地遍历对象图。行类型变化越少，越容易。

如果这太慢或者麻烦太多，总有好的老式的行计数经验法则。

没有方法调用，如果这是你想要的。只要稍加研究，我想你就可以自己写了。一个特定的实例具有一个固定的大小，该大小来自引用和原语值的数量以及实例簿记数据。您可以简单地遍历对象图。行类型变化越少，越容易。

如果这太慢或者麻烦太多，总有好的老式的行计数经验法则。

当我在Twitter工作时，我写了一个计算深度对象大小的实用程序。它考虑了不同的内存模型(32位，压缩oops, 64位)，填充，子类填充，在循环数据结构和数组上正确工作。你可以编译这个。java文件;它没有外部依赖:

https://github.com/twitter/commons/blob/master/src/java/com/twitter/common/objectsize/ObjectSizeCalculator.java

我曾经写过一个快速测试来进行评估:

public class Test1 {

    // non-static nested
    class Nested { }

    // static nested
    static class StaticNested { }

    static long getFreeMemory () {
        // waits for free memory measurement to stabilize
        long init = Runtime.getRuntime().freeMemory(), init2;
        int count = 0;
        do {
            System.out.println("waiting..." + init);
            System.gc();
            try { Thread.sleep(250); } catch (Exception x) { }
            init2 = init;
            init = Runtime.getRuntime().freeMemory();
            if (init == init2) ++ count; else count = 0;
        } while (count < 5);
        System.out.println("ok..." + init);
        return init;
    }

    Test1 () throws InterruptedException {

        Object[] s = new Object[10000];
        Object[] n = new Object[10000];
        Object[] t = new Object[10000];

        long init = getFreeMemory();

        //for (int j = 0; j < 10000; ++ j)
        //    s[j] = new Separate();

        long afters = getFreeMemory();

        for (int j = 0; j < 10000; ++ j)
            n[j] = new Nested();

        long aftersn = getFreeMemory();

        for (int j = 0; j < 10000; ++ j)
            t[j] = new StaticNested();

        long aftersnt = getFreeMemory();

        System.out.println("separate:      " + -(afters - init) + " each=" + -(afters - init) / 10000);
        System.out.println("nested:        " + -(aftersn - afters) + " each=" + -(aftersn - afters) / 10000);
        System.out.println("static nested: " + -(aftersnt - aftersn) + " each=" + -(aftersnt - aftersn) / 10000);

    }

    public static void main (String[] args) throws InterruptedException {
        new Test1();
    }

}

一般概念是分配对象并测量空闲堆空间的变化。键是getFreeMemory()，它请求GC运行并等待报告的空闲堆大小稳定下来。上面的输出是:

nested:        160000 each=16
static nested: 160000 each=16

考虑到对齐行为和可能的堆块报头开销，这正是我们所期望的。

仪器仪表方法详细在这里接受的答案是最准确的。我描述的方法是准确的，但只有在受控条件下，即没有其他线程创建/丢弃对象。

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

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

首先，“对象的大小”在Java中并不是一个定义明确的概念。你可以指对象本身，包括它的成员、对象和它引用的所有对象(引用图)。您可以指内存中的大小或磁盘上的大小。JVM可以优化字符串之类的东西。

所以唯一正确的方法是用一个好的分析器(我使用YourKit)询问JVM，这可能不是你想要的。

然而，从上面的描述来看，似乎每一行都是自包含的，没有很大的依赖树，因此序列化方法在大多数jvm上可能是一个很好的近似方法。最简单的方法如下:

 Serializable ser;
 ByteArrayOutputStream baos = new ByteArrayOutputStream();
 ObjectOutputStream oos = new ObjectOutputStream(baos);
 oos.writeObject(ser);
 oos.close();
 return baos.size();

请记住，如果对象具有公共引用，这将不会给出正确的结果，并且序列化的大小并不总是与内存中的大小匹配，但这是一个很好的近似值。如果您将ByteArrayOutputStream大小初始化为一个合理的值，代码将会更有效。