|| 原始类型 || 大小 ||
|  boolean |   1   |
|  byte    |   1   |
|  short   |   2   |
|  char    |   2   |
|  int     |   4   |
|  float   |   4   |
|  long    |   8   |
|  double  |   8   |

public class Demo {  
    private final long L = 0x7EFFFFFFFFL;  
    private final int I = 0x7FFFFF;  
    private final int J = 0x7EFFFF;  
}
// Demo的地址分配
0x00000007d569f1c8: 0x0000000000000001
0x00000007d569f1d0: 0x007fffffef650cc4
0x00000007d569f1d8: 0x0000007effffffff
0x00000007d569f1e0: 0x00000000007effff
// 对于Demo地址分配的解释(x86是小端模式:数据的低位保存在内存的低地址中)
_mark:             0x00000007d569f1c8: 0x0000000000000001
_compressed_klass: 0x00000007d569f1d0: 0xef650cc4
I:                 0x00000007d569f1d4: 0x007fffff        // gap填充
L:                 0x00000007d569f1d8: 0x0000007effffffff
J:                 0x00000007d569f1e0: 0x007effff
(padding):         0x00000007d569f1e4: 0x00000000

int o[] = {}  // 16(header) = 8(_mark) + 4(_compressed_klass) + 4(size)
byte[] o = {1, 2, 3, 4, 5};    // 24 = 16 + 1*5 + 3(padding)
object[] o = {new object()};   // 24 = 16 + 4*1 + 4(padding)

private final char value[];        // 一个数组的引用，4B
private int hash;                  // int 4B
private transient int hash32 = 0;  // int 4B

    /**
     * 判断该对象是否需要跳过计算
     *
     * @param obj
     * @param visited
     * @return
     */
    private static boolean skipObject(Object obj, Map<Object, Object> visited) {

        return null == obj ||               // null 直接跳过
                isSharedFlyweight(obj) ||   // 享元对象 跳过
                visited.containsKey(obj);   // 计算过的对象 跳过
    }
    /**
     * 计算栈顶元素大小
     *
     * @param stack   待计算对象栈
     * @param visited 已经计算过的对象
     * @return
     */
    private static long doSizeOf(Stack<Object> stack, Map<Object, Object> visited) {
        // 获取栈顶元素
        Object obj = stack.pop();
        // 如果该对象需要跳过计算，直接返回0
        if (skipObject(obj, visited)) {
            return 0;
        }
        // 先把该对象放到已经访问过的集合中
        visited.put(obj, null);
        // 计算这个对象的大小 (object header + primitive variables + member pointers)
        long result = SizeOf.sizeOf(obj);
        // 获取对象类型
        Class clazz = obj.getClass();
        // 如果该对象是数组类型，则还需要把数组元素压栈待计算, 然后返回
        if (clazz.isArray()) {
            // 如果该数组的元素的类型是原生类型，就不用压栈了(即使压栈，也因是skipObject而被忽略)
            if (!clazz.getComponentType().isPrimitive()) {
                int length = Array.getLength(obj);
                for (int i = 0; i < length; i++) {
                    stack.add(Array.get(obj, i));  // 数组元素压栈
                }
            }
        } else { // 即不是skipObject，也不是数组，那只能是普通对象了，则对该对象的成员变量进行处理
            while (clazz != null) {
                Field[] fields = clazz.getDeclaredFields();  // 获取所有成员
                for (Field field : fields) {
                    // 只将非static成员和非primitive成员压栈
                    if (!Modifier.isStatic(field.getModifiers()) && !field.getType().isPrimitive()) {
                        field.setAccessible(true);
                        try {
                            stack.add(field.get(obj));
                        } catch (IllegalAccessException ex) {
                            throw new RuntimeException(ex);
                        }
                    }
                }
                clazz = clazz.getSuperclass();  // 继续处理父类的成员
            }
        }
        return result;
    }

public class SizeOf {
    /**
     * JVM将在启动时通过{@link #premain}初始化此成员变量.
     */
    private static Instrumentation instrumentation;
    /**
     * JVM会调用该函数来初始化代理类
     *
     * @param agentArgs premain 函数得到的程序参数，随同 “–javaagent:”一起传入。
     *                  eg:java -javaagent:jar 文件的位置 [= 传入 premain 的参数 ]
     * @param inst      java.lang.instrument.Instrumentation 的实例，由 JVM 自动传入
     */
    public static void premain(String agentArgs, Instrumentation inst) {
        instrumentation = inst;
    }
    /**
     * 返回对象大小，不包括其成员变量所引用的对象
     *
     * @param object 需要计算大小的对象
     * @return 对象的大小
     * @see java.lang.instrument.Instrumentation#getObjectSize(Object objectToSize)
     */
    public static long sizeOf(Object object) {
        if (instrumentation == null)
            throw new IllegalStateException("Instrumentation is null");
        return instrumentation.getObjectSize(object);  // 通过Instrumentation的实现类计算
    }
    /**
     * 返回包含引用对象在内的大小(需要我们自己计算)
     *
     * @param obj 需要计算大小的对象
     * @return 对象的全部大小
     */
    public static long fullSizeOf(Object obj) { ... }
}