java中的各类数据类型在内存中存储的方式

转载自：http://blog.csdn.net/aaa1117a8w5s6d/article/details/8251456

1.java是如何管理内存的

java的内存管理就是对象的分配和释放问题。（其中包括两部分）

分配：内存的分配是由程序完成的，程序员须要经过关键字new为每一个对象申请内存空间(基本类型除外)，全部的对象都在堆(Heap)中分配空间。
释放：对象的释放是由垃圾回收机制决定和执行的，这样作确实简化了程序员的工做。但同时，它也加剧了JVM的工做。由于，GC为了可以正确释放对象，GC必须监控每个对象的运行状态，包括对象的申请、引用、被引用、赋值等，GC都须要进行监控。

2.什么叫java的内存泄露

在java中，内存泄漏就是存在一些被分配的对象，这些对象有下面两个特色，首先，这些对象是可达的，即在有向图中，存在通路能够与其相连（也就是说仍存在该内存对象的引用）；其次，这些对象是无用的，即程序之后不会再使用这些对象。若是对象知足这两个条件，这些对象就能够断定为Java中的内存泄漏，这些对象不会被GC所回收，然而它却占用内存。

3.JVM的内存区域组成

java把内存分两种：一种是栈内存，另外一种是堆内存
(1)在函数中定义的基本类型变量和对象的引用变量都在函数的栈内存中分配；
(2)堆内存用来存放由new建立的对象和数组以及对象的实例变量。在函数（代码块）中定义一个变量时，java就在栈中为这个变量分配内存空间，当超过变量的做用域后，java会自动释放掉为该变量所分配的内存空间；在堆中分配的内存由java虚拟机的自动垃圾回收器来管理
堆和栈的优缺点

堆的优点是能够动态分配内存大小，生存期也没必要事先告诉编译器，由于它是在运行时动态分配内存的。

缺点就是要在运行时动态分配内存，存取速度较慢；栈的优点是，存取速度比堆要快，仅次于直接位于CPU中的寄存器。

另外，栈数据能够共享。但缺点是，存在栈中的数据大小与生存期必须是肯定的，缺少灵活性。

4.java中数据在内存中是如何存储的

a)基本数据类型

java的基本数据类型共有8种，即int,short,long,byte,float,double,boolean,char(注意，并无String的基本类型 )。这种类型的定义是经过诸如int a = 3；long b = 255L；的形式来定义的。如int a = 3；这里的a是一个指向int类型的引用，指向3这个字面值。这些字面值的数据，因为大小可知，生存期可知(这些字面值定义在某个程序块里面，程序块退出后，字段值就消失了)，出于追求速度的缘由，就存在于栈中。

另外，栈有一个很重要的特殊性，就是存在栈中的数据能够共享。好比：
咱们同时定义：

int a=3;
int b=3;

编译器先处理int a = 3；首先它会在栈中建立一个变量为a的引用，而后查找有没有字面值为3的地址，没找到，就开辟一个存放3这个字面值的地址，而后将a指向3的地址。接着处理int b = 3；在建立完b这个引用变量后，因为在栈中已经有3这个字面值，便将b直接指向3的地址。这样，就出现了a与b同时均指向3的状况。

定义完a与b的值后，再令a = 4；那么，b不会等于4，仍是等于3。在编译器内部，遇到时，它就会从新搜索栈中是否有4的字面值，若是没有，从新开辟地址存放4的值；若是已经有了，则直接将a指向这个地址。所以a值的改变不会影响到b的值。

b)对象

在java中，建立一个对象包括对象的声明和实例化两步，下面用一个例题来讲明对象的内存模型。假设有类Rectangle定义以下：

1. public class Rectangle {
2. double width;
3. double height;
4. public Rectangle( double w, double h){
5. w = width;
6. h = height;
7. }
8. }

(1)声明对象时的内存模型
用Rectangle rect；声明一个对象rect时，将在栈内存为对象的引用变量rect分配内存空间，但Rectangle的值为空，称rect是一个空对象。空对象不能使用，由于它尚未引用任何”实体”。
(2)对象实例化时的内存模型
当执行rect=new Rectangle(3,5)；时，会作两件事：在堆内存中为类的成员变量width,height分配内存，并将其初始化为各数据类型的默认值；接着进行显式初始化（类定义时的初始化值）；最后调用构造方法，为成员变量赋值。返回堆内存中对象的引用（至关于首地址）给引用变量rect,之后就能够经过rect来引用堆内存中的对象了。

c)建立多个不一样的对象实例

