包装类

包装类

Java为了更加方便的去操作基本数据类型，对每种基本数据类型，都提供了他的一个包装类型（引用类型）

        基本类型     包装类型
         byte        Byte
         short       Short
         int         Integer
         long        Long
         float       Float
         double      Double
         char       Character
         boolean     Boolean

Integer类的概述和构造方法

Integer类概述：	
	Integer 类在对象中包装了一个基本类型 int 的值,
	该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，
	还提供了处理 int 类型时非常有用的其他一些常量和方法
构造方法：
	public Integer(int value)
	public Integer(String s)  //要一个字面上是数字的字符串，如果不是就会报错
案例：
	int num=100;
    //把int类型的值，包装成引用类型。
    Integer integer = new Integer(num);
	
	String s="200";
    //要的这个字符串，字面上是一个数字的字符串。
    Integer integer2 = new Integer(s);

自动装箱和自动拆箱

//自动装箱：将基本数据类型，自动转换成他所对应的包装类型。
//自动拆箱：将包装类型，自动转换成他所对应的基本数据类型。
		
		Integer a = new Integer(100);
        Integer b = new Integer(100);
        //自动拆箱
        int r=a+b;
        System.out.println(r);

        //手动拆箱 intValue();
        Integer c = new Integer(100);
        Integer d = new Integer(100);
        //手动拆箱
        int i1 = c.intValue();
        int i2 = d.intValue();
        System.out.println(i1+i2);


		 int num=10;
         //自动装箱
         Integer integer=num;
         //手动装箱 Integer.valueOf(num);
         Integer integer = Integer.valueOf(num);

//Integer 重写了equals()方法，比较的是，他包装的这个值是否相同
//Integer 重写了toString()方法，把他包装的这个int类型的数据，转换成字符串。
		Integer i = 9527;
		//将Integer类包装的i转换成字符串s；
		String s = i.toString();
		//此时s="9527";
		System.out.println(s);

String类和Int类型的相互转换

String和int类型的相互转换
   //int转换String 
        int num=100; //"100"
        //方式1：
        String str=num+"";  //对int类型+上一个空串""

        //方式2：
        String s = String.valueOf(num);	//valueOf

        //方式3:

        Integer integer = new Integer(num);//把int基本类型的num转换为Integer引用类，然后使用toString方法转换为字符串；
        String s1 = integer.toString();

   //String转换int
        String strNum="100";
        //方式1
        Integer integer1 = new Integer(strNum);	//Integer有参构造方法的参数中可以是字面值为数字的字符串
		//然后使用intValue方法将Integer类型转换成int类型；
        int i = integer1.intValue();

        //方式2：
		//调用Integer类型的parseInt方法；
        int i1 = Integer.parseInt(strNum);

Integer类型重写equals方法中的小问题

案例：
	public static void main(String[] args) {
        Integer i1 = new Integer(127);
        Integer i2 = new Integer(127);

        System.out.println(i1 == i2); //false
        //Integer 重写了i1.equals(i2)方法，比较的是，他包装的这个值是否相同
        System.out.println(i1.equals(i2)); //true
        System.out.println("-----------");

        Integer i3 = new Integer(128);
        Integer i4 = new Integer(128);
        System.out.println(i3 == i4); //false
        System.out.println(i3.equals(i4));//true
        System.out.println("-----------");

        Integer i5 = 128;
        Integer i6 = 128;
        System.out.println(i5 == i6);//  false
        System.out.println(i5.equals(i6)); //true
        System.out.println("-----------");

        Integer i7 = 127;
        Integer i8 = 127;
        System.out.println(i7 == i8);//true
        System.out.println(i7.equals(i8)); //true
    }
    
问题：
		同样是Integer类型，使用'=='比较时，当两个值都大于等于128并且两值相等时，它们的	   地址值是不同的；而当两个值都小于等于127且两值相等时，比较地址值是相等的。

查看源代码：
		public static Integer valueOf ( int i){
if (i >= Integer.IntegerCache.low && i <=Integer.IntegerCache.high)
return Integer.IntegerCache.cache[i + (-Integer.IntegerCache.low)];
        return new Integer(i);
    	当我们 采用 Integer i5 = 128; 这种方式，自动装箱的时候，会调用ValueOf()方法
    	ValueOf()中使用到了IntegerCache这个类 那么IntegerCache这个类是Integer的静态内部类，在这个IntegerCache这个类中有一个静态代码块，当IntegerCache这个类一加载，这个静态代码就会执行。
总结原因：
		Integer类型中，在使用valueOf()方法时,会先默认生成一个Int[]数组，存储（-128至127）共256个元素，而比较的范围在（-128至127）这个范围时，不会创建新的Integer类型的对象，直接在默认生成的数组中调取元素；所以在（-128至127）这个范围内，比较出来的地址值是一样的。

其他包装类的构造方法和常用的一些功能跟Integer是一样的。