计算对象内存

定义基本数据类型内存大小

package com.rambo.memory;

import com.sun.jna.platform.win32.WinDef;

import java.util.IdentityHashMap;
import java.util.Map;

/**
 * 定义java基本数据内存大小
 *
 * @author Rambo(浩祥)
 * @create 2017-09-21
 **/
public class MemorySizes {
    /*
     * IdentityHashMap与HashMap的区别
     * 1、key值对比不同,前者k1==k2认为相同,后者k1.equal(k2)认为相同
     * 2、前者key可以为null
     */
    private final Map primitiveSizes = new IdentityHashMap() {
        {
            // 基本数据类型字节大小
            put(boolean.class, new Integer(1));
            put(byte.class, new Integer(Byte.SIZE/8));
            put(char.class, new Integer(Character.SIZE/8));
            put(short.class, new Integer(Short.SIZE/8));
            put(int.class, new Integer(Integer.SIZE/8));
            put(float.class, new Integer(Float.SIZE/8));
            put(double.class, new Integer(Double.SIZE/8));
            put(long.class, new Integer(Long.SIZE/8));
        }
    };

    public int getPrimitiveFieldSize(Class clazz) {
        return ((Integer) primitiveSizes.get(clazz)).intValue();
    }

    public int getPrimitiveArrayElementSize(Class clazz) {
        return getPrimitiveFieldSize(clazz);
    }

    // java内引用占用内存大小
    public int getPointerSize() {
        return 4;
    }

    public int getClassSize() {
        return 8;
    }

定义计算类

package com.rambo.memory;

import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.IdentityHashMap;
import java.util.Map;
import java.util.Stack;

/**
 * 计算对象所占所有内存(会递归计算引用的对象及父类)
 *
 * @author Rambo(浩祥)
 * @create 2017-09-21
 **/
public class MemoryCounter {
    private static final MemorySizes sizes = new MemorySizes();
    private final Map visited = new IdentityHashMap();
    private final Stack stack = new Stack(); // 待计算的对象放入占中,计算一个pop一个

    /**
     * 计算对象、关联引用、父类内存
     * @param obj 待计算对象
     * @return 内存大小byte
     */
    public long estimate(Object obj) {
        synchronized (this){
            long result = _estimate(obj);
            while (!stack.isEmpty()) {
                result += _estimate(stack.pop());
            }
            visited.clear();
            return result;
        }

    }

    /**
     * 计算对象本身、不包括引用和父类的内存
     * @param obj 待计算对象
     * @return 内存大小byte
     */
    private long _estimate(Object obj) {
        if (skipObject(obj)) {
            return 0;
        }
        visited.put(obj, null);// 记录已计算对象
        long result = 0;// 内存大小
        Class clazz = obj.getClass();
        // 对象类型是数组
        if (clazz.isArray()) {
            return _estimateArray(obj);
        }
        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()) {
                        result += sizes.getPrimitiveFieldSize(
                                fields[i].getType());
                    }
                    // 非静态引用类型成员
                    else {
                        result += sizes.getPointerSize();
                        fields[i].setAccessible(true);// 这样才能访问私有成员
                        try {
                            Object toBeDone = fields[i].get(obj);
                            if (toBeDone != null) {
                                stack.add(toBeDone); // 成员引用加入待计算栈
                            }
                        } catch (IllegalAccessException ex) {
                            assert false;
                        }
                    }
                }
            }
            // 递归计算父类对象大小
            clazz = clazz.getSuperclass();
        }
        result += sizes.getClassSize();
        return result;
    }

    /**
     * 跳过符合规则的对象的计算
     * @param obj 待计算对象
     * @return 跳过返回true,否则false
     */
    private boolean skipObject(Object obj) {
        // 如果是字符串且在String池中是已存在的,则跳过
        if ((obj instanceof String) && (obj == ((String) obj).intern())) {
            return true;
        }
        // 为null或者已经计算过则跳过
        return (obj == null) || visited.containsKey(obj);
    }

    /**
     * 计算数组占用内存
     * @param obj
     * @return
     */
    protected long _estimateArray(Object obj) {
        long result = sizes.getPointerSize();
        int length = Array.getLength(obj);
        if (length != 0) {
            // 反射回去数组类型
            Class arrayElementClazz = obj.getClass().getComponentType();
            // 计算基本类型数组内存
            if (arrayElementClazz.isPrimitive()) {
                result += length *
                        sizes.getPrimitiveArrayElementSize(arrayElementClazz);
            }
            // 计算引用数组类型(每个元素包括引用大小和对象大小)
            else {
                for (int i = 0; i < length; i++) {
                    result += sizes.getPointerSize() +
                            estimate(Array.get(obj, i));
                }
            }
        }
        return result;
    }

使用

import com.rambo.memory.MemoryCounter;

/**
 * @author Rambo(浩祥)
 * @create 2017-03-09
 **/
public class Practice {
    // MemoryCounter是自己写的对象内存的计算类
    private static MemoryCounter memoryCounter = new MemoryCounter();
    static String str = "aaa";

    public static void main(String[] args) {
        System.out.println(memoryCounter.estimate(str));
    }
}