Java小白一文讲清楚Java中的包装类及其与基本数据类型、String类型之间的转换

包装类Wrapper

//针对八种基本数据类型相应的引用类型--包装类
基本数据类型				包装类
    boolean  			Boolean
    char				Character
    byte 				Byte
    short 				Short
    int 				Integer
    long 				Long
    float 				Float
    double				Double
    

包装类和基本数据类型的相互转换

说明：装箱—> 基本数据类型====》包装类型； 反之则为拆箱

自动装箱底层调用的是valueOf方法，比如Integer.valueOf();

        //jdk5之前 是手动装箱和拆箱
        //手动装箱  int --> Integer
        int n = 100;
        Integer integer = new Integer(n);
        Integer integer2 = Integer.valueOf(n);

        //手动拆箱  Integer--->int
        int i = integer.intValue();

        //jdk5之后，就可以自动装箱和拆箱
        int n2 = 200;
        //自动装箱  int-->Integer
        //底层调用的是Integer.valueOf(n2);可以打断点debug Step into看到进入到了Integer的valueOf方法
        Integer integer3 = n2;
        //自动拆箱
        int n3 = integer3;//底层仍然使用的是Integer类中的intValue()方法，同样可以打断点，查看


        //其他包装类的用法类似，就不一一列举了

练习

Double d = 100d;//OK的，采用自动装箱Double.valueOf(100d);
Float f = 1.5d;//Ok的，自动装箱 Float.valueOf(1.5f);

Object obj1 = true? new Integer(1):new Double(2.0);
System.out.println(obj1);
//最后输出的是1.0，因为起初赋值true,所以就会新建一个Integer对象，输出应该为1，但是不要忘记三元运算符要看作一个整体来看待
//后面的Double类型是最高精度，它提升了三元运算符整体的精度，所以最后输出	1.0
//不是1哈

//三元运算符要看成一个整体

Object obj2;
if(true){
    obj2 = new Integer(1);
}else{
    obj2 = new Double(2.0);
}
System.out.println(obj2);
//此中最后输出的是1哈，if-else是分别独立的语句，不会像三元运算符那样，
//提升整体精度，所以最后输出1，哎嘿，心态不要受影响哈

包装类型和String类型的相互转换

        //包装类（Integer）-->String
        Integer i = 100;//自动装箱
        //方式1
        String str = i+"";
        //方式2
        String str2 = i.toString();
        //方式3
        String str3 = String.valueOf(i);


        //String-->Integer
        String str4 = "essence";
        Integer i2 = Integer.parseInt(str4);//使用到了自动装箱，本身的返回值是int
        Integer i3 = new Integer(str4);//这里用到了构造器

Integer类和Character类的常用方法

//输出结果
-2147483648
2147483647
false
true
false
true
false
A
a

练习

//输出
false
true		底层调用的是Integer.valueOf(1);看源码可知，1在-128~127之间，所以不会新建Integer
    //源码解读，如果i在-128~127之间，就直接从数组返回
    //如果不在这范围之中，就直接new Integer(i);
    			public static Integer valueOf(int i) {
    				//在范围内（-128~+127），会直接返回，否则会新建Integer
    			    if (i >= IntegerCache.low && i <= IntegerCache.high)
    			        return IntegerCache.cache[i + (-IntegerCache.low)];
    			    return new Integer(i);
    			}
	//顺便看下cache的源码，看是怎么创建的
private static class IntegerCache {
        static final int low = -128;
        static final int high;
        static final Integer cache[];
        static {
            // high value may be configured by property
            int h = 127;
        	......
            cache = new Integer[(high - low) + 1];//即-128~127
false		//因为此时128已经超过了Integer的范围，所以会新建，此时两个Integer对象内存地址就不同，return false

//Integer练习题汇总
//示例一
Integer i1 = new Integer(127);
Integer i2 = new Integer(127);
System.out.println(i1==i2);
//输出如下
false,只要是new,肯定是不同的对象


//示例二
Integer i3 = new Integer(128);
Integer i4 = new Integer(128);
System.out.println(i3==i4);
//输出如下        
false


//示例三
Integer i5 = 127;
Integer i6 = 127;
System.out.println(i5==i6);
//输出如下
true	底层调用Integer.valueOf(127)
    127不超出范围，所以为true


//示例四
Integer i7 = 128;
Integer i8 = 128;
System.out.println(i7==i8);
//输出如下
false   底层调用Integer.valueOf(128)
    128超出范围，看源码可知，要new Integer(128)
    //源码如下
    public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }
    所以是false


//示例五
Integer i9 = 127;
Integer i10 = new Integer(127);
System.out.println(i9==i10);
//输出如下
false	i9所在行底层调用Integer.valueOf(127),直接从cache数组中取出
    而i9所在行直接new Integer，所以为false
    

//示例六
Integer i11 = 127;
Integer i12 = 127;
System.out.println(i11==i12);
//输出如下
true   只要有基本数据类型，判断的是值是否相等


//示例七
Integer i13 = 128;
Integer i14 = 128;
System.out.println(i13==i14);
//输出如下	
false	只要有基本数据类型，判断的是值是否相等