定义基本数据类型内存大小
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));
}
}
