Java 包装类总结

1.基本类型和包装类对应关系

除了int和char例外，其他均首字母大写

基本数据类型	包装类
byte	Byte
short	Short
int	Integer
long	Long
char	Charater
float	Float
double	Double
boolean	Bloolean

2.基本类型和包装类转换

自动装箱和拆箱

自动装箱： 基本类型–>包装类

{
//1.直接把基本变量赋值给Integer对象
    Integer intObj = 5;
//2.直接把基本变量赋值给Object对象
Object boolObject = true;
}

自动拆箱： 基本类型<–包装类

{
//1.直接把Integer赋值给int
    int it = intObj;

//2.先把Object强制转换成Boolean，再赋值给boolean
if (boolObject instanceof Boolean){
        boolean b = (Boolean)boolObject;
    }
}

注意: 自动拆箱和装箱只能在对应类型之间，例如int和Integer。

3.包装类和字符串直接转换

字符串转化成基本类型

{
String intStr = "111";

//1.利用包装类提供的Xxx(String x)构造器
    int int1 = new Integer(intStr);

//2.利用包装类提供的parseXxx(String x)静态方法
    int int2 = Integer.parseInt(intStr);
}

注意: Character包装类无此parseXxx(String x)静态方法

基本类型转化成字符串

{
    int it1 = 111;

//1.通过String.valueOf(xxx)转换
String str1 = String.valueOf(int1);

//2.将基本变量和""进行连接运算
String str2 = it1 + "";
}

4.包装类，基本变量相互比较

包装类和基本变量比较

可以直接进行数值比较

{
Integer a = new Integer(100);
//输出true
    System.out.println("100的包装类实力是否大于50:"+(a > 50));
}

包装类直接相互比较

包装类实例实际是引用类型，只有两个包装类引用同一个对象时才会返回true

{
//输出false
    System.out.println("比较100的包装类是否相等:"+
    (new Integer(100) == new Integer(100)));
}

特殊情况(部分面试会问）：应用常量池的场景 自动装箱可以把一些基本类型赋值给一个包装类实例，但会有以下特殊情况~

public static void main(String[] args)
{
//Java在编译的时候会直接将代码封装成Intege从而使用常量池中的对象
    Integer ina = 2;
    Integer inb = 2;
    System.out.println("两个2自动装箱后是否相等"+ (ina == inb)); // 输出true

//超出缓存数组范围，无法使用常量池
    Integer biga = 128;
    Integer bigb = 128;
    System.out.println("两个2自动装箱后是否相等"+ (biga == bigb)); // 输出false
}

直接看源码分析：
系统会把一个-128~127之间的数值自动装箱成Integer实例，并放入cache数组缓存起来，如果以后还有这个范围的整数自动装箱，实际上是指向同一个数组元素，但不在这个范围内的，系统会重新创建一个Integer实例。


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;
        String integerCacheHighPropValue =
            sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
if (integerCacheHighPropValue != null) {
try {
int i = parseInt(integerCacheHighPropValue);
                i = Math.max(i, 127);
// Maximum array size is Integer.MAX_VALUE
                h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
            } catch( NumberFormatException nfe) {
// If the property cannot be parsed into an int, ignore it.
            }
        }
        high = h;

        cache = new Integer[(high - low) + 1];
int j = low;
for(int k = 0; k < cache.length; k++)
            cache[k] = new Integer(j++);

// range [-128, 127] must be interned (JLS7 5.1.7)
assert IntegerCache.high >= 127;
    }

private IntegerCache() {}
}

public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}

同上，也使用cache的如下面列表所示：

包装类	缓存数组范围
Byte	static final Byte cache[] = new Byte[-(-128) + 127 + 1];
Short	static final Short cache[] = new Short[-(-128) + 127 + 1]
Long	static final Long cache[] = new Long[-(-128) + 127 + 1];
Character	static final Character cache[] = new Character[127 + 1];
Float	无
Double	无
Boolean	无

综合举例

{
public static void main(String[] args) {
int i0 = 127;
    Integer i1 = 127;
    Integer i2 = 127;
    Integer i3 = 0;
    Integer i4 = new Integer(127);
    Integer i5 = new Integer(127);
    Integer i6 = new Integer(0);

    System.out.println("i0=i1 "  +(i0==i1));//true
    System.out.println("i0=i4 "  +(i0==i4));//true

    System.out.println("i1=i2 " + (i1 == i2));//true
    System.out.println("i1=i2+i3 " + (i1 == i2 + i3));//true
    System.out.println("i1=i4 " + (i1 == i4));//false

    System.out.println("i4=i5 " + (i4 == i5));//false
    System.out.println("i4=i5+i6 " + (i4 == i5 + i6));//true
    System.out.println("127=i5+i6 " + (127 == i5 + i6));//true
    System.out.println("---------------------------");

int i20 = 128;
    Integer i21 = 128;
    Integer i22 = 128;
    Integer i23 = 0;
    Integer i24 = new Integer(128);
    Integer i25 = new Integer(128);
    Integer i26 = new Integer(0);

    System.out.println("i20=i21 "  +(i20==i21));//true
    System.out.println("i20=i24 "  +(i20==i24));//true

    System.out.println("i21=i22 " + (i21 == i22));//!!!!!!false
    System.out.println("i21=i22+i23 " + (i21 == i22 + i23));//true
    System.out.println("i21=i24 " + (i21 == i24));//false

    System.out.println("i24=i25 " + (i24 == i25));//false
    System.out.println("i24=i25+i26 " + (i24 == i25 + i26));//true
    System.out.println("128=i25+i26 " + (128 == i25 + i26));//true
   }
}

解释：

int和其他Integer进行==比较是会自动拆箱为int类型。
语句i4 == i5 +i6，因为+这个操作符不适用于Integer对象，是进行数值运算，要首先分别对i5和i6进行自动拆箱操作，进行数值相加，即i4 == 127。然后Integer对象无法与数值进行直接比较，所以i4自动拆箱转为int值127，最终这条语句转为127 == 127进行数值比较。

秒客网

Java 包装类总结

1.基本类型和包装类对应关系

2.基本类型和包装类转换

3.包装类和字符串直接转换

4.包装类，基本变量相互比较

相关文章