每日一句

世界上没有一段弯路是白走的，好像那都是人生必须经历的，可能有时候弯子大一点，内心痛苦也会多一点。

内容简介

本文深入分析并验证了不同 Java 对象占用内存空间大小的情况。对于不同的 jvm 实现，Java 对象占用的内存空间大小可能不尽相同，本文主要分析 HotSpot jvm 中的情况，实验环境为 64 位 window10 系统、JDK1.8。

对象头

在 64 位机器上，默认不开启指针压缩（-XX:-UseCompressedOops）的情况下，对象头占用 16bytes，开启指针压缩（-XX:+UseCompressedOops）则占用 12bytes。

实例数据

原生类型（primitive type）的内存占用如下：

对象引用（reference）类型在 64 位机器上，关闭指针压缩时占用 8bytes， 开启时占用 4bytes。

对齐填充

Java 对象占用空间是 8 字节对齐的，即所有 Java 对象占用 bytes 数必须是 8 的倍数。包含两个属性的对象：int 和 byte，并不是占用 17bytes(12+4+1)，而是占用 24bytes（对 17bytes 进行 8 字节对齐）

对象内存占用（前提回顾）

首先根据以上的计算规则，进行一个简单的验证。使用下面的程序进行验证：

public class Test {    public static void main(String[] args) throws InterruptedException {        TestObject testObject = new TestObject();        Thread.sleep(600 * 1000);        System.out.println(testObject);    }}
class TestObject {    private int i;    private double d;    private char[] c;    public TestObject() {        this.i = 1;        this.d = 1.0;        this.c = new char[]{'a', 'b', 'c'};    }}

TestObject 对象有四个属性，分别为 int, double, Byte, char[]类型。在打开指针压缩(-XX:+UseCompressedOops)的情况下，在 64 位机器上，TestObject 占用的内存大小应为：

12(Header) + 4byte(int) + 8byte(double) + 4byte(reference) = 28 (bytes)，加上 4byte 对齐（padding），最终的大小应为 32bytes。

当指针压缩关闭时(-XX:-UseCompressedOops)，在 64 位机器上，TestObject 占用的内存大小应为：

16(Header) + 4(int) + 8(double) + 8(reference) = 36 (bytes)，4 字节对齐后为 40 bytes。

包装类型

包装类（Boolean/Byte/Short/Character/Integer/Long/Double/Float）占用内存的大小等于对象头大小加上底层基础数据类型的大小。

包装类型的对象内存占用情况如下：

数组

64 位机器上，数组对象的对象头占用 24 bytes，启用压缩后占用 16 字节。比普通对象占用内存多是因为需要额外的空间存储数组的长度。

• 基础数据类型数组占用的空间包括数组对象头以及基础数据类型数据占用的内存空间。

• 对象数组中存放的是对象的引用，所以对象数组本身的大小=数组对象头+length * 引用指针大小，总大小为对象数组本身大小+存放的数据的大小之和。

举两个例子：

int[10]：

开启压缩：16（12Byte(8[标记字段]+4[类型指针])+4[数组长度大小]） + 10(大小) * 4(32bit 的整数类型) = 56 bytes；

关闭压缩：24（16Byte(8[标记字段]+8[类型指针])+4[数组长度大小]+4[padding]） + 10 * 4(32bit 的整数类型) = 64bytes

new Integer[3]:

关闭压缩：

Integer 数组本身：24(header) + 3 * 8(Integer reference) = 48 bytes;

总共：48 + 3 * 24(Integer) = 120 bytes。

开启压缩：

Integer 数组本身：16(header) + 3 * 4(Integer reference) = 28+4(padding) -> 32 (bytes)

总共：32 + 3 * 16(Integer)[12byte 的对象头+4byte 的引用 reference] = 80 (bytes)

String

在 JDK1.7 及以上版本中，String 包含 2 个属性，一个用于存放字符串数据的 char[], 一个 int 类型的 hashcode, 部分源代码如下：

public final class String    implements java.io.Serializable, Comparable<String>, CharSequence {    /** The value is used for character storage. */    private final char value[];    /** Cache the hash code for the string */    private int hash; // Default to 0}

因此，在关闭指针压缩时，一个 String 本身需要 16(Header) + 8(char[] reference) + 4(int) = 32 bytes。

除此之外，一个 char[]占用 24byte（其中有 4byte 的对齐 padding） + length * 2 bytes(8 字节对齐), 即一个 String 占用的内存空间大小为：

56 + length * 2 bytes（char 的 18bit） (8 字节对齐)。

举几个例子。

一个空字符串("")的大小应为：56 + 0 * 2 bytes = 56 bytes。

字符串"abc"的大小应为：56 + 3 * 2 = 62(8 字节对齐)->64 (bytes)

字符串"abcde"的大小应为：56 + 5 * 2 = 66->72 (bytes)

字符串"abcde"在开启指针压缩时的大小为：

String 本身：12(Header) + 4(char[] reference) + 4(int hash) = 20(padding) -> 24 (bytes);

存储数据：16(char[] header) + 5 * 2 = 26(padding) -> 32 (bytes)

总共：24 + 32 = 56 (bytes)