您的位置:

java计算object大小(计算java对象大小)

本文目录一览:

java中的怎么比较两个object值的大小

我给你举个例子吧:创建一个熊猫类,实例化两个熊猫对象,如果两个对象的身高和年龄相同就认为这两个对象的equals方法返回真,否则返回假

Panda类:

public class Panda {

double height;

int age;

@Override

public boolean equals(Object obj) {

if(this==obj){

return true;

}

if(obj instanceof Panda){

Panda panda=(Panda)obj;

if (this.height==panda.heightthis.age==panda.age){

return true;}

else{

return false;

}

}

return false;

}

}

Test类:

public class Test {

public static void main(String[] args) {

Panda panda=new Panda();

panda.height=1.60;

panda.age=4;

Panda panda1=new Panda();

panda1.height=1.60;

panda1.age=4;

System.out.println(panda.equals(panda1));

}

}

你可以测试一下。

如何计算java中的对象object大小size

// 利用GC回收前与回收后的差值计算对象的大小:

class Foo{ // 32位OS类定义引用占8 byte,64位OS占用16 byte

   int x;  // 4 byte

   byte b; // 1 byte

}

public class Demo {

  public static void main(String args[]) {

  

    Foo foo= new Foo();

    Runtime.getRuntime().gc();

    long gcing = Runtime.getRuntime().freeMemory();

    Foo foo2= new Foo();

    long gced = Runtime.getRuntime().freeMemory();

    // 64位打印24,32位打印16 (注:是因为JVM底层内存都是以8 byte对齐的,即8的倍数)

    System.out.println("Memory used:"+(gcing -gced )); 

    

  }

  

}

如何准确计算Java对象的大小

首先,我们先写一段大家可能不怎么写或者认为不可能的代码:一个类中,几个类型都是private类型,没有public方法,如何对这些属性进行读写操作,看似不可能哦,为什么,这违背了面向对象的封装,其实在必要的时候,留一道后门可以使得语言的生产力更加强大,对象的序列化不会因为没有public方法就无法保存成功吧,OK,我们简单写段代码开个头,逐步引入到怎么样去测试对象的大小,一下代码非常简单,相信不用我解释什么:

import java.lang.reflect.Field;

class NodeTest1 {

private int a = 13;

private int b = 21;

}

public class Test001 {

public static void main(String []args) {

NodeTest1 node = new NodeTest1();

Field []fields = NodeTest1.class.getDeclaredFields();

for(Field field : fields) {

field.setAccessible(true);

try {

int i = field.getInt(node);

field.setInt(node, i * 2);

System.out.println(field.getInt(node));

} catch (IllegalArgumentException e) {

e.printStackTrace();

} catch (IllegalAccessException e) {

e.printStackTrace();

}

}

}

}

代码最基本的意思就是:实例化一个NodeTest1这个类的实例,然后取出两个属性,分别乘以2,然后再输出,相信大家会认为这怎么可能,NodeTest1根本没有public方法,代码就在这里,将代码拷贝回去运行下就OK了,OK,现在不说这些了,运行结果为:

26

42

为什么可以取到,是每个属性都留了一道门,主要是为了自己或者外部接入的方便,相信看代码自己仔细的朋友,应该知道门就在:field.setAccessible(true);代表这个域的访问被打开,好比是一道后门打开了,呵呵,上面的方法如果不设置这个,就直接报错。

看似和对象大小没啥关系,不过这只是抛砖引玉,因为我们首先要拿到对象的属性,才能知道对象的大小,对象如果没有提供public方法我们也要知道它有哪些属性,所以我们后面多半会用到这段类似的代码哦!

对象测量大小的方法关键为java提供的(1.5过后才有):java.lang.instrument.Instrumentation,它提供了丰富的对结构的等各方面的跟踪和对象大小的测量的API(本文只阐述对象大小的测量方法),于是乎我心喜了,不过比较恶心的是它是实例化类:sun.instrument.IntrumentationImpl是sun开头的,这个鬼东西有点不好搞,翻开源码构造方法是private类型,没有任何getInstance的方法,写这个类干嘛?看来这个只能被JVM自己给初始化了,那么怎么将它自己初始化的东西取出来用呢,唯一能想到的就是agent代理,那么我们先抛开代理,首先来写一个简单的对象测量方法:

