写在转载文章前面：
在项目中遇到了诡异的内存占用过高的问题，其实搬到服务器上内存也够，但是某位大神还是锲而不舍的追求问题本质，于是我们学习了这篇文章。
项目中读了一个1.7G的词向量文件（对，用Java搞NLP），文件每行为一个词语及300维度的词向量，自然是要存为一个hashmap，便于查找；
诡异的是这个map整体上似乎占用了过高的内存（>6G），导致在16G的台式机上跑不动。
最后我们查到本质的原因是 hashmap 为 String（词语）：ArrayList<Double>（词向量），问题在于这个封装类型Double；
众所周知啊，double占8b，但是list<>里只能用封装类型，所以用了Double，然后Double竟然占用24b，在本项目这个场景下，60w*300的double数据就生生扩大了两三倍的存储空间。
我们学习一下这篇文章了解一下吧。
当然最后的解决方案是 hashmap 为String：WordVector，其中WordVector就是把double[] 这个数组封装了一下。最后占用的内存基本相当于文件大小了。
为什么写这篇文章？
其实一般的程序猿根本不用了解这么深，只有当你到了一定层次，需要了解jvm内部运行机制，或者高并发多线程下，你写的代码对内存有影响，你想做性能优化。。。等等等等，一句话，当你想深入了解java对象在内存中，如何存储，或者每个对象占用多大空间时，你会感谢这篇文章
本文主要分析jvm中的情况，实验环境为64位window10系统、JDK1.8，使用JProfiler进行结论验证
很多描述以及 概念是基于你懂基本java知识的，如果你看起来有点吃力，要加油咯
本片更偏重验证，更多理论，请参考：https://segmentfault.com/a/1190000006933272
接下来用JProfiler验证：
新建一个空对象，观察空对象内存占用 1 2 public class TestObject { }对象占用内存 16b，如图
结论：一般自建空对象占用内存 16b，16 = 12 + 4
在TestObj中新增一个 int 属性，观察对象内存占用 1 2 3 4 public class TestObj { private int i; }对象占用内存 16b，如图
结论：int 占用 4b， 4 = 16 -12
在TestObj中新增一个 long 属性，观察对象内存占用 1 2 3 4 public class TestObj { private long i; }对象占用内存 24b，如图
结论：long 占用 8b， 8 = 24 -12 - 4
其余基本类型可以参照以上自行验证，原理一样
包装类（Boolean/Byte/Short/Character/Integer/Long/Double/Float）占用内存的大小等于对象头大小加上底层基础数据类型的大小。
类型占用空间Boolean、Byte16byteShort、Char16byteInteger、Float16byteLong、Double24byte 在TestObj中新增一个 Integer 属性，观察对象内存占用 1 2 3 4 public class TestObj { private Integer i =128; }对象占用内存 32b，如图
结论：Integer 占用 16b， 16 = 32 - 16
特别的：-128~127 之间的封装类型，只占用 4b**
在TestObj中新增一个 Long 属性，观察对象内存占用 1 2 3 4 public class TestObj { private Long l = new Long(1); }对象占用内存 40b，如图
结论：Long 占用 24b， 16 = 40 - 16
其余包装类型可以参照以上自行验证，原理一样
64位机器上，数组对象的对象头占用24 bytes，启用压缩后占用16字节。比普通对象占用内存多是因为需要额外的空间存储数组的长度（普通16b-12b）。
对象数组本身的大小=数组对象头 + length * 存放单个元素大小
在TestObj中新增一个 char[] 属性，观察对象内存占用 1 2 3 4 public class TestObj { private char[] c = {'a','b','c'}; }对象占用内存 40b，如图
结论：char[3] 占用 24b， 24 = 40 - 16，24 = 16 + 3 * 2 + 2
封装类型数组比基本类型的数组，需要多管理元素的引用
对象数组本身的大小=数组对象头+length 引用指针大小 + length 存放单个元素大小
在TestObj中新增一个 Integer[] 属性，观察对象内存占用 1 2 3 4 public class TestObj { private Integer[] i = {128,129,130}; }对象占用内存 80b，如图
结论：Integer[3] 占用 80b， 80 = 96 - 16 , 80 = 16 + 3 4 + 3 16 +4
对象占用内存 40b，如图
结论：String 本身占用 24b， 24 = 40 -16，另外，String的属性value还需要 16b，也就是说空””也需要16b
注意：这里为什么要写String s = new String(“”)？请自己思考，不写会怎么样？
答：如果写成String s = “”，是不会再堆中开辟内存的，也就看不到String占用的空间，你看到的将会是下面的，至于为什么，都是因为final
这些参考文章开头提到的那篇文章，下面给出计算公式：
一个ArrayList实例本身的的大小为：12(header) + 4(modCount) + 4(size) + 4(elementData reference) = 24 (bytes)
下面分析一个只有一个Integer(1)元素的ArrayList实例占用的内存大小。
ArrayList<Integer> testList = Lists.newArrayList(); testList.add(1);根据上面对ArrayList原理的介绍，当调用add方法时，ArrayList会初始化一个默认大小为10的数组，而数组中保存的Integer(1)实例大小为16 bytes。
则testList占用的内存大小为：
24(ArrayList itselft) + 16(elementData array header) + 10 * 4(elemetData reference) + 16(Integer) = 96 (bytes)
JProfiler中的结果验证了上述分析：
2. HashMap内存占用
这里分析一个只有一组键值对的HashMap, 结构如下：
Map<Integer, Integer> testMap = Maps.newHashMap(); testMap.put(1, 2);
首先分析HashMap本身的大小。HashMap对象拥有的属性包括：
/** * The table, initialized on first use, and resized as * necessary. When allocated, length is always a power of two. * (We also tolerate length zero in some operations to allow * bootstrapping mechanics that are currently not needed.) */ transient Node<K,V>[] table; /** * Holds cached entrySet(). Note that AbstractMap fields are used * for keySet() and values(). */ transient Set<Map.Entry<K,V>> entrySet; /** * The number of key-value mappings contained in this map. */ transient int size; /** * The number of times this HashMap has been structurally modified * Structural modifications are those that change the number of mappings in * the HashMap or otherwise modify its internal structure (e.g., * rehash). This field is used to make iterators on Collection-views of * the HashMap fail-fast. (See ConcurrentModificationException). */ transient int modCount; /** * The next size value at which to resize (capacity * load factor). * * @serial */ // (The javadoc description is true upon serialization. // Additionally, if the table array has not been allocated, this // field holds the initial array capacity, or zero signifying // DEFAULT_INITIAL_CAPACITY.) int threshold; /** * The load factor for the hash table. * * @serial */ final float loadFactor;HashMap继承了AbstractMap<K,V>, AbstractMap有两个属性：
transient Set<K> keySet; transient Collection<V> values;所以一个HashMap对象本身的大小为：
12(header) + 4(table reference) + 4(entrySet reference) + 4(size) + 4(modCount) + 4(threshold) + 8(loadFactor) + 4(keySet reference) + 4(values reference) = 48(bytes)
接着分析testMap实例在总共占用的内存大小。 根据上面对HashMap原理的介绍，可知每对键值对对应一个Node对象。根据上面的Node的数据结构，一个Node对象的大小为：
12(header) + 4(hash reference) + 4(key reference) + 4(value reference)+ 4(next pointer reference) = 28 (padding) -> 32(bytes)
加上Key和Value两个Integer对象，一个Node占用内存总大小为：32 + 2 * 16 = 64(bytes)
JProfiler中结果：
下面分析HashMap的Node数组的大小。 根据上面HashMap的原理可知，在不指定容量大小的情况下，HashMap初始容量为16，所以testMap的Node[]占用的内存大小为：
16(header) + 16 * 4(Node reference) + 64(Node) = 144(bytes)
JProfile结果：
所以，testMap占用的内存总大小为：
48(map itself) + 144(Node[]) = 192(bytes)
JProfile结果：
这里只用一个例子说明如何对HashMap进行占用内存大小的计算，根据HashMap初始化容量的大小，以及扩容的影响，HashMap占用内存大小要进行具体分析， 不过思路都是一致的。
