Java应用上线前，常常需要估算所需的内存，从而设置正确的内存选项参数。正确计算Java对象所占内存从而估算应用的整体所占内存，就显得很有必要。那么，如何计算Java对象所占的内存呢？
1.Java对象的内存布局
计算Java对象所占内存，首先需要了解Java对象的内存布局。一个Java对象在内存中可以分为三部分：对象头、实例数据和对齐填充。关于对象头的详细介绍可查看这篇文章；实例数据即Java的成员字段，包括基本类型和对象引用；对齐填充并不必须存在，只用作占位对齐字节。一个对象的内存布局示意如下：
|---------------------------|-----------------|---------|
| Object Header | Instance Data | Padding |
|-----------|---------------|-----------------|---------|
| Mark Word | Klass Pointer | field1|filed2| | Padding |
|-----------|---------------|-----------------|---------|
需要注意以下几点：
- 对象默认以8字节对齐，即对象所占空间必须是8的整数倍。默认对齐字节数可以使用选项-XX:ObjectAlignmentInBytes=num设置，最小值为8，最大值为256。
- 为了避免空间浪费，实例数据会进行重排序，排序的优先级为： long = double > int = float > char = short > byte > boolean > object reference。
- 继承体系里不同类的字段不会混合在一起，父类成员字段分配之后才会分配子类，每个类里的字段遵循第2条规则。
- 继承体系里不同类间需要8字节对齐。
- 在继承体系中，父类层次中有至少4字节的空闲而子类含有4字节及其以下的字段，将按优先级：int = float > char = short > byte > boolean > object reference填充这4字节。对象头部如果有剩余也会使用该规则填充。
2.内存布局实例研究
为了方便的研究对象所占的内存，建议使用官方提供的jol工具，如果使用Maven，只需加入如下依赖：
<dependency>
<groupId>org.openjdk.jol</groupId>
<artifactId>jol-core</artifactId>
<version>0.9</version>
</dependency>
然后便可以愉快的查看内存布局了：
public static void main(String[] args) {
System.out.println(ClassLayout.parseClass(Object.class).toPrintable());
System.out.println(ClassLayout.parseInstance(new Integer(1)).toPrintable());
}
上述代码第一行的输出如下（JDK8 64 bit）：
java.lang.Object object internals:
OFFSET SIZE TYPE DESCRIPTION VALUE
0 12 (object header) N/A
12 4 (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
由于目前的计算机基本为64位架构，所以忽略32位JVM，只对64位进行讨论。由于JDK8以后默认开启-XX:CompressedOops选项，所以上述为开启指针压缩的结果。
2.1 int VS Integer
Java中，一个int占4个字节，那么Integer对象占多少字节呢？Integer对象中只有一个value字段用于存储实际的整数。不开启指针压缩时，其布局为：
|-------------------------------------------|----------------|-----------------|
| Object Header | Instance Data | Padding |
|-------------------|-----------------------|----------------|-----------------|
| Mark Word(8 byte) | Klass Pointer(8 byte) | value(4 byte) | Padding(4 byte) |
|-------------------|-----------------------|----------------|-----------------|
开启指针压缩时，内存布局为：
|-------------------------------------------|----------------|
| Object Header | Instance Data |
|-------------------|-----------------------|----------------|
| Mark Word(8 byte) | Klass Pointer(4 byte) | value(4 byte) |
|-------------------|-----------------------|----------------|
可知如果不开启指针压缩，一个Integer对象需要占用24字节，就算开启指针压缩也需要占用16字节，是int的四倍多。Integer的内存占用超出想象，由此在Java中产生了许多优化方案。考虑Java集合，其中的对象泛型不支持基本数据类型，而只能使用Integer，Long等包装器类，这样将会耗费过多的内存。为了节约内存，一些开源工具支持基本类型的容器，比如：Koloboke。
2.2 字段重排序
为了更高效的使用内存，实例数据字段将会重排序。排序的优先级为： long = double > int = float > char = short > byte > boolean > object reference。如下所示的类：
class FieldTest{
byte a;
int c;
boolean d;
long e;
Object f;
}
将会重排序为（开启CompressedOops选项）：
OFFSET SIZE TYPE DESCRIPTION
16 8 long FieldTest.e
24 4 int FieldTest.c
28 1 byte FieldTest.a
29 1 boolean FieldTest.d
30 2 (alignment/padding gap)
32 8 java.lang.Object FieldTest.f
2.3 继承体系的布局
继承体系中，类间不混排，而是独立分隔开，但每个类中的字段遵循前述的优先级。如下的类：
class Father {
int a;
int b;
long c;
}
class Child extends Father {
long d;
}
重排序的结果为：
OFFSET SIZE TYPE DESCRIPTION
16 8 long Father.c
24 4 int Father.a
28 4 int Father.b
32 8 long Child.d
不开启指针压缩时，如果继承体系中的类字段没有占满8字节，将补齐字节对齐8字节。如下的类：
class Father {
long a;
byte b;
byte c;
}
class Child extends Father {
long d;
byte e;
}
重排序的结果为：
OFFSET SIZE TYPE DESCRIPTION
16 8 long Father.a
24 1 byte Father.b
25 1 byte Father.c
26 6 (alignment/padding gap)
32 8 long Child.d
40 1 byte Child.e
41 7 (alignment/padding gap)
开启指针压缩时，情况稍有不同：如果父类层次中有至少4字节的空闲，则子类中如果含有4字节及其以下的字段，将按优先级：int = float > char = short > byte > boolean > object reference填充。开启指针压缩时，由于对象头只有12字节，剩余的4字节也将按这样的规则填充。如下的类：
class Father {
byte b;
long a;
byte c;
}
class Child extends Father {
byte e;
long d;
}
重排序的结果为：
OFFSET SIZE TYPE DESCRIPTION
12 1 byte Father.b
13 1 byte Father.c
14 2 (alignment/padding gap)
16 8 long Father.a
24 8 long Child.d
32 1 byte Child.e
33 7 (alignment)
2.4 非静态内部类
非静态内部类隐含一个指向外部类对象的引用，如下的类：
class Outer {
int a;
Inner i;
class Inner{
int b;
}
}
其中Inner的字段排序结果为：
OFFSET SIZE TYPE DESCRIPTION
0 12 (object header)
12 4 int Inner.b
16 4 Outer Inner.this$0
20 4 (loss due to the next object alignment)
可见其中的隐含引用，这也就是能使用Inner.this引用外部对象的原因。
3.估算应用所占内存
明白了这些，那么估算应用所占内存便成为可能。一个应用使用如下的数据结构存储数据：
HashMap<Integer, String> cache = new HashMap<Integer, String>();
该应用有约100万数据，其中每个String的长度约为50，该应用大约占用多少内存呢？假设该应用运行在64位JVM上，开启CompressedOops选项。
由前述分析知：一个Integer占用16字节。那么长度为50的字符串占用多少字节呢？String的数据结构如下：
public final class String {
private int hash; // Default to 1
private final char value[];
}
其中含有一个int值和字符数组，而数组的对象头中含有一个4字节的长度字段，故对象头部为16字节。该String对象的内存布局示意如下：
可知，长度为50的字符串占用24+120=144字节的空间。
估计HashMap大小的关键是估算
Entry的大小，它的数据结构如下：
static class Entry<K,V> implements Map.Entry<K,V> {
final K key; // 引用
V value; // 引用
Entry<K,V> next; // 引用
int hash;
}
可知一个Entry所占内存为：12B对象头+16B实例数据+4B对齐填充，共占用32字节。由于含有100万条数据，故将创建100万个Entry。由此可估算所占内存为：100万Integer、100万String和100万Entry，忽略HashMap的其他小额占用，最终占用内存：
(16 + 144 + 32) * 1 000 000 ≈ 192 MB
使用visual vm工具进行监控的实际数据如下：
附相关资料：
Java对象结构及大小计算
Java Object Memory Structure
Java数据对齐讨论
jdk jol工具
