一、打包和使用方法参考我之前的这篇文章,本文主要是更新了测量的类及方法,实际测试这个方法更准确。

https://www.cnblogs.com/yoyotl/p/8421287.html

二、新的测量类

//package net.sourceforge.sizeof;

import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;
import java.lang.instrument.Instrumentation;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.IdentityHashMap;
import java.util.Map; public class SizeOf {
private static OutputStream out = System.out;
private static Instrumentation inst;
private static long MIN_CLASS_SIZE_TO_LOG = 1048576L;
private static boolean SKIP_STATIC_FIELD = false;
private static boolean SKIP_FINAL_FIELD = false;
private static boolean SKIP_FLYWEIGHT_FIELD = false;
private static boolean debug = false;
private static String[] unit = {"b", "Kb", "Mb", "Gb", "Tb"}; public static void premain(String paramString, Instrumentation paramInstrumentation) {
inst = paramInstrumentation;
System.out.println("JAVAGENT: call premain instrumentation for class SizeOf");
} public static long sizeOf(Object paramObject) {
if (inst == null) {
throw new IllegalStateException("Instrumentation is null");
}
if ((SKIP_FLYWEIGHT_FIELD) && (isSharedFlyweight(paramObject))) {
return 0L;
}
return inst.getObjectSize(paramObject);
} public static String humanReadable(long paramLong) {
double d = paramLong;
int i = ;
for (i = ; (i < ) && (d >= 1024.0D); i++) {
d /= 1024.0D;
}
return d + unit[i];
} public static long deepSizeOf(Object paramObject) {
IdentityHashMap localIdentityHashMap = new IdentityHashMap();
return deepSizeOf(paramObject, localIdentityHashMap, );
} /**
* @deprecated
*/
public static long iterativeSizeOf(Object paramObject)
throws IllegalArgumentException, IllegalAccessException, IOException {
return deepSizeOf(paramObject);
} private static String indent(int paramInt) {
StringBuilder localStringBuilder = new StringBuilder();
for (int i = ; i < paramInt; i++) {
localStringBuilder.append(" ");
}
return localStringBuilder.toString();
} private static long deepSizeOf(Object paramObject, Map<Object, Object> paramMap, int paramInt) {
if (paramObject == null) {
if (debug) {
print("null\n");
}
return 0L;
}
long l = 0L;
if (paramMap.containsKey(paramObject)) {
if (debug) {
print("\n%s{ yet computed }\n", new Object[]{indent(paramInt)});
}
return 0L;
}
if (debug) {
print("\n%s{ %s\n", new Object[]{indent(paramInt), paramObject.getClass().getName()});
}
paramMap.put(paramObject, null);
l = sizeOf(paramObject);
if ((paramObject instanceof Object[])) {
int i = ;
for (Object localObject2 : (Object[]) paramObject) {
if (debug) {
print("%s [%d] = ", new Object[]{indent(paramInt), Integer.valueOf(i++)});
}
l += deepSizeOf(localObject2, paramMap, paramInt + );
}
} else {
Field[] arrayOfField = paramObject.getClass().getDeclaredFields();
for (Object localObject2 : arrayOfField) {
((Field) localObject2).setAccessible(true);
Object localObject3;
try {
localObject3 = ((Field) localObject2).get(paramObject);
} catch (IllegalArgumentException localIllegalArgumentException) {
throw new RuntimeException(localIllegalArgumentException);
} catch (IllegalAccessException localIllegalAccessException) {
throw new RuntimeException(localIllegalAccessException);
}
if (isComputable((Field) localObject2)) {
if (debug) {
print("%s %s = ", new Object[]{indent(paramInt), ((Field) localObject2).getName()});
}
l += deepSizeOf(localObject3, paramMap, paramInt + );
} else if (debug) {
print("%s %s = %s\n", new Object[]{indent(paramInt), ((Field) localObject2).getName(), localObject3.toString()});
}
}
}
if (debug) {
print("%s} size = %s\n", new Object[]{indent(paramInt), humanReadable(l)});
}
if ((MIN_CLASS_SIZE_TO_LOG > 0L) && (l >= MIN_CLASS_SIZE_TO_LOG)) {
print("Found big object: %s%s@%s size: %s\n", new Object[]{indent(paramInt), paramObject.getClass().getName(), Integer.valueOf(System.identityHashCode(paramObject)), humanReadable(l)});
}
return l;
} private static boolean isAPrimitiveType(Class paramClass) {
if (paramClass == Boolean.TYPE) {
return true;
}
if (paramClass == Character.TYPE) {
return true;
}
if (paramClass == Byte.TYPE) {
return true;
}
if (paramClass == Short.TYPE) {
return true;
}
if (paramClass == Integer.TYPE) {
return true;
}
if (paramClass == Long.TYPE) {
return true;
}
if (paramClass == Float.TYPE) {
return true;
}
if (paramClass == Double.TYPE) {
return true;
}
return paramClass == Void.TYPE;
} private static boolean isComputable(Field paramField) {
int i = paramField.getModifiers();
if (isAPrimitiveType(paramField.getType())) {
return false;
}
if ((SKIP_STATIC_FIELD) && (Modifier.isStatic(i))) {
return false;
}
return (!SKIP_FINAL_FIELD) || (!Modifier.isFinal(i));
} private static boolean isSharedFlyweight(Object paramObject) {
if ((paramObject instanceof Comparable)) {
if ((paramObject instanceof Enum)) {
return true;
}
if ((paramObject instanceof String)) {
return paramObject == ((String) paramObject).intern();
}
if ((paramObject instanceof Boolean)) {
return (paramObject == Boolean.TRUE) || (paramObject == Boolean.FALSE);
}
if ((paramObject instanceof Integer)) {
return paramObject == Integer.valueOf(((Integer) paramObject).intValue());
}
if ((paramObject instanceof Short)) {
return paramObject == Short.valueOf(((Short) paramObject).shortValue());
}
if ((paramObject instanceof Byte)) {
return paramObject == Byte.valueOf(((Byte) paramObject).byteValue());
}
if ((paramObject instanceof Long)) {
return paramObject == Long.valueOf(((Long) paramObject).longValue());
}
if ((paramObject instanceof Character)) {
return paramObject == Character.valueOf(((Character) paramObject).charValue());
}
}
return false;
} public static void setMinSizeToLog(long paramLong) {
MIN_CLASS_SIZE_TO_LOG = paramLong;
} public static void skipFinalField(boolean paramBoolean) {
SKIP_FINAL_FIELD = paramBoolean;
} public static void skipStaticField(boolean paramBoolean) {
SKIP_STATIC_FIELD = paramBoolean;
} public static void skipFlyweightObject(boolean paramBoolean) {
SKIP_FLYWEIGHT_FIELD = paramBoolean;
} private static void print(String paramString) {
try {
out.write(paramString.getBytes());
} catch (IOException localIOException) {
throw new RuntimeException(localIOException);
}
} private static void print(String paramString, Object... paramVarArgs) {
try {
out.write(String.format(paramString, paramVarArgs).getBytes());
} catch (IOException localIOException) {
throw new RuntimeException(localIOException);
}
} public static void setLogOutputStream(OutputStream paramOutputStream) {
if (paramOutputStream == null) {
throw new IllegalArgumentException("Can't use a null OutputStream");
}
out = paramOutputStream;
} public static void turnOnDebug() {
debug = true;
} public static void turnOffDebug() {
debug = false;
}
}

