假设我声明了一个名为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

可以使用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

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

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

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

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

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

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

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

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

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

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

如果您的应用程序有Apache公共lang库作为依赖项，或者正在使用Spring框架，那么您还可以使用SerializationUtils类快速查找任何给定对象的大约字节大小。

byte[] data = SerializationUtils.serialize(user);
System.out.println("Approximate object size in bytes " + data.length);