Java内存解析

好久不写文章了，人懒惰了，这是很不好的行为和态度，所以今天这么好的周末先写一篇好一点的文章再说，表示安心的度过和规划好这个美好的周末，这也是热爱生活的体现之一。

最近，很迷茫，原因是不知道从哪些方面来提高自己，我的目标很简单，就是希望能够争取到明年美图网的实习机会，怎样在众多的竞争者中让别人一眼看到的，想留住你，这是我的目标，还有就是接下来参加最后一次有分量的软件开发比赛--------第四届中国软件杯；然后还有就是拿到许家印奖学金（特等)(但是就目前我的状态来说离目标还很远，主要是客观的因素也会有一点，没有经验)。实现了这三个目标，我的大学就算完美结束。Android上面学的很杂，又想往底层靠，又想真正做一个很锻炼人的App，又想参加一个真正有分量的比赛，非常纠结，10月份以来主要是在在线教育平台极客学院上学习，虚的东西很杂，但是今天突然想回归java基础的一些东西上面来，今天就讲一下java内存里面的一些东西，这个对开发来说是非常重要的，首先先靠清楚，java虚拟机到底是什么？

学到现在，java相比C++有这么两个优势（在你不真正了解计算机的一门语言或者架构的的时候不要随便去评价这是几代科学家的研究成果），从我的角度看首先，人们在用java开发应用程序的时候实际上不需要去关注计算机的内存，然而我们学过C++的都知道，C++里面是需要程序员自己去控制内存的，析构函数就是这个作用，但是再java里面内存是不需要程序员去控制的，这里的内存尤其指的是堆内存，java里里面有自己的垃圾回收器，会自动回收new出来的堆内存，不需要考虑计算机内存的申请与释放。其次是，java是跨平台的，有一个java的虚拟机jvm，这个虚拟机可以去屏蔽底层的操作系统，如图：

java的虚拟机会自动装载class文件并且执行，不需要关注操作系统，可以认为是一台虚拟的有自己和独特CPU（执行独特的字节码）和独特操作系统（不需考虑是windows还是linnux还是unix）的虚拟计算机，JVM隐藏了纷繁复杂的计算机硬件和操作系统，使我们只面对单一的支持Java的计算机。编译器会将源代码转换成jvm可以执行的指令序列（字节码）保存在.class文件中执行Java程序时，JVM负责解释字节码，将JVM的指令转换成真实的机器指令，并执行代码，具体的而过程如下：

java的虚拟机有类装载器，解释器，校验器等等。这上面说的两点就是我认为java比C++强的地方，但是，所谓有得必有失，java的垃圾回收器由于不知道什么时候会回收，然后java里面不断的动态申请内存空间往往会导致java的程序非常占据内存（可以不断动态申请内存无需关注释放），执行起来也比C++慢很多。

接下来看java自己的CPU的计算机的（jvm）的内存设计的情况（虚拟机）：

栈、堆、常量池等虽同属Java内存分配时操作的区域，但其适用范围和功用却大不相同。本文将深入Java核心，简单讲解Java内存分配方面的知识。

首先我们先来讲解一下内存中的各个区域。

 stack（栈）：存放基本类型的数据和对象的引用，即存放变量。

如果存放的事基本类型的数据（非静态变量），则直接将变量名和值存入stack中的内存中；

如果是引用类型，则将变量名存入栈，然后指向它new出的对象（存放在堆中）。

heap（堆）：存放new产生的数据。

data segment：分为静态域和常量域。

静态域：

存放在对象中用static定义的静态成员（即静态变量，同理，如果该静态变量是基本类型则将变量名和值存入静态域，如果是引用类型则指向new出的对象）。

常量池：

常量池指的是在编译期被确定，并被保存在已编译的.class文件中的一些数据。除了包含代码中所定义的各种基本类型（如int、long等等）和对象型（如String及数组）的常量值(final)还包含一些以文本形式出现的符号引用，比如：类和接口的全限定名；字段的名称和描述符；方法和名称和描述符。

code segment：存放代码。

 

下面我来举几个简单的小例子来让大家认识一下这几个区域具体存放的内容：

注：例1和例2中大家要注意String类型不是基本数据类型，所以它可以创建对象，并且它的值是放在常量池中的。

例1. 非静态和静态变量的创建：

String str = "abc";  static Int a = 10;  //创建String类型的变量str；创建Int类型变量a

内存解析：

这里的str是非静态变量所以将其放入到栈中，而静态变量a则需要放入静态域中，对于变量值"abc"和10则都应该放入到常量池当中

