您可以生成一个堆转储(例如，使用jmap)，然后分析输出以查找对象大小。这是一种离线解决方案，但是您可以检查浅尺寸和深尺寸等。

可以使用java.lang.instrument包。

编译并将这个类放入JAR:

import java.lang.instrument.Instrumentation;

public class ObjectSizeFetcher {
    private static Instrumentation instrumentation;

    public static void premain(String args, Instrumentation inst) {
        instrumentation = inst;
    }

    public static long getObjectSize(Object o) {
        return instrumentation.getObjectSize(o);
    }
}

将以下内容添加到您的清单中。MF:

Premain-Class: ObjectSizeFetcher

使用getObjectSize()方法:

public class C {
    private int x;
    private int y;

    public static void main(String [] args) {
        System.out.println(ObjectSizeFetcher.getObjectSize(new C()));
    }
}

调用:

java -javaagent:ObjectSizeFetcherAgent.jar C

几年前，Javaworld有一篇关于确定组合和潜在嵌套Java对象大小的文章，他们基本上介绍了如何在Java中创建sizeof()实现。这种方法基本上建立在其他工作的基础上，在这些工作中，人们通过实验确定了原语和典型Java对象的大小，然后将该知识应用于递归地遍历对象图以计算总大小的方法。

它总是比原生C实现更不准确，这仅仅是因为类背后发生的事情，但它应该是一个很好的指示器。

另外一个SourceForge项目被适当地称为sizeof，它提供了一个带有sizeof()实现的Java5库。

附注:不要使用序列化方法，序列化对象的大小和它在运行时所消耗的内存量之间没有相关性。

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

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

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

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

许多其他答案提供了浅的大小——例如，没有任何键或值的HashMap的大小，这可能不是您想要的。

jamm项目使用上面的java.lang.instrumentation包，但是遍历树，因此可以为您提供深层内存使用。

new MemoryMeter().measureDeep(myHashMap);

https://github.com/jbellis/jamm

要使用MemoryMeter，请使用“-javaagent:/jam .jar”启动JVM

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

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