[Java] [學習筆記] - 基本數據類型的大小(sizeof方法功能)

時間 2019-11-15

標籤 java 學習筆記基本數據類型大小 sizeof 方法功能欄目 Java 简体版

原文原文鏈接

Java基本數據類型

int 32bit
short 16bit
long 64bit
byte 8bithtml

char 16bit
float 32bit
double 64bitjava

boolean 1bit數組

This data type represents one bit of information, but its "size" isn't something that's precisely defined.（ref）oracle

Java基本數據類型大小app

private static void calSize() {  
    System.out.println("Integer: " + Integer.SIZE/8);           // 4  
    System.out.println("Short: " + Short.SIZE/8);               // 2      
    System.out.println("Long: " + Long.SIZE/8);                 // 8  
    System.out.println("Byte: " + Byte.SIZE/8);                 // 1  
    System.out.println("Character: " + Character.SIZE/8);       // 2  
    System.out.println("Float: " + Float.SIZE/8);               // 4  
    System.out.println("Double: " + Double.SIZE/8);             // 8  
//  System.out.println("Boolean: " + Boolean);  
}

Java中模擬c中對sizeof的實現函數

思路：利用java中GC內存回收先後的heap size差異，得出每一個object的大小。測試

這是一個程序，java中沒有現成的sizeof的實現，緣由主要是java中的基本數據類型的大小都是固定的，因此看上去沒有必要用sizeof這個關鍵字。google

實現的想法是這樣的：java.lang.Runtime類中有一些簡單的能涉及到內存管理的函數：spa

Every Java application has a single instance of class Runtime that allows the application to interface with the environment in which the application is running. The current runtime can be obtained from the getRuntime method..net

long	freeMemory() Returns the amount of free memory in the Java Virtual Machine.
void	gc() Runs the garbage collector.
static Runtime	getRuntime() Returns the runtime object associated with the current Java application.
long	maxMemory() Returns the maximum amount of memory that the Java virtual machine will attempt to use.
void	runFinalization() Runs the finalization methods of any objects pending finalization.

使用這些簡單的內存訪問，能夠獲得內存的一些狀況，咱們經過創建一個大的某個類的數組，來查看內存用了多少，進而能夠求得類的大小。

源碼：

private static void calSize2() {
runGC();
long heap1 = 0;
final int count = 100000;
Object[] objs = new Object[count];
for(int i=-1; i<count; i++) {
Object obj = null;
obj = new Object(); // 8
// obj = new Integer( i ); // 16
// obj = new Short( (short)i ); // 16
// obj = new Long( i ); // 16
// obj = new Byte( (byte)0 ); // 16
// obj = new Character( (char)i ); // 16
// obj = new Float( i ); // 16
// obj = new Double( i ); // 16
// obj = new Boolean( true ); // 16
// obj = new String(); // 40
if(i<0){
obj = null;
runGC();
heap1 = usedMemory(); // before memory size
} else {
objs[i] = obj;
}
}
runGC();
long heap2 = usedMemory(); // after memory size
final int size = (int)Math.round( (heap2 - heap1)/(double)count );
System.out.println("heap1 = " + heap1 + "; heap2 = " + heap2);
System.out.println("heap2-heap1 = " + (heap2 - heap1) + "; "
+ objs[0].getClass().getSimpleName()
+ " size = " + size);
for(int i=0; i<count; i++) {
objs[i] = null;
}
objs = null;
runGC();
}
private static void runGC() {
for(int i=0; i<4; i++) {
long usedMem1 = usedMemory();
long usedMem2 = Long.MAX_VALUE;
for(int j=0; (usedMem1<usedMem2) && (j<500); j++) {
rTime.runFinalization();
rTime.gc();
Thread.yield();
usedMem2 = usedMem1;
usedMem1 = usedMemory();
}
}
}
private static long usedMemory() {
return rTime.totalMemory() - rTime.freeMemory();
}

注意：Object[] objects = new Object[count];

只是分配了數組空間，沒有分配對象的空間。數組中只有引用而已。

結論：下代碼測試基本對象時，得出的結果象下面：

Object obj = null;
obj = new Object(); // 8
obj = new Integer( i ); // 16
obj = new Short( (short)i ); // 16
obj = new Long( i ); // 16
obj = new Byte( (byte)0 ); // 16
obj = new Character( (char)i ); // 16
obj = new Float( i ); // 16
obj = new Double( i ); // 16
obj = new Boolean( true ); // 16
obj = new String(); // 40
怎麼會這樣呢？？？解釋以下：

這個例子寫的很好,正好說明了java中基本類型封裝對象所佔內存的大小.
1.簡單的Object對象要佔用8個字節的內存空間，由於每一個實例都至少必須包含一些最基本操做,好比:wait()/notify(),equals(), hashCode()等
2.使用Integer對象佔用了16個字節,而int佔用4個字節,說了封裝了以後內存消耗大了4倍。
3.那麼Long看起來比Integer對象應該使用更多空間,結果Long所佔的空間也是16個字節.
那麼就正好說明了JVM的對於基本類型封裝對象的內存分配的規則是以下:
Object所佔內存(8個字節) + 最大基本類型(long)所佔內存(8個字節) = 16字節.

Object所佔內存(8個字節) + int所佔內存(4個字節) = 12字節 + 補充4字節 = 16字節.