步骤1:(先创建一个用于测试对象大小的处理类)

import java.lang.instrument.Instrumentation;

public class MySizeOf {

private static Instrumentation inst;

/**

*这个方法必须写,在agent调用时会被启用

*/

public static void premain(String agentArgs, Instrumentation instP) {

inst = instP;

}

/**

* 直接计算当前对象占用空间大小,包括:当前类及超类的基本类型实例字段大小

* 引用类型实例字段引用大小、实例基本类型数组总占用空间、实例引用类型数组引用本身占用空间大小

* 但是不包括超类继承下来的和当前类声明的实例引用字段的对象本身的大小、实例引用数组引用的对象本身的大小

* 用来测量java对象的大小(这里先理解这个大小是正确的,后面再深化)

*/

public static long sizeOf(Object o) {

if(inst == null) {

throw new IllegalStateException("Can not access instrumentation environment.\n" +

"Please check if jar file containing SizeOfAgent class is \n" +

"specified in the java's \"-javaagent\" command line argument.");

}

return inst.getObjectSize(o);

}

}

步骤2:上面我们写好了agent的代码,此时我们要将上面这个类编译后打包为一个jar文件,并且在其包内部的META-INF/MANIFEST.MF文件中增加一行:Premain-Class: MySizeOf代表执行代理的全名,这里的类名称是没有package的,如果你有package,那么就写全名,我们这里假设打包完的jar包名称为agent.jar(打包过程这里简单阐述,就不细说了),OK,继续向下走:

步骤3:编写测试类,测试类中写:

public class TestSize {

public static void main(String []args) {

System.out.println(MySizeOf.sizeOf(new Integer(1)));

System.out.println(MySizeOf.sizeOf(new String("a")));

System.out.println(MySizeOf.sizeOf(new char[1]));

}

}

下一步准备运行,运行前我们准备初步估算下结果是什么,目前我是在32bit模式下运行jvm(注意,不同位数的JVM参数设置不一样,对象大小也不一样大)。

(1) 首先看Integer对象,在32bit模式下,class区域占用4byte,mark区域占用最少4byte,所以最少8byte头部,Integer内部有一个int类型的数据,占4个byte,所以此时为8+4=12,java默认要求按照8byte对象对其,所以对其到16byte,所以我们理论结果第一个应该是16;

(2) 再看String,长度为1,String对象内部本身有4个非静态属性(静态属性我们不计算空间,因为所有对象都是共享一块空间的),4个非静态属性中,有offset、count、hash为int类型,分别占用4个byte,char value[]为一个指针,指针的大小在bit模式下或64bit开启指针压缩下默认为4byte,所以属性占用了16byte,String本身有8byte头部,所以占用了24byte;其次,一个String包含了子对象char数组,数组对象和普通对象的区别是需要用一个字段来保存数组的长度,所以头部变成12byte,java中一个char采用UTF-16编码,占用2个byte,所以是14byte,对其到16byte,24+16=40byte;

(3) 第三个在第二个基础上已经分析,就是16byte大小;

也就是理论结果是:16、40、16;

步骤4:现在开始运行代码:运行代码前需要保证classpath把刚才的agent.jar包含进去:

D:javac TestSize.java

D:java -javaagent:agent.jar TestSize

16

24

16

第一个和第三个结果一致了,不过奇怪了,第二个怎么是24,不是40,怎么和理论结果偏差这么大,再回到理论结果中,有一个24曾经出现过,24是指String而不包含char数组的空间大小,那么这么算还真是对的,可见,java默认提供的方法只能测量对象当前的大小,如果要测量这个对象实际的大小(也就是包含了子对象,那么就需要自己写算法来计算了,最简单的方法就是递归,不过递归一项是我不喜欢用的,无意中在一个地方看到有人用栈写了一个代码写得还不错,自己稍微改了下,就是下面这种了)。

