计算对象占用内存大小工具类

想明确了解一个对象，比如VO,BO,List占用多少内存空间，可使用此类获得，在评估一些大批量导出时很有用，能够准确评估出一次查询的返回结果list占用多少内存空间

package com;


import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.*;
//一个引用：4字节
//一个Object：8字节
//一个Integer：16字节 == (8 + 4+8-1) / 8 * 8
//一个int：4字节
//长度为0的数组大小：JRo64=24,  Sun32=12


import com.pcm.order.edit.business.model.OrderHeaderBO;


//引用大小，如Object = null：                    JRo64=JRo32=4, Sun32=4, Sun64=8
//无成员的对象大小，如new Object();：     JRo32=JRo64=8, Sun32=8, Sun64=16
//new byte[0]:                        JRo32=JRo64=8+8 Sun32=8+4, Sun64=16+8


//长度l的byte数组：(l+12+8-1)/8*8
//长度l的char/short数组：(l*2+12+8-1)/8*8 == (l+9)/4*8
//长度l的String：(l+1)/4*8+40
//长度l的int数组：(l*4+12+8-1)/8*8 ==(l+4)/2*8
//长度l的long数组：(l*8+12+8-1)/8*8 == (l+2)*8


public class Occupy {
 public static void main(String[] args){
 Occupy oc = new Occupy((byte) 4, (byte) 8, (byte) 4);
 System.out.println(oc.occupyof(new OrderHeaderBO()));
 
 }
 //这8个方法不写不行，否则occupyof(int x)会自动重载到occupyof(Object o),并且无法在方法中判断
 public static int occupyof(boolean variable) {
   return 1;
 }
 
 public static int occupyof(byte variable) {
   return 1;
 }
 
 public static int occupyof(short variable) {
   return 2;
 }
 
 public static int occupyof(char variable) {
   return 2;
 }
 
 public static int occupyof(int variable) {
   return 4;
 }
 
 public static int occupyof(float variable) {
   return 4;
 }
 
 public static int occupyof(long variable) {
   return 8;
 }
 
 public static int occupyof(double variable) {
   return 8;
 }
 
 public Occupy(byte nullReferenceSize, byte emptyObjectSize, byte emptyArrayVarSize) {
   this.NULL_REFERENCE_SIZE = nullReferenceSize;
   this.EMPTY_OBJECT_SIZE = emptyObjectSize;
   this.EMPTY_ARRAY_VAR_SIZE = emptyArrayVarSize;
 }
 
 public static Occupy forJRockitVM() {
   return new Occupy((byte) 4, (byte) 8, (byte) 8);
 }
 
 public static Occupy forSun32BitsVM() {
   return new Occupy((byte) 4, (byte) 8, (byte) 4);
 }
 
 public static Occupy forSun64BitsVM() {
   return new Occupy((byte) 8, (byte) 16, (byte) 8);
 }
 
 public static Occupy forDetectedVM(){
   return null;
 }
 
 private final byte NULL_REFERENCE_SIZE;
 private final byte EMPTY_OBJECT_SIZE;
 private final byte EMPTY_ARRAY_VAR_SIZE;
 
 private static class ref{
   public ref(Object obj){
     this.obj = obj;
   }
   final Object obj;
   @Override
   public boolean equals(Object obj) {
     return (obj instanceof ref) && ((ref)obj).obj == this.obj;
   }
   @Override
   public int hashCode() {
     return obj.hashCode();
   }
 }
 
 private List dedup = new ArrayList();
 