一个类经过使用new运算符能够建立多个不一样的对象实例，这些对象实例将在堆中被分配不一样的内存空间，改变其中一个对象的状态不会影响其余对象的状态。例如：

1. Rectangle r1= new Rectangle(3,5);
2. Rectangle r2= new Rectangle(4,6);

此时，将在堆内存中分别为两个对象的成员变量 width 、 height 分配内存空间，两个对象在堆内存中占据的空间是互不相同的。若是有：

1. Rectangle r1=new Rectangle(3,5);
2. Rectangle r2=r1;

则在堆内存中只建立了一个对象实例，在栈内存中建立了两个对象引用，两个对象引用同时指向一个对象实例。

d)包装类

基本类型都有对应的包装类：如int对应Integer类，double对应Double类等，基本类型的定义都是直接在栈中，若是用包装类来建立对象，就和普通对象同样了。例如：int i=0；i直接存储在栈中。Integer i（i此时是对象）= new Integer(5)；这样，i对象数据存储在堆中，i的引用存储在栈中，经过栈中的引用来操做对象。

e)String

String是一个特殊的包装类数据。能够用如下两种方式建立：String str = new String(“abc”)；String str = “abc”;
第一种建立方式，和普通对象的的建立过程同样；
第二种建立方式，java内部将此语句转化为如下几个步骤：
(1)先定义一个名为str的对String类的对象引用变量：String str；
(2)在栈中查找有没有存放值为”abc”的地址，若是没有，则开辟一个存放字面值为”abc”
地址，接着建立一个新的String类的对象o，并将o的字符串值指向这个地址，并且在栈
这个地址旁边记下这个引用的对象o。若是已经有了值为”abc”的地址，则查找对象o，并
回o的地址。
(3)将str指向对象o的地址。
值得注意的是，通常String类中字符串值都是直接存值的。但像String str = “abc”；这种
合下，其字符串值倒是保存了一个指向存在栈中数据的引用。
为了更好地说明这个问题，咱们能够经过如下的几个代码进行验证。

1. String str1="abc"；
2. String str2="abc"；
3. System.out.println(s1==s2)；//true

注意，这里并不用 str1.equals(str2)；的方式，由于这将比较两个字符串的值是否相等。==号，根据JDK的说明，只有在两个引用都指向了同一个对象时才返回真值。而咱们在这里要看的是，str1与str2是否都指向了同一个对象。
咱们再接着看如下的代码。

1. String str1= new String("abc")；
2. String str2= "abc"；
3. System.out.println(str1==str2)；//false

建立了两个引用。建立了两个对象。两个引用分别指向不一样的两个对象。
以上两段代码说明，只要是用new()来新建对象的，都会在堆中建立，并且其字符串是单独存值的，即便与栈中的数据相同，也不会与栈中的数据共享。

f)数组

当定义一个数组，int x[]；或int[] x；时，在栈内存中建立一个数组引用，经过该引用（即数组名）来引用数组。x=new int[3]；将在堆内存中分配3个保存 int型数据的空间，堆内存的首地址放到栈内存中，每一个数组元素被初始化为0。

g)静态变量

用static的修饰的变量和方法，其实是指定了这些变量和方法在内存中的”固定位置”－static storage，能够理解为全部实例对象共有的内存空间。static变量有点相似于C中的全局变量的概念；静态表示的是内存的共享，就是它的每个实例都指向同一个内存地址。把static拿来，就是告诉JVM它是静态的，它的引用（含间接引用）都是指向同一个位置，在那个地方，你把它改了，它就不会变成原样，你把它清理了，它就不会回来了。

那静态变量与方法是在何时初始化的呢？对于两种不一样的类属性，static属性与instance属性，初始化的时机是不一样的。instance属性在建立实例的时候初始化，static属性在类加载，也就是第一次用到这个类的时候初始化，对于后来的实例的建立，再也不次进行初始化。

咱们常可看到相似如下的例子来讲明这个问题：

1. class Student{
2. static int numberOfStudents =0;
3. Student()
4. {
5. numberOfStudents ++;
6. }
7. }

每一次建立一个新的Student实例时,成员numberOfStudents都会不断的递增,而且全部的Student实例都访问同一个numberOfStudents变量,实际上intnumberOfStudents变量在内存中只存储在一个位置上。

5.java的内存管理实例

Java程序的多个部分(方法，变量，对象)驻留在内存中如下两个位置：即堆和栈，如今咱们只关心三类事物：实例变量，局部变量和对象：
实例变量和对象驻留在堆上
局部变量驻留在栈上
让咱们查看一个 java 程序，看看他的各部分如何建立而且映射到栈和堆中：