import java.lang.instrument.Instrumentation;

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;

public class MySizeOf {

static Instrumentation inst;

public static void premain(String agentArgs, Instrumentation instP) {

inst = instP;

}

public static long sizeOf(Object o) {

if(inst == null) {

throw new IllegalStateException("Can not access instrumentation environment.\n" +

"Please check if jar file containing SizeOfAgent class is \n" +

"specified in the java's \"-javaagent\" command line argument.");

}

return inst.getObjectSize(o);

}

/**

* 递归计算当前对象占用空间总大小,包括当前类和超类的实例字段大小以及实例字段引用对象大小

*/

public static long fullSizeOf(Object obj) {//深入检索对象,并计算大小

MapObject, Object visited = new IdentityHashMapObject, Object();

StackObject stack = new StackObject();

long result = internalSizeOf(obj, stack, visited);

while (!stack.isEmpty()) {//通过栈进行遍历

result += internalSizeOf(stack.pop(), stack, visited);

}

visited.clear();

return result;

}

//判定哪些是需要跳过的

private static boolean skipObject(Object obj, MapObject, Object visited) {

if (obj instanceof String) {

if (obj == ((String) obj).intern()) {

return true;

}

}

return (obj == null) || visited.containsKey(obj);

}

private static long internalSizeOf(Object obj, StackObject stack, MapObject, Object visited) {

if (skipObject(obj, visited)) {//跳过常量池对象、跳过已经访问过的对象

return 0;

}

visited.put(obj, null);//将当前对象放入栈中

long result = 0;

result += sizeOf(obj);

Class ?clazz = obj.getClass();

if (clazz.isArray()) {//如果数组

if(clazz.getName().length() != 2) {// skip primitive type array

int length = Array.getLength(obj);

for (int i = 0; i length; i++) {

stack.add(Array.get(obj, i));

}

}

return result;

}

return getNodeSize(clazz , result , obj , stack);

}

//这个方法获取非数组对象自身的大小,并且可以向父类进行向上搜索

private static long getNodeSize(Class ?clazz , long result , Object obj , StackObject stack) {

while (clazz != null) {

Field[] fields = clazz.getDeclaredFields();

for (Field field : fields) {

if (!Modifier.isStatic(field.getModifiers())) {//这里抛开静态属性

if (field.getType().isPrimitive()) {//这里抛开基本关键字(因为基本关键字在调用java默认提供的方法就已经计算过了)

continue;

}else {

field.setAccessible(true);

try {

Object objectToAdd = field.get(obj);

if (objectToAdd != null) {

stack.add(objectToAdd);//将对象放入栈中,一遍弹出后继续检索

}

} catch (IllegalAccessException ex) {

assert false;

}

}

}

}

clazz = clazz.getSuperclass();//找父类class,直到没有父类

}

return result;

}

}

java中怎么算一个对象的空间大小

Object流

直接将Object写入或读出

也叫做对象的序列化:把一个Object直接转换成字节流写到硬盘上,或者直接写到网络上去

这里有一个类T:

class T implements Serializable { // 注意,必须要实现Serializable接口,才是可序列化的

int i = 10;

int j = 9;

double d = 2.3;

int k = 15;

}

这个类里面的成员变量3个int,1个double,int是4字节,double是8字节

所以对象的大小绝对不会小于20字节,但是T肯定是从Object类继承,那么继承下来这些内容也

占空间,比如方法什么的,所以肯定要大于20字节了

运行下面这个类:

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import java.io.Serializable;

public class Test {

public static void main(String[] args) {

T t = new T();

try {

FileOutputStream fos = new FileOutputStream("d:/abc.txt");

ObjectOutputStream oos = new ObjectOutputStream(fos);

oos.writeObject(t);

oos.flush();

oos.close();

} catch (IOException e) {

e.printStackTrace();

}

}

}

直接将T对象通过Object流写到了D盘的名为abc.txt的文件里面

一个空文本文件是0字节,找到这个文件以后查看它的属性,我这里是67 字节,

