Java类占用内存的情况概述（一）

 

 本文属于转载，在本系列的第二部分会讨论更加复杂的情况。

下面的论述针对32位系统，对64位系统不适用，后叙经常你写了一个程序，一测试，功能没问题，一看内存占用也不多，就不去考虑其它的东西了。但可能程序使用了一个什么数据结构，会当数据规模变大时，内存占用激增。

 

基本&&关键的问题是，Java里各种东东占多少内存？？？？？？？？？

 

对于primitive类型，有8个

byte short int long float double char boolean 它们的长度分别是

1 2 4 8 4 8 2 1

这个不罗嗦了，举例来说

long[] data=new long[1000];

占用内存 8*1000 bytes

此外，data本身是一个Object，也占用内存若干，后叙，当然它针对 8*1000来说，忽略不计

 

再说Object的占用，在说这个之前，先说说引用，一惯的说法是

Java里没有指针了，只有引用，引用是安全的

 

这个说法没错，但是从机理上来说，引用就是指针，只是jvm对指针的使用检查和限制很多，这个引用/指针变得很安全

 

直接来结论：一个引用占4byte ，在32位系统上

 

Object obj=null; //4byte

Object[] objs=new Object[1000]; //至少4*1000byte

 

你看我定义了一个 obj，还是null，就占4byte

定义了一个 objs,1000个元素，但都是null啊，就都每个占4byte

是的！！！！！

虽然obj==null，但它已经是 一个引用，或者说一个指针了

指针也要占地方啊！！！！啊！！！！啊！！！！

 

接下来，直接给另一个结论： Object占8byte，注意，纯Object

 

Object obj=new Object(); //多少？？？？

 

8byte？？ 错！！ 12byte，忘了还有一个引用，8byte是Object的内容

记住 Object obj=new Object(); 占12byte

 

Object[] objs=new Object[1000];

for(int i=0;i<1000;i ) {

objs[i]=new Object();

}

 

至少占用 12*1000 bytes

 

推论： Object占12bytes，似乎和上面的结论矛盾？？！！

没有！！ 不管Object，没有被垃圾回收之前，总得被别人引用吧？

总的有指针指它吧？ 既然指，那个引用or指针就要占地方啊 4byte

加起来是12byte，反正一个Object至少 12bytes

 

还是直接给结论，推导的过程我就都包办了，咱不是脏活累活抢着干么！！

一个Integer占 16 bytes

 

这时您可能会有疑问，Integer=Object int，就是：

public class Integer {

public int value;

}

Integer应该占 8 4=12 bytes啊

你说的有道理，但是jvm对所有的Object有限制！！

这个限制被我发现了，就是不管什么Object占的空间，要是8的倍数

12不是8的倍数，只能是16了！！！

 

推论：Byte也占16bytes!!!!!!!!!!!

 

问：

Byte[] bytes=new Byte[1000];

占用空间多少？

答： 约为（至少为） (16 4)*1000 bytes

好家伙！！！！！！！！

 

 

论题：数组空间占用怎么算？

我这里直接给结论了，推导这个花了更长的时间：

对于数组来说，数组这个Object有一个length属性，数组的元素相当于其成员

public class Array {

public int length;

//... 其它成员

}

对于数组，我们不是直接可以取length属性么，源于此

 

public byte[] bytes=new byte[1000];

System.out.println(bytes.length); // 看，有length属性

上面的bytes换算过来是：

public class Array {

public int length;

public byte byte0;

public byte byte1;

...

public byte byte999; 

}

上面的bytes占用的内存是：

4 [8 4 1*1000] = 4 [1012]=4 1016=1020

4是 bytes这个引用，8是Object基占的，4是length属性占的

1000是1000个成员占的，本来是 1012，但要求是8的倍数，变成 1016了

总共是 1020

再如：

byte[] bytes=new byte[4];

的内存占用是:

4 [8 4 4*1]=4 [16]=20;

 

byte[] bytes=new byte[3]; 也是 20

 

对于元素是Object的数组，Object也是当作其成员，（注意只有引用这个数组的空间，这个可以推到普通Class上）

 

Byte[] bytes=new Byte[1000];

这个 bytes的定义相当于:

public class Array {

public int length;

public Byte byte0;

.....

public Byte byte999;

}

占用空间是：

4 [8 4 4*1000] 16*1000= 4 4016 16000 = 你自己算吧

 

推论：千万不要用 Byte[] 有20倍的差距！！！！！！！

 

 

你可能一下子没明白过来，没关系多琢磨一下，对于普通的class来说

，内容占用就是基加成员的占用，Object成员只记引用

public class Abc {

public int n;

public byte b;

public Object obj;

}

它的内容占用是： [8 4 1 4]=24

所以 Abc one=new Abc()的占用是 4 24=28

提醒：对于 Abc的成员 obj没有计，如果要计入的话，循环这个过程就可以了。（琢磨一下）

 

举例：

 

public class Abc {

public byte b;

public Object obj=null;

}

 

public class Def {

public int n;

public byte b;

public Abc obj=new Abc();

}

问：

Def one=new Def(); //占多少？

答：

4 [8 4 1 4] [8 1 4]=4 24 16=44

 

 

public class Abc {

public byte b;

public Object obj=null;

}

 

public class Def {

public int n;

public byte b;

public Abc[] objs=new Abc[100];

{

for(int i=0;i<10;i ) {

objs[i]=new Abc();

}

}

}

问：

Def one=new Def(); //占多少？

答：

kao，一下我也算不出来，不过我写了程序，可以算出来，你给它一个Object，它就能递归的算出总共占了多少内存，这个程序不复杂，你也可以写出来。我等机会合适了再放出。

 

单独说一下String，String的结构是：

public class String {

private final char value[];

private final int offset;

private final int count;

private int hash; // Default to 0

}

所以，不考虑那个char[]的占用，一个String最少占用 [8 4 4 4 4]=24bytes

加上引用，共28bytes

所以

String s="";

占用28bytes！！！！！ 尽管它的长度为0

如果精确的算，加上引用一个String的占用是

4 24 [8 4 2*length]

String s=""; 的占用是 28 16= 44

String s="ab" 的占用是 28 16= 44

String s="abc" 的占用是 28 24 = 52

 

要说的是，String是常用的类，这么看，String耗内存很多，所以jvm有优化，同样的内容尽量重用，所以除了28是必须的外，那个char[] 很可能一样

比方说

String[] s=new String[1000];

for(int i=0;i<1000;i ) {

s[i]=new String("abcdefasdjflksadjflkasdfj");

 

}

的占用的数量级是 28*1000，那 1000个字符串本身基本上不占内存，只有一份！！！！！！

反正String 至少是 28,最多也可能是28！！！！！！！！

 

 

比较占内存的数据结构，这个很重要：

基本上就是 primitive的包装

 

实例：

我以前用一个

Hashtable的结构，有100万个元素

改为String[]＋int[]后，内存占用改观不少，速度也很快

100万的String[] 快排一下，也就2秒多，查找用2分，和hash也差不多少。