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

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

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

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

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

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

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

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

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

我的答案是基于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和一些普通类测试了这个解决方案。可能也有不包括在内的情况。

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

我偶然发现了一个java类 "jdk.nashorn.internal.ir.debug. objectsizecalculator "，已经在jdk中， 这很容易使用，似乎对确定物体的大小非常有用。

System.out.println(ObjectSizeCalculator.getObjectSize(new gnu.trove.map.hash.TObjectIntHashMap<String>(12000, 0.6f, -1)));
System.out.println(ObjectSizeCalculator.getObjectSize(new HashMap<String, Integer>(100000)));
System.out.println(ObjectSizeCalculator.getObjectSize(3));
System.out.println(ObjectSizeCalculator.getObjectSize(new int[]{1, 2, 3, 4, 5, 6, 7 }));
System.out.println(ObjectSizeCalculator.getObjectSize(new int[100]));

结果:

164192
48
16
48
416

我正在寻找一个对象大小的运行时计算，满足以下要求:

在运行时可用，不需要包括插装。 使用Java 9+，无需访问Unsafe。 仅基于类。不是考虑字符串长度，数组长度等的深度sizeOf。

以下内容基于java专家的原始文章(https://www.javaspecialists.eu/archive/Issue078.html)的核心代码，以及不安全版本中对这个问题的另一个回答中的一些内容。

我希望有人觉得它有用。

public class JavaSize {

    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 HEADER_SIZE = 8;

    public static int sizeOf(Class<?> clazz) {
        int result = 0;

        while (clazz != null) {
            Field[] fields = clazz.getDeclaredFields();
            for (int i = 0; i < fields.length; i++) {
                if (!Modifier.isStatic(fields[i].getModifiers())) {
                    if (fields[i].getType().isPrimitive()) {
                        Class<?> primitiveClass = fields[i].getType();
                        if (primitiveClass == boolean.class || primitiveClass == byte.class) {
                            result += 1;
                        } else if (primitiveClass == short.class) {
                            result += 2;
                        } else if (primitiveClass == int.class || primitiveClass == float.class) {
                            result += 4;
                        } else if (primitiveClass == double.class || primitiveClass == long.class) {
                            result += 8;
                        }

                    } else {
                        // assume compressed references.
                        result += 4;
                    }
                }
            }

            clazz = clazz.getSuperclass();

            // round up to the nearest WORD length.
            if ((result % WORD) != 0) {
                result += WORD - (result % WORD);
            }
        }

        result += HEADER_SIZE;

        return result;
    }
 }