1. public class Dog {
2. Collar c;
3. String name;
4. //1.main()方法位于栈上
5. public static void main(String[] args) {
6. //2.在栈上建立引用变量d,但Dog对象还没有存在
7. Dog d;
8. //3.建立新的Dog对象，并将其赋予d引用变量
9. d = new Dog();
10. //4.将引用变量的一个副本传递给go()方法
11. d.go(d);
12. }
13. //5.将go()方法置于栈上，并将dog参数做为局部变量
14. void go(Dog dog){
15. //6.在堆上建立新的Collar对象，并将其赋予Dog的实例变量
16. c = new Collar();
17. }
18. //7.将setName()添加到栈上，并将dogName参数做为其局部变量
19. void setName(String dogName){
20. //8.name的实例对象也引用String对象
21. name =dogName;
22. }
23. //9.程序执行完成后，setName()将会完成并从栈中清除，此时，局部变量dogName也会消失，尽管它所引用的String仍在堆上
24. }

6. 垃圾回收机制

问题一：什么叫垃圾回收机制？
垃圾回收是一种动态存储管理技术，它自动地释放再也不被程序引用的对象，按照特定的垃圾收集算法来实现资源自动回收的功能。当一个对象再也不被引用的时候，内存回收它占领的空间，以便空间被后来的新对象使用，以避免形成内存泄露。

问题二：java的垃圾回收有什么特色？
jAVA语言不容许程序员直接控制内存空间的使用。内存空间的分配和回收都是由JRE负责在后台自动进行的，尤为是无用内存空间的回收操做(garbagecollection,也称垃圾回收)，只能由运行环境提供的一个超级线程进行监测和控制。

问题三：垃圾回收器何时会运行？
通常是在CPU空闲或空间不足时自动进行垃圾回收，而程序员没法精确控制垃圾回收的时机和顺序等。、

问题四：什么样的对象符合垃圾回收条件？
当没有任何得到线程能访问一个对象时，该对象就符合垃圾回收条件。

问题五：垃圾回收器是怎样工做的？
垃圾回收器如发现一个对象不能被任何活线程访问时，他将认为该对象符合删除条件，就将其加入回收队列，但不是当即销毁对象，什么时候销毁并释放内存是没法预知的。垃圾回收不能强制执行，然而java提供了一些方法（如：System.gc()方法），容许你请求JVM执行垃圾回收，而不是要求，虚拟机会尽其所能知足请求，可是不能保证JVM从内存中删除全部不用的对象。

问题六：一个java程序可以耗尽内存吗？
能够。垃圾收集系统尝试在对象不被使用时把他们从内存中删除。然而，若是保持太多活的对象，系统则可能会耗尽内存。垃圾回收器不能保证有足够的内存，只能保证可用内存尽量的获得高效的管理。

问题七：如何显示的使对象符合垃圾回收条件？
(1)空引用：当对象没有对他可到达引用时，他就符合垃圾回收的条件。也就是说若是没有对他的引用，删除对象的引用就能够达到目的，所以咱们能够把引用变量设置为null，来符合垃圾回收的条件。

1. StringBuffer sb = new StringBuffer("hello");
2. System.out.println(sb);
3. sb= null;

(2)从新为引用变量赋值：能够经过设置引用变量引用另外一个对象来解除该引用变量与一个对象间的引用关系。
StringBuffer sb1 = new StringBuffer(“hello”);
StringBuffer sb2 = new StringBuffer(“goodbye”);
System.out.println(sb1);
sb1=sb2;//此时”hello”符合回收条件
(3)方法内建立的对象：所建立的局部变量仅在该方法的做用期间内存在。一旦该方法返回，在这个方法内建立的对象就符合垃圾收集条件。有一种明显的例外状况，就是方法的返回对象。

1. public static void main(String[] args) {
2. Date d = getDate();
3. System.out.println("d="+d);
4. }
5. private static Date getDate() {
6. Date d2 = new Date();
7. StringBuffer now = new StringBuffer(d2.toString());
8. System.out.println(now);
9. return d2;
10. }

(4)隔离引用：这种状况中，被回收的对象仍具备引用，这种状况称做隔离岛。若存在这两个实例，他们互相引用，而且这两个对象的全部其余引用都删除，其余任何线程没法访问这两个对象中的任意一个。也能够符合垃圾回收条件。

