關於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也差很少少

完！


說明：
1。 以上結論適用於32位系統，對於64位系統，有不少不一樣。反正結論是雖然64位系統能用的內容更多了，但相同的程序佔用內存也多了很多
2。 上面討論的是類的實例佔用的內存，沒有考慮靜態變量的佔用。 靜態變量引用的是算在Class數據裏的，內容的佔用和實例無關，單獨計算就能夠了
3。 以上沒有考慮 Class自己佔的內存。 Class自己也須要佔地方啊，就是類的結構，以及靜態變量的引用的佔用。可是這個佔用是靜態的，不隨實例變多而變多的。也很差統計出來，想統計的話，看jvm源碼裏jclass的表示