常量池

package mooc_6_4;

public class IntegerTest {

	public static void main(String[] args) {
		Integer n1 = 127;
		Integer n2 = 127;
		System.out.println(n1 == n2);
		Integer n3 = 128;
		Integer n4 = 128;
		System.out.println(n3 == n4);
		Integer n5 = new Integer(127);
		System.out.println(n1 == n5);

	}

}

java为提高程序的性能,java为很多基本性能的包装类/字符串都建立常量池

常量池：相同的值只存储一份，节约内存，共享访问（确定的值用一个东西框起来，要用的时候指向同一个地方）;

基本包装类(把每一个基本类型都定义一个相应的类对象）：

Boolean ,Byte, Short,Integer,Long,Charater,Float,Double

Boolean:true,false;

Byte,Character:0-127;

Short,Int,Long-128-127;

Float,Double:没有缓存（常量池），小数太多了;

package mooc_6_4;

public class cacheTest {
	public static void main(String[] arg) {
		Boolean b1 = true;//基本类型的一个包装类,b1变成了一个对象;
		Boolean b2 = true;
		System.out.println("Boolean Test:" + String.valueOf(b1 ==b2));
		//对象的等号判断的是两个指针指向的地址是否一样,在内存中b1,b2指向同一个东西;
		Byte b3 = 127;
		Byte b4 = 127;
		System.out.println("Byte Test:" + String.valueOf(b3 == b4));
		
		Character c1 = 127;
		Character c2 = 127;
		System.out.println("Character Test:" + String.valueOf(c1 == c2));
		
		Short s1 = -128;
		Short s2 = -128;
		System.out.println("Short Test:" + String.valueOf(s1 == s2));
		
		Integer i1 = 127;
		Integer i2 = 127;
		System.out.println("Integer Test:" + String.valueOf(i1 == i2));
		
		Long l1 = -128L;
		Long l2 = -128L;
		System.out.println("Long Test:" + String.valueOf(l1 == l2));
		
		Float f1 = 0.5f;//输出false,在内存中指向是不一样的;
		Float f2 = 0.5f;
		System.out.println("Float Test:" + String.valueOf(f1 == f2));
		
		Double d1 = 0.5;
		Double d2 = 0.5;
		System.out.println("Double Test:" + String.valueOf(d1 == d2));
	}//在允许的范围内指向的是同一个地方,超过范围就不是的了;

}

java为常量字符串都建立常量池缓存机制

常量池作用：节约内存，提高共享访问;

package mooc_6_4;

public class StringConstantTest {

	public static void main(String[] args) {
		String s1 = "abc";
		String s2 = "abc";
		String s3 = "ab" + "c";//都是常量，编译器将常量化;
		String s4 = "a" + "b" + "c";//存在同一个地址;
		System.out.println(s1 == s2);//true;
		System.out.println(s1 == s3);//true;
		System.out.println(s1 == s4);//true;
	}

}

 基本类型的包装类和字符串有两种创建方式

①：常量式（字面式）赋值创建，放在栈内存(将被常量化）

Integer a = 10;

String b ="abc";

②：new对象进行创建，放在堆内存（不会被常量化）

Integer c = new Integer(10);

String d = new String("abc");

这两件创建方式导致创建的对象存放的位置不一样;

package mooc_6_4;

public class BoxClassTest {

	public static void main(String[] args) {
		int i1 = 10;
		Integer i2 = 10;//自动装箱,10本来是int型,在这里进行包装，成包装类;
		System.out.println(i1 == i2);//true
		//自动拆箱 基本类型和包装类进行比较，包装类自动拆箱;

		Integer i3 = new Integer(10);
		System.out.println(i1 == i3);//true
		//自动拆箱 基本类型和包装类进行比较，包装类自动拆箱
		
		System.out.println(i2 == i3);//false
		//两个对象比较，比较其地址。
		//i2常量，放在栈内存常量池中，i3是new出对象，放在对内存。
		
		Integer i4 = new Integer(5);
		Integer i5 = new Integer(5);
		System.out.println(i1 == (i4+i5));//true,基本类型和包装类;
		System.out.println(i2 == (i4+i5));//true,
		System.out.println(i3 == (i5+i4));//true 
		//i4+i5操作使得i4,i5自动拆箱为基本类型并运算得到10
		//基础类型10和对象比较，将会使对象自动拆箱，做基本类型比较;
		//做算术运算的时候自动拆箱，变为int型;
		
		Integer i6 = i4 + i5;//+操作使得i4,i5自动拆箱，得到10，因此i6=i2; 
		System.out.println(i1 == i6);//true,基本类型和包装类进行比较;
		System.out.println(i2 == i6);//true,都是存在栈中
		System.out.println(i3 == i6);//false,i3存在堆中
		
	}

}