Java常用类-包装类

包装类

​ Java中的基本类型功能简单，不具备对象的特性，为了使基本类型具备对象的特性，所以出现了包装类，就可以像操作对象一样操作基本类型数据;包装类不是为了取代基本数据类型，而是在数据类型需要使用对象表示的时候，才使用包装类;

1.包装类的继承关系

2.基本数据类型和包装类的关系

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

提示：所有的包装类+String类都是final修饰的，代表不可以被继承;

3.包装类对应的属性定义（以Integer为例）

System.out.println(Integer.SIZE); //位数 32位
System.out.println(Integer.BYTES); //字节数 4字节
System.out.println(Integer.MAX_VALUE); //最大值 2^32-1 2147483647
System.out.println(Integer.MIN_VALUE); //最小值 -2^32  -2147483648

4.包装类型的基本操作

基本类型，包装类型，String类型的相互转换

序号	类型转换	方法
1	int->Integer	new Integer(primitive)
2	Integer->int	Integer 对象.xxxValue()
3	Integer->String	Integer 对象.toString()
4	String->Integer	new Integer(String str)
5	int->String	String.valueOf(primitive)
6	String->int	Integer.paseXxx(String str)

4.1 int->Integer new Integer(primitive)

所有包装类都可以与之对应的基本数据类型作为参数，来构造他们的实例

//1基本数据类型 ->包装类
//1.1byte->Byte
byte b = 1;
Byte byte1 = new Byte(b);
//1.2 char->Character
Character character1 = new Character('a');
//1.3 short->Short
short s = 2;
Short short1 = new Short(s);
//1.4 int Integer
Integer integer1 = new Integer(4);
//1.5 long->Long
Long long1 = new Long(8);
//1.6 float->Float
Float float1 = new Float((float) 4.0);
//1.7 double->Double
Double double1 = new Double(8.0);
//1.8 boolean->Boolean
Boolean boolean1 = new Boolean(true);

注意：类型一定要对应；

Integer.valueOf(int a)

Integer integer5 = Integer.valueOf(200);
System.out.println(integer5);

源码

//也是new 的对象 跟new Integer(primitive)一样
public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

4.2 Integer->int Integer 对象.xxxValue()

对象.xxxValue(),将包装类转换为对应的基本数据类型值，所有包装类都有

 Integer integer2 = new Integer(4);
 int int2 = integer2.intValue();
 System.out.println(int2); //4

4.3 Integer->String Integer 对象.toString()

对象.toString() 将基本数据烈性转换为String类型

Integer integer3 = new Integer(4);
String string3 = integer3.toString();
System.out.println(string3); //4

4.4 String->Integer new Integer(String str)

除Character类外，其他包装类可将一个字符作为参数构造他们的实例，前提：字符串内容必须跟对应包装类匹配

Integer integer4 = new Integer("4");
System.out.println(integer4);

Character类型 没有支持字符串的构造方法，因为字符串包含多个字符，Character只包含一个字符

Character a = new Character("aa"); //会报错

Integer.valueOf(String s)

源码

public static Integer valueOf(String s) throws NumberFormatException {
    return Integer.valueOf(parseInt(s, 10)); 
    //先匹配数字，再调用new Integer
}

4.5 int->String String.valueOf(primitive)

基本类型转String类型

String string5 = String.valueOf(100);
System.out.println(string5); //100

String类的valueOf方法

4.6 String->int Integer.paseXxx

直接将字符串转换为对应的基本数据类型Character除外

int int6 = Integer.parseInt("123");
System.out.println(int6); //123

5.装箱，拆箱

5.1装箱

自动装箱,底层就是自动调用valuesOf方法实现

Integer integer5_1_1 = 400;
//实际上，系统执行了Integer obj = Integer.valueOf(400);
System.out.println(integer5_1_1); //400

5.2拆箱

Integer integer5_2_1 = new Integer(500);
System.out.println(integer5_2_1+integer5_2_1); //1000
//实际上执行了integer5_2_1.intValue()+integer5_2_1.intValue();   

6.包装类的缓存

6.1包装类的缓存范围

包装类	缓存范围
Byte	全部缓存（-128—127）
Character	<=127缓存
Short	-128—127缓存
Integer	-128—127缓存
Long	-128—127缓存
Float	没有缓存
Double	没有缓存
Boolean	全部缓存（true,false）

6.2案例

Integer integer8_1 = 120;
Integer integer8_2 = 120;
System.out.println(integer8_1 == integer8_2); //true

Integer integer9_1 = 130;
Integer integer9_2 = 130;
System.out.println(integer9_1 == integer9_2); //false
//Integer类中有一个静态内部类IntegerCache,缓存了-128到127之间所有int数字的Integer对象
//120 在-128-127之间 ，产出的对象是从IntegerCache中取出来的
//其他包装类也是一样

6.3垃圾回收相关

Integer integer6_3_1 = 100;
integer6_3_1 = null; //integer6_3_1 不会被垃圾回收器回收
//这里虽然integer6_3_1被赋予null，但它之前指向的是cache中的Integer对象，而cache没有被赋null，所以Integer(100)这个对象还是存在

Integer integer6_3_2 = 128;
integer6_3_2 = null;//integer6_3_2 会被垃圾回收器回收
//integer6_3_2不是缓存中的对象，被赋予null后会被垃圾回收器回收

标签：常用,Java,String,包装,System,int,new,println,Integer
来源： https://www.cnblogs.com/xiaoqigui/p/16378054.html