【賽迪網技術社區整理】

　　近對程序占用內存方面做了一些優化，取得了不錯的效果，總結了一些經驗。

　　簡要說一下，相信會對大家寫出優質的程序有所幫助。

　　下面的論述針對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也差不多少。