例2. 对象的创建：

String str=new String("abc");  //创建String类型的对象str

内存解析：

这里的str是String类型的对象，所以放入栈中，而new出来的东西则放入到堆中，对于初始值"abc"则放入到常量池中即可。

 

 

例3. 数组的创建

Int s[] = new Int[3];s[0]=3;s[1]=2;s[2]=3;

内存解析：

这里的s[]是一个数组变量，所以放入到栈中，new出来的东西还是放入到堆中，最后的每个元素的值则放入到常量池当中。

 

补充：

一般Java在内存分配时会涉及到以下区域：

◆寄存器：我们在程序中无法控制

◆栈：存放基本类型的数据和对象的引用，但对象本身不存放在栈中，而是存放在堆中

◆堆：存放用new产生的数据

◆静态域：存放在对象中用static定义的静态成员

◆常量池：存放常量

◆非RAM存储：硬盘等永久存储空间

Java内存分配中的栈

在函数中定义的一些基本类型的变量数据和对象的引用变量都在函数的栈内存中分配。
  
当在一段代码块定义一个变量时，Java就在栈中为这个变量分配内存空间，当该变量退出该作用域后，Java会自动释放掉为该变量所分配的内存空间，该内存空间可以立即被另作他用。

Java内存分配中的堆

堆内存用来存放由new创建的对象和数组。 在堆中分配的内存，由Java虚拟机的自动垃圾回收器来管理。

在堆中产生了一个数组或对象后，还可以 在栈中定义一个特殊的变量，让栈中这个变量的取值等于数组或对象在堆内存中的首地址，栈中的这个变量就成了数组或对象的引用变量。 引用变量就相当于是 为数组或对象起的一个名称，以后就可以在程序中使用栈中的引用变量来访问堆中的数组或对象。引用变量就相当于是为数组或者对象起的一个名称。

引用变量是普通的变量，定义时在栈中分配，引用变量在程序运行到其作用域之外后被释放。而数组和对象本身在堆中分配，即使程序 运行到使用 new产生数组或者对象的语句所在的代码块之外，数组和对象本身占据的内存不会被释放，数组和对象在没有引用变量指向它的时候，才变为垃圾，不能在被使用，但仍然占据内存空间不放，在随后的一个不确定的时间被垃圾回收器收走（释放掉）。这也是 Java 比较占内存的原因。

实际上，栈中的变量指向堆内存中的变量，这就是Java中的指针！
 
常量池 (constant pool)

常量池指的是在编译期被确定，并被保存在已编译的.class文件中的一些数据。除了包含代码中所定义的各种基本类型（如int、long等等）和对象型（如String及数组）的常量值(final)还包含一些以文本形式出现的符号引用，比如：

◆类和接口的全限定名；

◆字段的名称和描述符；

◆方法和名称和描述符。

虚拟机必须为每个被装载的类型维护一个常量池。常量池就是该类型所用到常量的一个有序集和，包括直接常量（string,integer和 floating point常量）和对其他类型，字段和方法的符号引用。

对于String常量，它的值是在常量池中的。而JVM中的常量池在内存当中是以表的形式存在的，对于String类型，有一张固定长度的CONSTANT_String_info表用来存储文字字符串值，注意：该表只存储文字字符串值，不存储符号引用。说到这里，对常量池中的字符串值的存储位置应该有一个比较明了的理解了。
在程序执行的时候,常量池 会储存在Method Area,而不是堆中。

堆与栈

