1. import java.lang.instrument.Instrumentation;
    2. import java.lang.reflect.Array;
    3. import java.lang.reflect.Field;
    4. import java.lang.reflect.Modifier;
    5. import java.util.ArrayDeque;
    6. import java.util.Deque;
    7. import java.util.HashSet;
    8. import java.util.Set;
    10. /**
    11.  * 对象占用字节大小工具类
    12.  *
    13.  * @author tianmai.fh http://yueyemaitian.iteye.com/blog/2033046
    14.  * @date 2014-03-18 11:29
    15.  */
    16. public class SizeOfObject {
    17.     static Instrumentation inst;
    19.     public static void premain(String args, Instrumentation instP) {
    20.         inst = instP;
    21.     }
    23.     /**
    24.      * 直接计算当前对象占用空间大小，包括当前类及超类的基本类型实例字段大小、<br></br>
    25.      * 引用类型实例字段引用大小、实例基本类型数组总占用空间、实例引用类型数组引用本身占用空间大小;<br></br>
    26.      * 但是不包括超类继承下来的和当前类声明的实例引用字段的对象本身的大小、实例引用数组引用的对象本身的大小 <br></br>
    27.      *
    28.      * @param obj
    29.      * @return
    30.      */
    31.     public static long sizeOf(Object obj) {
    32.         return inst.getObjectSize(obj);
    33.     }
    35.     /**
    36.      * 递归计算当前对象占用空间总大小，包括当前类和超类的实例字段大小以及实例字段引用对象大小
    37.      *
    38.      * @param objP
    39.      * @return
    40.      * @throws IllegalAccessException
    41.      */
    42.     public static long fullSizeOf(Object objP) throws IllegalAccessException {
    43.         Set<Object> visited = new HashSet<Object>();
    44.         Deque<Object> toBeQueue = new ArrayDeque<>();
    45.         toBeQueue.add(objP);
    46.         long size = 0L;
    47.         while (toBeQueue.size() > 0) {
    48.             Object obj = toBeQueue.poll();
    49.             //sizeOf的时候已经计基本类型和引用的长度，包括数组
    50.             size += skipObject(visited, obj) ? 0L : sizeOf(obj);
    51.             Class<?> tmpObjClass = obj.getClass();
    52.             if (tmpObjClass.isArray()) {
    53.                 //[I , [F 基本类型名字长度是2
    54.                 if (tmpObjClass.getName().length() > 2) {
    55.                     for (int i = 0, len = Array.getLength(obj); i < len; i++) {
    56.                         Object tmp = Array.get(obj, i);
    57.                         if (tmp != null) {
    58.                             //非基本类型需要深度遍历其对象
    59.                             toBeQueue.add(Array.get(obj, i));
    60.                         }
    61.                     }
    62.                 }
    63.             } else {
    64.                 while (tmpObjClass != null) {
    65.                     Field[] fields = tmpObjClass.getDeclaredFields();
    66.                     for (Field field : fields) {
    67.                         if (Modifier.isStatic(field.getModifiers())   //静态不计
    68.                                 || field.getType().isPrimitive()) {    //基本类型不重复计
    69.                             continue;
    70.                         }
    72.                         field.setAccessible(true);
    73.                         Object fieldValue = field.get(obj);
    74.                         if (fieldValue == null) {
    75.                             continue;
    76.                         }
    77.                         toBeQueue.add(fieldValue);
    78.                     }
    79.                     tmpObjClass = tmpObjClass.getSuperclass();
    80.                 }
    81.             }
    82.         }
    83.         return size;
    84.     }
    86.     /**
    87.      * String.intern的对象不计；计算过的不计，也避免死循环
    88.      *
    89.      * @param visited
    90.      * @param obj
    91.      * @return
    92.      */
    93.     static boolean skipObject(Set<Object> visited, Object obj) {
    94.         if (obj instanceof String && obj == ((String) obj).intern()) {
    95.             return true;
    96.         }
    97.         return visited.contains(obj);
    98.     }
    99. }