instrumentation类提供了一种获取Java对象大小的好方法，但它要求您定义一个premain并使用Java代理运行程序。当您不需要任何代理，而又必须为应用程序提供一个虚拟Jar代理时，这是非常无聊的。

所以我使用sun.misc中的Unsafe类获得了一个替代解决方案。因此，根据处理器架构考虑对象堆对齐并计算最大字段偏移量，就可以测量Java对象的大小。在下面的例子中，我使用了一个辅助类UtilUnsafe来获取sun.misc.Unsafe对象的引用。

private static final int NR_BITS = Integer.valueOf(System.getProperty("sun.arch.data.model"));
private static final int BYTE = 8;
private static final int WORD = NR_BITS/BYTE;
private static final int MIN_SIZE = 16; 

public static int sizeOf(Class src){
    //
    // Get the instance fields of src class
    // 
    List<Field> instanceFields = new LinkedList<Field>();
    do{
        if(src == Object.class) return MIN_SIZE;
        for (Field f : src.getDeclaredFields()) {
            if((f.getModifiers() & Modifier.STATIC) == 0){
                instanceFields.add(f);
            }
        }
        src = src.getSuperclass();
    }while(instanceFields.isEmpty());
    //
    // Get the field with the maximum offset
    //  
    long maxOffset = 0;
    for (Field f : instanceFields) {
        long offset = UtilUnsafe.UNSAFE.objectFieldOffset(f);
        if(offset > maxOffset) maxOffset = offset; 
    }
    return  (((int)maxOffset/WORD) + 1)*WORD; 
}
class UtilUnsafe {
    public static final sun.misc.Unsafe UNSAFE;

    static {
        Object theUnsafe = null;
        Exception exception = null;
        try {
            Class<?> uc = Class.forName("sun.misc.Unsafe");
            Field f = uc.getDeclaredField("theUnsafe");
            f.setAccessible(true);
            theUnsafe = f.get(uc);
        } catch (Exception e) { exception = e; }
        UNSAFE = (sun.misc.Unsafe) theUnsafe;
        if (UNSAFE == null) throw new Error("Could not obtain access to sun.misc.Unsafe", exception);
    }
    private UtilUnsafe() { }
}

我怀疑您是否希望以编程方式完成它，除非您只是想执行一次并将其存储起来以供将来使用。这是一件代价高昂的事情。在Java中没有sizeof()操作符，即使有，它也只会计算引用其他对象的代价和原语的大小。

你可以这样做的一种方法是将它序列化到File中，然后查看文件的大小，就像这样:

Serializable myObject;
ObjectOutputStream oos = new ObjectOutputStream (new FileOutputStream ("obj.ser"));
oos.write (myObject);
oos.close ();

当然，这假设每个对象都是不同的，并且不包含对其他任何对象的非瞬时引用。

另一种策略是获取每个对象并通过反射检查其成员，并将大小相加(boolean & byte = 1字节，short & char = 2字节，等等)，沿着成员层次结构向下工作。但这既乏味又昂贵，而且最终与序列化策略所做的事情相同。

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

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

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

假设我声明了一个名为Complex的类:

public class Complex {

    private final long real;
    private final long imaginary;

    // omitted
}

为了查看这个类的活动实例被分配了多少内存:

$ jmap -histo:live <pid> | grep Complex

 num     #instances         #bytes  class name (module)
-------------------------------------------------------
 327:             1             32  Complex

还有内存测量器工具(以前在谷歌Code，现在在GitHub上)，它很简单，在商业友好的Apache 2.0许可下发布，就像在类似的问题中讨论的那样。

如果您想测量内存字节消耗，它也需要一个java解释器的命令行参数，但在其他方面似乎工作得很好，至少在我使用它的场景中是这样。