1. public class Island {
2. Island i;
3. public static void main(String[] args) {
4. Island i2 = new Island();
5. Island i3 = new Island();
6. Island i4 = new Island();
7. i2. i =i3;
8. i3. i =i4;
9. i4. i =i2;
10. i2= null;
11. i3= null;
12. i4= null;
13. }
14. }

问题八：垃圾收集前进行清理——finalize()方法
java提供了一种机制，使你可以在对象刚要被垃圾回收以前运行一些代码。这段代码位于名为finalize()的方法内，全部类从Object类继承这个方法。因为不能保证垃圾回收器会删除某个对象。所以放在finalize()中的代码没法保证运行。所以建议不要重写finalize();

7.final问题

final使得被修饰的变量”不变”，可是因为对象型变量的本质是”引用”，使得”不变”也有了两种含义：引用自己的不变和引用指向的对象不变。
引用自己的不变：

1. final StringBuffer a= new StringBuffer("immutable");
2. final StringBuffer b= new StringBuffer("not immutable");
3. a=b;//编译期错误
4. final StringBuffer a=new StringBuffer("immutable");
5. final StringBuffer b=new StringBuffer("not immutable");

a=b;//编译期错误

引用指向的对象不变：

1. final StringBuffer a= new StringBuffer("immutable");
2. a.append（"broken!");//编译经过
3. final StringBuffer a=new StringBuffer("immutable");
4. a.append("broken!");//编译经过

可见，final只对引用的”值”(也即它所指向的那个对象的内存地址)有效，它迫使引用只能指向初始指向的那个对象，改变它的指向会致使编译期错误。至于它所指向的对象的变化，final是不负责的。这很相似==操做符：==操做符只负责引用的”值”相等，至于这个地址所指向的对象内容是否相等，==操做符是无论的。在举一个例子：

1. public class Name {
2. private String firstname;
3. private String lastname;
4. public String getFirstname() {
5. return firstname;
6. }
7. public void setFirstname(String firstname) {
8. this.firstname = firstname;
9. }
10. public String getLastname() {
11. return lastname;
12. }
13. public void setLastname(String lastname) {
14. this.lastname = lastname;
15. }
16. }
17.  
18. public class Name {
19. private String firstname;
20. private String lastname;
21. public String getFirstname() {
22. return firstname;
23. }
24. public void setFirstname(String firstname) {
25. this.firstname = firstname;
26. }
27. public String getLastname() {
28. return lastname;
29. }
30. public void setLastname(String lastname) {
31. this.lastname = lastname;
32. }
33. }

编写测试方法：

1. public static void main(String[] args) {
2. final Name name = new Name();
3. name.setFirstname("JIM");
4. name.setLastname("Green");
5. System.out.println(name.getFirstname()+ " " +name.getLastname());
6. }
7. public static void main(String[] args) {
8. final Name name = new Name();
9. name.setFirstname("JIM");
10. name.setLastname("Green");
11. System.out.println(name.getFirstname()+" "+name.getLastname());
12. }

理解final问题有很重要的含义。许多程序漏洞都基于此—-final只能保证引用永远指向固定对象，不能保证那个对象的状态不变。在多线程的操做中，一个对象会被多个线程共享或修改，一个线程对对象无心识的修改可能会致使另外一个使用此对象的线程崩溃。一个错误的解决方法就是在此对象新建的时候把它声明为final，意图使得它”永远不变”。其实那是徒劳的.final还有一个值得注意的地方，
先看如下示例程序：

1. class Something {
2. final int i ;
3. public void doSomething() {
4. System. out .println( "i = " + i );
5. }
6. }
7. class Something {
8. final int i;
9. public void doSomething() {
10. System.out.println("i = " + i);
11. }
12. }

对于类变量，java虚拟机会自动进行初始化。若是给出了初始值，则初始化为该初始值。若是没有给出，则把它初始化为该类型变量的默认初始值。可是对于用final修饰的类变量，虚拟机不会为其赋予初值，必须在constructor(构造器)结束以前被赋予一个明确的值。能够修改成”final int i = 0;”。

8.如何把程序写得更健壮

(1)尽早释放无用对象的引用。
好的办法是使用临时变量的时候，让引用变量在退出活动域后，自动设置为null，暗示垃圾收集器来收集该对象，防止发生内存泄露。对于仍然有指针指向的实例，jvm就不会回收该资源,由于垃圾回收会将值为null的对象做为垃圾，提升GC回收机制效率；

(2)定义字符串应该尽可能使用String str=”hello”;的形式，避免使用String str = new String(“hello”);的形式。由于要使用内容相同的字符串，没必要每次都new一个String。例如咱们要在构造器中对一个名叫s的String引用变量进行初始化，把它设置为初始值，应当这样作：