PS:反编译一个开源测试库并优化代码得到的新类,测试有效,希望对你有用。

Java对象的内存实际占用的更多相关文章

  1. java对象在内存的大小

    前言 一直以来,对java对象大小的概念停留在基础数据类型,比如byte占1字节,int占4字节,long占8字节等,但是一个对象包含的内存空间肯定不只有这些. 假设有类A和B,当new A()或者n ...

  2. Java对象的内存模型(一)

    前言 新人一枚,刚刚入门编程不久,各方面都在学习当中,博文有什么错误的地方,希望我们可以多多交流! 最近,在开发App后台过程中,需要将项目部署到云服务器上.而云服务器的内存大小却只有1G.要如何做到 ...

  3. Java对象的内存布局

    对象的内存布局 平时用java编写程序,你了解java对象的内存布局么? 在HotSpot虚拟机中,对象在内存中存储的布局可以分为3块区域: 对象头 实例数据 对齐填充 对象头 对象头包括两部分信息: ...

  4. JVM总结-java对象的内存布局

    在 Java 程序中,我们拥有多种新建对象的方式.除了最为常见的 new 语句之外,我们还可以通过反射机制.Object.clone 方法.反序列化以及 Unsafe.allocateInstance ...

  5. Java对象的内存(一)

    前言 新人一枚,刚刚入门编程不久,各方面都在学习当中,博文有什么错误的地方,希望我们可以多多交流! 最近,在开发App后台过程中,需要将项目部署到云服务器上.而云服务器的内存大小却只有1G.要如何做到 ...

  6. java对象在内存中的分配

    java对象在内存中的分配 http://blog.csdn.net/qq_30753945/article/details/54974899

  7. 10 Java 对象的内存布局

    Java 创建对象的方式 1:new 语句和反射机制创建.该方式会调用类的构造器,同时满足诸多约束.如果一个类没有构造器的话,Java 编译器会自动添加一个无参数的构造器.子类的构造器需要调用父类的构 ...

  8. Java对象的内存布局以及对象的访问定位

    一 Java对象的内存布局 在HotSpot虚拟机中,对象在内存中的布局分为3个区域 对象头(Header) Mark Word(在32bit和64bit虚拟机上长度分别为32bit和64bit)存储 ...

  9. 3 Java对象的内存布局以及对象的访问定位

    先来看看Java对象在内存中的布局   一 Java对象的内存布局 在HotSpot虚拟机中,对象在内存中的布局分为3个区域 对象头(Header) Mark Word(在32bit和64bit虚拟机 ...

随机推荐

  1. JS实现品字布局

    在网页后台中常用的布局是头部+侧边栏的形式 为了省去多于代码和重复修改多个页面 头部和侧边栏都是共用的,一直不改变的,所以写死在页面中. 中间的内容根据点击而发生改变,所以用iframe包起来 如何实 ...

  2. python ThreadLocal

    ThreadLocal: 主要是为了解决各个线程引用全局变量,并且各个线程之间互不影响而设置的. 实例: import threading threadlocal = threading.local( ...

  3. Unity 之 添加背景音乐 以及 Slider控制

    游戏音频分为背景音乐与环境音乐两种.Audio   Clip(音频剪辑)有四种音乐格式.MP3:适合较长音频,作为背景音乐.Ogg:适合较长音频,作为背景音乐.Wav:适合较短音频,作为环境音乐.Ai ...

  4. 《Gradle权威指南》--Gradle构建脚本基础

    No1: 设置文件默认名是setting.gradle,放在根目录下,大多数作用都是为了配置子工程 No2: 一个Project包含很多个Task.Task就是一个操作,一个原子性的操作.其实它是Pr ...

  5. Python开发之pip使用详解

    1 pip的优点 pip如今已经成为了Python的一大特色,可以很方便得协助Python开发者进行包管理.综合来说,匹配拥有如下优点: pip提供了丰富的功能,其竞争对手easy_install只支 ...

  6. C# 动态事件示例

    public Form1() { InitializeComponent(); button1.Click += new EventHandler(button_Click); button2.Cli ...

  7. HDU 4352 XHXJ's LIS 数位dp lis

    目录 题目链接 题解 代码 题目链接 HDU 4352 XHXJ's LIS 题解 对于lis求的过程 对一个数列,都可以用nlogn的方法来的到它的一个可行lis 对这个logn的方法求解lis时用 ...

  8. Bzoj2673 3961: [WF2011]Chips Challenge 费用流

    国际惯例题面:如果我们枚举放几个零件的话,第二个限制很容易解决,但是第一个怎么办?(好的,这么建图不可做)考虑我们枚举每行每列最多放几个零件t,然后计算零件总数sum.这样如果可行的话,则有t*B&l ...

  9. UOJ #79 一般图最大匹配 带花树

    http://uoj.ac/problem/79 一般图和二分图的区别就是有奇环,带花树是在匈牙利算法的基础上对奇环进行缩点操作,复杂度似乎是O(mn)和匈牙利一样. 具体操作是一个一个点做类似匈牙利 ...

  10. SPOJTLE - Time Limit Exceeded(高维前缀和)

    题意 题目链接 题目的意思是给一个数组C,长度为n,每个数字的范围是2^m,然后要求构造一个数组a,满足 1.a[i] % C[i] !=0 ; 2.a[i] < 2^m ; 3.a[i] &a ...