Java的堆是一个运行时数据区,类的(对象从中分配空间。这些对象通过new、newarray、anewarray和multianewarray等指令建立，它们不需要程序代码来显式的释放。堆是由垃圾回收来负责的，堆的优势是可以动态地分配内存大小，生存期也不必事先告诉编译器，因为它是在运行时动态分配内存的，Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是，由于要在运行时动态分配内存，存取速度较慢。

 

 

栈的优势是，存取速度比堆要快，仅次于寄存器，栈数据可以共享。但缺点是，存在栈中的数据大小与生存期必须是 确定的，缺乏灵活性。栈中主要存放一些基本类型的变量数据（int, short, long, byte, float, double, boolean, char）和对象句柄(引用)。

栈有一个很重要的特殊性，就是存在栈中的数据可以共享。假设我们同时定义：

1.       int a = 3;  

2.       int b = 3；  

编译器先处理int a = 3；首先它会在栈中创建一个变量为a的引用，然后查找栈中是否有3这个值，如果没找到，就将3存放进来，然后将a指向3。接着处理int b = 3；在创建完b的引用变量后，因为在栈中已经有3这个值，便将b直接指向3。这样，就出现了a与b同时均指向3的情况。

这时，如果再令 a=4；那么编译器会重新搜索栈中是否有4值，如果没有，则将4存放进来，并令a指向4；如果已经有了，则直接将a指向这个地址。因此a值的改变不会影响 到b的值。

要注意这种数据的共享与两个对象的引用同时指向一个对象的这种共享是不同的，因为这种情况a的修改并不会影响到b, 它是由编译器完成的，它有利于节省空间。而一个对象引用变量修改了这个对象的内部状态，会影响到另一个对象引用变量。

 

栈、堆、常量池虽同属Java内存分配时操作的区域，但其适用范围和功用却大不相同。本文将深入Java核心，详细讲解Java内存分配方面的知识。

AD：

String是一个特殊的包装类数据。可以用：

1.       String str = new String("abc");  

2.       String str = "abc";  

两种的形式来创建，第一种是用new()来新建对象的，它会在存放于堆中。每调用一次就会创建一个新的对象。而第二种是先在栈中创建一个对String类的对象引用变量str，然后通过符号引用去字符串常量池 里找有没有"abc",如果没有，则将"abc"存放进字符串常量池，并令str指向”abc”，如果已经有”abc” 则直接令str指向“abc”。

比较类里面的数值是否相等时，用equals()方法；当测试两个包装类的引用是否指向同一个对象时，用==，下面用例子说明上面的理论。

1.       String str1 = "abc";  

2.       String str2 = "abc";  

3.       System.out.println(str1==str2); //true  

可以看出str1和str2是指向同一个对象的。

1.       String str1 =new String ("abc");  

2.       String str2 =new String ("abc");  

3.       System.out.println(str1==str2); // false  

用new的方式是生成不同的对象。每一次生成一个。

因此用第二种方式创建多个”abc”字符串,在内存中 其实只存在一个对象而已. 这种写法有利与节省内存空间. 同时它可以在一定程度上提高程序的运行速度，因为JVM会自动根据栈中数据的实际情况来决定是否有必要创建新对象。而对于String str= new String("abc")；的代码，则一概在堆中创建新对象，而不管其字符串值是否相等，是否有必要创建新对象，从而加重了程序的负担。

另 一方面, 要注意: 我们在使用诸如String str = "abc"；的格式定义类时，总是想当然地认为，创建了String类的对象str。担心陷阱！对象可能并没有被创建！而可能只是指向一个先前已经创建的对象。只有通过new()方法才能保证每次都创建一个新的对象。
 
由于String类的immutable性质，当String变量需要经常变换 其值时，应该考虑使用StringBuffer类，以提高程序效率。
 
1. 首先String不属于8种基本数据类型，String是一个对象。因为对象的默认值是null，所以String的默认值也是null；但它又是一种特殊的对象，有其它对象没有的一些特性。

2. new String()和new String(”")都是申明一个新的空字符串，是空串不是null；

3. String str=”kvill”；String str=new String (”kvill”)的区别

示例：

1.       String s0="kvill";  

2.       String s1="kvill";  

3.       String s2="kv" + "ill";  

4.       System.out.println( s0==s1 );  

5.       System.out.println( s0==s2 );  

结果为：

true 
true

首先，我们要知结果为道Java 会确保一个字符串常量只有一个拷贝。

因为例子中的 s0和s1中的”kvill”都是字符串常量，它们在编译期就被确定了，所以s0==s1为true；而”kv”和”ill”也都是字符串常量，当一个字符串由多个字符串常量连接而成时，它自己肯定也是字符串常量，所以s2也同样在编译期就被解析为一个字符串常量，所以s2也是常量池中” kvill”的一个引用。所以我们得出s0==s1==s2；用new String() 创建的字符串不是常量，不能在编译期就确定，所以new String() 创建的字符串不放入常量池中，它们有自己的地址空间。

示例：

1.       String s0="kvill";  

2.       String s1=new String("kvill");  

3.       String s2="kv" + new String("ill");  

4.       System.out.println( s0==s1 );  

5.       System.out.println( s0==s2 );  

6.       System.out.println( s1==s2 );  

结果为：

false 
false 
false

例2中s0还是常量池 中"kvill”的应用，s1因为无法在编译期确定，所以是运行时创建的新对象”kvill”的引用，s2因为有后半部分new String(”ill”)所以也无法在编译期确定，所以也是一个新创建对象”kvill”的应用;明白了这些也就知道为何得出此结果了。