那么这个对象就是67 字节

现在在T类中添加一些其他内容,那么再次输出,字节数肯定就比原来大了,它就是把整个对象转换成

字节,写入了文件,这个应该算是比较好的方式了,但是我们无法特别精确的知道对象中哪些内容各自

占用多少空间,因为那是Java虚拟机的事了,我学的没那么深入,水平有限

当然,把一个对象写进去,也可以读出来:

FileInputStream fis = new FileInputStream("");

ObjectInputStream ois = new ObjectInputStream(fis);

// 当成Object读出来的,强转成T类型

T tReaded = (T)ois.readObject();

System.out.println(tReaded.i + " " + tReaded.j + " " + tReaded.d + " " + tReaded.k);

发现打印出的成员变量的值,还是存进去这个对象的值

如何计算java对象的大小

首先,我们先写一段大家可能不怎么写或者认为不可能的代码:一个类中,几个类型都是private类型,没有public方法,如何对这些属性进行读写操作,看似不可能哦,为什么,这违背了面向对象的封装,其实在必要的时候,留一道后门可以使得语言的生产力更加强大,对象的序列化不会因为没有public方法就无法保存成功吧,OK,我们简单写段代码开个头,逐步引入到怎么样去测试对象的大小,一下代码非常简单,相信不用我解释什么:

import java.lang.reflect.Field;

class NodeTest1 {

private int a = 13;

private int b = 21;

}

public class Test001 {

public static void main(String []args) {

NodeTest1 node = new NodeTest1();

Field []fields = NodeTest1.class.getDeclaredFields();

for(Field field : fields) {

field.setAccessible(true);

try {

int i = field.getInt(node);

field.setInt(node, i * 2);

System.out.println(field.getInt(node));

} catch (IllegalArgumentException e) {

e.printStackTrace();

} catch (IllegalAccessException e) {

e.printStackTrace();

}

}

}

}

代码最基本的意思就是:实例化一个NodeTest1这个类的实例,然后取出两个属性,分别乘以2,然后再输出,相信大家会认为这怎么可能,NodeTest1根本没有public方法,代码就在这里,将代码拷贝回去运行下就OK了,OK,现在不说这些了,运行结果为:

26

42

为什么可以取到,是每个属性都留了一道门,主要是为了自己或者外部接入的方便,相信看代码自己仔细的朋友,应该知道门就在:field.setAccessible(true);代表这个域的访问被打开,好比是一道后门打开了,呵呵,上面的方法如果不设置这个,就直接报错。

看似和对象大小没啥关系,不过这只是抛砖引玉,因为我们首先要拿到对象的属性,才能知道对象的大小,对象如果没有提供public方法我们也要知道它有哪些属性,所以我们后面多半会用到这段类似的代码哦!

对象测量大小的方法关键为java提供的(1.5过后才有):java.lang.instrument.Instrumentation,它提供了丰富的对结构的等各方面的跟踪和对象大小的测量的API(本文只阐述对象大小的测量方法),于是乎我心喜了,不过比较恶心的是它是实例化类:sun.instrument.IntrumentationImpl是sun开头的,这个鬼东西有点不好搞,翻开源码构造方法是private类型,没有任何getInstance的方法,写这个类干嘛?看来这个只能被JVM自己给初始化了,那么怎么将它自己初始化的东西取出来用呢,唯一能想到的就是agent代理,那么我们先抛开代理,首先来写一个简单的对象测量方法:

步骤1:(先创建一个用于测试对象大小的处理类)

import java.lang.instrument.Instrumentation;

public class MySizeOf {

private static Instrumentation inst;

/**

*这个方法必须写,在agent调用时会被启用

*/

public static void premain(String agentArgs, Instrumentation instP) {

inst = instP;

}

/**

* 直接计算当前对象占用空间大小,包括:当前类及超类的基本类型实例字段大小

* 引用类型实例字段引用大小、实例基本类型数组总占用空间、实例引用类型数组引用本身占用空间大小

* 但是不包括超类继承下来的和当前类声明的实例引用字段的对象本身的大小、实例引用数组引用的对象本身的大小

* 用来测量java对象的大小(这里先理解这个大小是正确的,后面再深化)

*/

public static long sizeOf(Object o) {

if(inst == null) {

throw new IllegalStateException("Can not access instrumentation environment.\n" +

"Please check if jar file containing SizeOfAgent class is \n" +

"specified in the java's \"-javaagent\" command line argument.");

}

return inst.getObjectSize(o);

}

}