1. public class Demo {
2. private String s;
3. public Demo() {
4. s = "Initial Value";
5. }
6. }
7.  
8. public class Demo {
9. private String s;
10. ...
11. public Demo {
12. s = "Initial Value";
13. }
14. ...
15. }
16. 而非
17. s =  new  String("Initial Value");
18. s = new String("Initial Value");

后者每次都会调用构造器，生成新对象，性能低下且内存开销大，而且没有意义，由于String对象不可改变，因此对于内容相同的字符串，只要一个String对象来表示就能够了。也就说，屡次调用上面的构造器建立多个对象，他们的String类型属性s都指向同一个对象。

(3)咱们的程序里不可避免大量使用字符串处理，避免使用String，应大量使用StringBuffer，由于String被设计成不可变(immutable)类，因此它的全部对象都是不可变对象，请看下列代码；

1. String s = "Hello";
2. s = s + " world!";
3. String s = "Hello";
4. s = s + " world!";

在这段代码中，s原先指向一个String对象，内容是”Hello”，而后咱们对s进行了+操做，那么s所指向的那个对象是否发生了改变呢？答案是没有。这时，s不指向原来那个对象了，而指向了另外一个String对象，内容为”Hello world!”，原来那个对象还存在于内存之中，只是s这个引用变量再也不指向它了。

经过上面的说明，咱们很容易导出另外一个结论，若是常常对字符串进行各类各样的修改，或者说，不可预见的修改，那么使用String来表明字符串的话会引发很大的内存开销。由于String对象创建以后不能再改变，因此对于每个不一样的字符串，都须要一个String对象来表示。这时，应该考虑使用StringBuffer类，它容许修改，而不是每一个不一样的字符串都要生成一个新的对象。而且，这两种类的对象转换十分容易。

(4)尽可能少用静态变量，由于静态变量是全局的，GC不会回收的；

(5)尽可能避免在类的构造函数里建立、初始化大量的对象，防止在调用其自身类的构造器时形成没必要要的内存资源浪费，尤为是大对象，JVM会忽然须要大量内存，这时必然会触发GC优化系统内存环境；显示的声明数组空间，并且申请数量还极大。
如下是初始化不一样类型的对象须要消耗的时间：

运算操做	示例	标准化时间
本地赋值	i = n	1.0
实例赋值	this.i = n	1.2
方法调用	Funct()	5.9
新建对象	New Object()	980
新建数组	New int[10]	3100

从表中能够看出，新建一个对象须要980个单位的时间，是本地赋值时间的980倍，是方法调用时间的166倍，而新建一个数组所花费的时间就更多了。

(6)尽可能在合适的场景下使用对象池技术以提升系统性能，缩减缩减开销，可是要注意对象池的尺寸不宜过大，及时清除无效对象释放内存资源，综合考虑应用运行环境的内存资源限制，避免太高估计运行环境所提供内存资源的数量。

(7)大集合对象拥有大数据量的业务对象的时候，能够考虑分块进行处理，而后解决一块释放一块的策略。

(8)不要在常常调用的方法中建立对象，尤为是忌讳在循环中建立对象。能够适当的使用hashtable，vector建立一组对象容器，而后从容器中去取那些对象，而不用每次new以后又丢弃。

(9)通常都是发生在开启大型文件或跟数据库一次拿了太多的数据，形成Out Of Memory Error的情况，这时就大概要计算一下数据量的最大值是多少，而且设定所需最小及最大的内存空间值。

(10)尽可能少用finalize函数，由于finalize()会加大GC的工做量，而GC至关于耗费系统的计算能力。

(11)不要过滥使用哈希表，有必定开发经验的开发人员常常会使用hash表（hash表在JDK中的一个实现就是HashMap）来缓存一些数据，从而提升系统的运行速度。好比使用HashMap缓存一些物料信息、人员信息等基础资料，这在提升系统速度的同时也加大了系统的内存占用，特别是当缓存的资料比较多的时候。其实咱们可使用操做系统中的缓存的概念来解决这个问题，也就是给被缓存的分配一个必定大小的缓存容器，按照必定的算法淘汰不须要继续缓存的对象，这样一方面会由于进行了对象缓存而提升了系统的运行效率，同时因为缓存容器不是无限制扩大，从而也减小了系统的内存占用。如今有不少开源的缓存实现项目，好比ehcache、oscache等，这些项目都实现了FIFO 、MRU等常见的缓存算法。