 public int occupyof(Object object){
   dedup.clear();
   return occupyof0(object);
 }
 private int occupyof0(Object object) {
   if (object == null)
     return 0;
   ref r = new ref(object);
   if(dedup.contains(r))
     return 0;
   dedup.add(r);
   int varSize = 0;//对象中的值类型、引用类型变量大小
   int objSize = 0;//对象中的引用类型指向的对象实例的大小
   for (Class clazz = object.getClass(); clazz != Object.class; clazz = clazz.getSuperclass()) {
//      System.out.println(clazz);
     if (clazz.isArray()) {//当前对象的数组
       varSize += EMPTY_ARRAY_VAR_SIZE;
       Class<?> componentType = clazz.getComponentType();
       if (componentType.isPrimitive()) {//当前数组是原生类型的数组
         varSize += lengthOfPrimitiveArray(object) * sizeofPrimitiveClass(componentType);
         return occupyOfSize(EMPTY_OBJECT_SIZE, varSize, 0);
       }
       Object[] array = (Object[]) object;
       varSize += NULL_REFERENCE_SIZE * array.length;//当前数组有length个引用，每个占用4字节
       for (Object o : array)
         objSize += occupyof0(o);
       return occupyOfSize(EMPTY_OBJECT_SIZE, varSize, objSize);
     }
     Field[] fields = clazz.getDeclaredFields();
     for (Field field : fields) {
       if (Modifier.isStatic(field.getModifiers()))
         continue;//类成员不计
       //System.out.println(field.getDeclaringClass());
       if(clazz != field.getDeclaringClass())
         continue;
       Class<?> type = field.getType();
       if (type.isPrimitive())
         varSize += sizeofPrimitiveClass(type);
       else {
         varSize += NULL_REFERENCE_SIZE;//一个引用型变量占用4个字节
         try {
           field.setAccessible(true);//可以访问非public类型的变量
             objSize += occupyof0(field.get(object));
         } catch (Exception e) {
           objSize += occupyofConstructor(object, field);
         }
       }
     }
   }
   return occupyOfSize(EMPTY_OBJECT_SIZE, varSize, objSize);
 }
 
 public static int sizeof(boolean variable) {
   return 1;
 }
 
 public static int sizeof(byte variable) {
   return 1;
 }
 
 public static int sizeof(short variable) {
   return 2;
 }
 
 public static int sizeof(char variable) {
   return 2;
 }
 
 public static int sizeof(int variable) {
   return 4;
 }
 
 public static int sizeof(float variable) {
   return 4;
 }
 
 public static int sizeof(long variable) {
   return 8;
 }
 
 public static int sizeof(double variable) {
   return 8;
 }
 
 
 public int sizeof(Object object) {
   if (object == null)
     return 0;
   int size = EMPTY_OBJECT_SIZE;
   Class clazz = object.getClass();
   if (clazz.isArray()) {
     size += EMPTY_ARRAY_VAR_SIZE;//length变量是int型
     Class<?> componentType = clazz.getComponentType();
     if (componentType.isPrimitive())
       return size + lengthOfPrimitiveArray(object) * sizeofPrimitiveClass(componentType);
     Object[] array = (Object[]) object;
     size += 4 * array.length;
     for (Object o : array)
       size += sizeof(o);
     return size;
   }
   Field[] fields = clazz.getDeclaredFields();
   for (Field field : fields) {
     if (Modifier.isStatic(field.getModifiers()))
       continue;//类成员不计
     Class<?> type = field.getType();
     if (type.isPrimitive())
       size += sizeofPrimitiveClass(type);
     else {
       size += 4;//一个引用型变量占用4个字节
       try {
         field.setAccessible(true);//可以访问非public类型的变量
         size += sizeof(field.get(object));
       } catch (Exception e) {
         size += sizeofConstructor(object, field);
       }
     }
   }
   return size;
 }
 
 private static int occupyofConstructor(Object object, Field field) {
   throw new UnsupportedOperationException("field type Constructor not accessible: " + object.getClass() + " field:" + field);
 }
 
 private static int sizeofConstructor(Object object, Field field) {
   throw new UnsupportedOperationException("field type Constructor not accessible: " + object.getClass() + " field:" + field);
 }
 
 
 private static int occupyOfSize(int size) {
   return (size + 7) / 8 * 8;
 }
 
 private static int occupyOfSize(int selfSize, int varsSize, int objsSize) {
//    System.out.println("self=" + selfSize + " vars=" + varsSize + " objs=" + objsSize);
   return occupyOfSize(selfSize) + occupyOfSize(varsSize) + objsSize;
 }
 
 private static int sizeofPrimitiveClass(Class clazz) {
   return clazz == boolean.class || clazz == byte.class ? 1 : clazz == char.class || clazz == short.class ? 2 : clazz == int.class || clazz == float.class ? 4
       : 8;
 }
 
 private static int lengthOfPrimitiveArray(Object object) {
   Class<?> clazz = object.getClass();
   return clazz == boolean[].class ? ((boolean[]) object).length : clazz == byte[].class ? ((byte[]) object).length
       : clazz == char[].class ? ((char[]) object).length : clazz == short[].class ? ((short[]) object).length
           : clazz == int[].class ? ((int[]) object).length : clazz == float[].class ? ((float[]) object).length
               : clazz == long[].class ? ((long[]) object).length : ((double[]) object).length;
 }
}