步骤2:上面我们写好了agent的代码,此时我们要将上面这个类编译后打包为一个jar文件,并且在其包内部的META-INF/MANIFEST.MF文件中增加一行:Premain-Class: MySizeOf代表执行代理的全名,这里的类名称是没有package的,如果你有package,那么就写全名,我们这里假设打包完的jar包名称为agent.jar(打包过程这里简单阐述,就不细说了),OK,继续向下走:

步骤3:编写测试类,测试类中写:

public class TestSize {

public static void main(String []args) {

System.out.println(MySizeOf.sizeOf(new Integer(1)));

System.out.println(MySizeOf.sizeOf(new String("a")));

System.out.println(MySizeOf.sizeOf(new char[1]));

}

}

如何在java里面对Object的类型值进行一个大小的比较

作者:Tao Li

链接:

来源:知乎

著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。

java中类的比较一般有两种方法,一种就是类本身实现ComparableT这个接口,比如通过对用户的姓名进行比较排序:

package com.ailot.compare;

public class User implements ComparableUser {

private String name;

private int age;

private String sex;

public User(String name,int age,String sex){

this.name = name;

this.age = age;

this.sex = sex;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

public String getSex() {

return sex;

}

public void setSex(String sex) {

this.sex = sex;

}

@Override

public String toString() {

return "User [name=" + name + ", age=" + age + ", sex=" + sex + "]";

}

@Override

public int compareTo(User u) {

// TODO Auto-generated method stub

int c = this.name.compareTo(u.name);

if(c==0){

return 0;

}else if(c 0){

return 1;

}else{

return -1;

}

}

}

Test.java

package com.ailot.compare;

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

import java.util.Random;

public class Test {

public static void main(String[] args) {

ListUser userList = new ArrayListUser();

for(int i=0;i10;i++){

int s = new Random().nextInt(20);

User u = new User(s+"张三",i,"男");

userList.add(u);

}

Collections.sort(userList);

for(User user : userList){

System.out.println(user.toString());

}

}

}

排序的话直接用 Collections.sort( userList ) ;就可以了。

作者:Tao Li

链接:

来源:知乎

著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。

另一种就是类没有实现ComparableT这个接口,这就需要自己新建一个比较的类,通过实现ComparatorT来对类进行比较,还是对User类的姓名进行比较排序:

User.java

package com.ailot.compare;

public class User {

private String name;

private int age;

private String sex;

public User(String name,int age,String sex){

this.name = name;

this.age = age;

this.sex = sex;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

public String getSex() {

return sex;

}

public void setSex(String sex) {

this.sex = sex;

}

@Override

public String toString() {

return "User [name=" + name + ", age=" + age + ", sex=" + sex + "]";

}

}

UserCompare.java

package com.ailot.compare;

import java.util.Comparator;

public class UserCompare implements ComparatorUser {

@Override

public int compare(User u1, User u2) {

// TODO Auto-generated method stub

int c = u1.getName().compareTo(u2.getName());

if(c == 0){

return 0;

}else if(c 0){

return -1;

}else{

return 1;

}

}

}

Test.java

package com.ailot.compare;

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

import java.util.Random;

public class Test {

public static void main(String[] args) {

ListUser userList = new ArrayListUser();

for(int i=0;i10;i++){

int s = new Random().nextInt(20);

User u = new User(s+"张三",i,"男");

userList.add(u);

}

Collections.sort(userList,new UserCompare());

for(User user : userList){

System.out.println(user.toString());

}

}

}

排序的话直接用 Collections.sort(userList,new UserCompare());就可以了。