越深入java 就觉得java做得越烂,java设计问题之 : 对象占用内存空间设计-白红宇

越深入java 就觉得java做得越烂,java设计问题之 : 对象占用内存空间设计

阅读量：2800 次

发布时间：2019-05-13

本文共 3156 字，大约阅读时间需要 10 分钟。

近段时间，项目要求对java的内存有要求，客户希望不要老是要他们扩大内存，所以此过程中了解了一些问题。

越想觉得，java越不是。

1，基础对象占有内存 byte,char,short,int,long,float,double分别为 1,2,2,4,8,4,8，byte;

包括后Byte,Short,Integer,Long....等分别为 16,16,16,16，都是byte

本来是 1字节的 byte包装后占 16字节!! 太不象话了，白用我的内存。除了一个Object 8byte指针其它浪费。

2, Object 8byte指针，就算定义个空对象，也一样占8byte 我觉得一个指针要 8个字节吗？有必要吗？我的内存啊。

2^64= 18446744073709551616 byte =17179869184G 有可能用这么大的内存地址吗？（欢迎内行发言）。

个人觉得:6个byte足也,281474976710656 = 262144G 不知道有什么难处要用 8byte.

3, Byte 用了 16字字节，真是想不通:8(指针)+8；浪费7byte

4, Short用了 16字字节，真是想不通:8(指针)+8；浪费6byte

5, Integer 用了 16字字节，真是想不通:8(指针)+8；浪费4byte

6, Long 用了 16字字节，:8(指针)+8；没浪费。

7, Float 用了 16字字节，真是想不通:8(指针)+8；浪费4byte。

8, Double 用了 16字字节，:8(指针)+8；没浪费。

9, BigDecimal 用了 32字字节，:8(指针)+24；除指针外 16不够？太猛了吧？吃内存啊!!!

10,object = new String(); 用了 40 字字节，:8(指针)+32；好象内存没花钱一样。

11 int[] a =new int[]{0}; 也是16字节

11 long[] a =new long[]{0}; 也是24字节

这么基础的东西，做得这样烂，java倒底怎么了？难道为吃内存而生？

现在知道，为什么java在游戏上插不上足，这样根本是不行的。

不用对象，又难以区分数据库为空的数据，真是进退两难。

为什么java不在新版本上来个新架构啊，这样下去只有一条：死.........

本来用 byte 只需要 100M，如果用 Byte就要 1.6G

（有多少米？内存地址能搞多大？32? 64?）

本来用 int 只需要 400M，如果用 Integer就要 1.6G

详细见：

1.3,1.4测试代码(1.5,1.6java本身有方法提供)

import java.util.ArrayList;
import java.math.BigDecimal;
/**
 * @author guishuanglin 2008-12-2 原程序作者：Vladimir Roubtsov
 * 
 */
publicclass Sizeof { 
publicstaticvoid main(String[] args) throws Exception { 
        // Warm up all classes/methods we will use
        runGC();
        usedMemory();
        // Array to keep strong references to allocated objects
        final int count = 100000;
        Object[] objects = new Object[count];
        long heap1 = 0;
        // Allocate count+1 objects, discard the first one
for (int i = -1; i < count; ++i) { 
            Object object = null;
            // Instantiate your data here and assign it to object
            // object = new Object();
            // object = new Integer (i);
            // object = new Long (i);
            // object = new String ();
            // object = new byte [128][1];
            // object = new Float(1);
            // object = new Double(1);
            // object = new BigDecimal(1);
            //object = new String();
            //object = new StringBuffer();
            //object = new Character('中');
            if (i >= 0)
                objects[i] = object;
else { 
                object = null; // Discard the warm up object
                runGC();
                heap1 = usedMemory(); // Take a before heap snapshot
            }
        }
        runGC();
        long heap2 = usedMemory(); // Take an after heap snapshot:
        final int size = Math.round(((float) (heap2 - heap1)) / count);
        System.out.println("'before' heap: " + heap1 + ", 'after' heap: "
                + heap2);
        System.out.println("heap delta: " + (heap2 - heap1) + ", {"
                + objects[0].getClass() + "} size = " + size + " bytes");
        for (int i = 0; i < count; ++i)
            objects[i] = null;
        objects = null;
    }
privatestaticvoid runGC() throws Exception { 
        // It helps to call Runtime.gc()
        // using several method calls:
        for (int r = 0; r < 4; ++r)
            _runGC();
    }
privatestaticvoid _runGC() throws Exception { 
        long usedMem1 = usedMemory(), usedMem2 = Long.MAX_VALUE;
for (int i = 0; (usedMem1 < usedMem2) && (i < 500); ++i) { 
            s_runtime.runFinalization();
            s_runtime.gc();
            Thread.currentThread().yield();
            usedMem2 = usedMem1;
            usedMem1 = usedMemory();
        }
    }
privatestaticlong usedMemory() { 
        return s_runtime.totalMemory() - s_runtime.freeMemory();
    }
    private static final Runtime s_runtime = Runtime.getRuntime();
} // End of class