Java装箱以及拆箱类型

一、前述

写前述貌似成为我写博客的一个习惯，总觉得直接开始不太好，得扯一两句，才慢慢进入主题，毕竟大家都是含蓄的，hhh，本文分享的是 Java 里面装箱以及拆箱的操作

二、测试代码以及讲解

public class TestString {
	public static void main(String[] args) {
		String s1 = "abc";
		StringBuffer s2 = new StringBuffer(s1);
		System.out.println("s1.equals(s2):"+s1.equals(s2));//false
		/*
		 * String里面的equals方法里面检查了 instance of String，但是我们的StringBuffer的祖先是CharSequence
		 * 因此不是同一个祖先，所以在最后比较的时候是不相等的，所以是false
		 */
		 
		System.out.println("s1 == s2:"+(s1==s2.toString()));
		/*
		 * 这里的s2是新建的对象，然后才转为字符串的，所以不是同一个对象，== 是比较的地址，这里不是不是同一个内存地址，所以是false
		 */
		 
		Integer i1 = 100;
		Integer i2 = 100;
		Integer i3 = 200;
		Integer i4 = 200;
		System.out.println("i1 == i2:"+(i1 == i2)); //true
		/*
		 * 这里的 i1 和 i2的数值在 -128—127之间，可以直接从内部缓存池中拿，不需要再新建对象，所以是同一个对象，这里为true
		 */
		System.out.println("i3 == i4:"+(i3 == i4)); //false
		/*
		 * 这里的i3 和 i4的数值大小超过了 -128-127 所以这两个是不同的对象，用 == 比较的是false
		 */
		 
		Double d1 = 100.0;
		Double d2 = 100.0;
		Double d3 = 200.0;
		Double d4 = 200.0;
		System.out.println("d1 == d2:"+(d1 == d2));//false
		/*
		 * Double类型的对象每次不管是多大的数值，都会new一个新的对象来表达该数值，所以这里的两个都是新的对象，
		 * == 比较的就是对象的引用，这里就是false
		 */
		System.out.println("d3 == d4:"+(d3 == d4)); //false
		/*
		 * Double类型的对象每次不管是多大的数值，都会new一个新的对象来表达该数值，所以这里的两个都是新的对象，
		 * == 比较的就是对象的引用，这里就是false
		 */
		
		Boolean b1 = false;
		Boolean b2 = false;
		Boolean b3 = true;
		Boolean b4 = true;
		/*
		 * Boolean类型都是同一个对象，而且是final类型的
		 */
		System.out.println("b1 == b2:"+(b1 == b2)+" b1哈希地址："+b1.hashCode()+" b2哈希地址："+b2.hashCode()); //true
		System.out.println("b3 == b4:"+(b3 == b4)); //true

		
		Integer a = 1;
		Integer b = 2;
		Integer c = 3;
		Integer d = 3;
		Integer e = 321;
		Integer f = 321;
		Long g = 3L;
		Long h = 2L;
		/*
		 * Integer类型的如果在 -128—127之间，直接从缓存里面拿，不用新建对象，所以为true
		 */
		System.out.println("c == d:"+(c == d)); //true
		
		/*
		 *Integer类型超过 -128~127 ，那么就是新建的对象，不从缓存里面拿出来，内存地址就不是缓冲池了
		 */
		System.out.println("c == d:"+(e == f)); //false

		/*
		 * 当 == 两边有表达式的时候，会进行拆箱成基本数据类型，直接比较数值大小，不是比较对象的引用了，
		 * 
		 */
		System.out.println("c == (a + b):"+(c == (a + b))); //true
		
		/*
		 * 这里的equals方法
		 * a+b是先把a  b各自拆箱，
		 * 得到的结果再装箱，去和c比较，
		 */
		System.out.println("c.equals(a + b):"+c.equals(a + b)); //true
		
		/*
		 * 拆箱成为基本数据类型，所以为true
		 */
		System.out.println("g == (a + b):"+(g == (a + b))); //true	
		/*
		 * 这里的g是长整型包装类的，a+b是Integer类型的，因为equals方法会把 a b 各自拆箱得到的和再来装箱比较
		 * g是长整型包装类，没有重写equals方法，所以使用的是Object的equals方法，而Object的方法
		 * equals比较的是内存地址，所以这里是true
		 */
		 
		System.out.println("g.equals(a + b):"+g.equals(a + b)); //false
		
		/*
		 * 这里 a + h 因为 a是Integr类型的，h是Long类型的，两个相加就会自己把类型变成高精度类型的那个，
		 * 会变成Long类型，由于 g 也是Long类型，所以这里就是true
		 */
		System.out.println("g.equals(a + h):"+g.equals(a + h)); //true
		Integer a1 = 444;
		int a2 = 444;
		/*
		 * 这里会把a1拆箱成为int类型的 444，然后就是基本数据类型直接比较数值
		 */
		System.out.println("a1 == a2:"+(a1 == a2)); //true
		/*
		 * 这里的equals是先把 a2 装箱成 Integer,再去和a1比较值，所以为true
		 */		
		 System.out.println("a1.equals(a2):"+a1.equals(a2));//true		
	}
}