Java 包装类从基本概念到实战技巧

目录

• 1 什么是包装类
• 2. 怎么使用包装类❓
• 3. 包装类与基本类型的转换
• 3.1 装箱
• 3.2 拆箱
• 4.基本数据类型、包装类与字符串间的转换
• （1）包装类转换成其他基本数据类型
• （2）基本数据类型转为字符串
• （3）字符串转为基本数据类型
• 5. 包装类对象的特点
• 6. 小结

1 什么是包装类

在 Java 中，八大基础数据类型（int,float,double...）不是继承自 Object，并且不具备对象的特征的。比如：基本数据类型就不能调用方法。

int i = 10;
i.toString();

使用这段代码就会出错。

但是我们在开发过程中肯定会遇到，将基本数据类型转换为String类型，或者其他数据类型，而这个时候如果我们要用基础数据类型实现这些转换就会非常麻烦，所以Java就有了基本数据类型的包装类，顾名思义，包装类就是：将基本数据类型包装成对象，使其具有了对象的属性和方法。

这样就可以使用方法和属性了。

而包装类的主要作用也就是：

• 将本类型与其他类型进行转换；
• 将字符串与本类型及包装类型相互转换。

因此为了在泛型代码中可以支持基本类型，并且让基本数据类型也具备对象的特征，Java 给每个基本类型都对应 一个包装类型

2. 怎么使用包装类❓

首先我们来看如何定义包装类：比如定义一个int类型的包装类

• 定义整形包装类

Integer i1 = new Integer(100);  //定义一个值为100的 整形包装类
Integer i2 = 100

我们可能会有疑问，数android据变成了包装类，之后要使用数据怎么办呢 --> 很简单，我们在将包装类转换成基本数据类型就可以了

• 包装类转换成基本数据类型

Integer i1 = new Integer(100);
int value = i1;//方法1
int value2 = i1.intValue();//方法2

经过上述步骤就可以将包装类转换成基本数据类型了，这两个例子分别展示了如何将int类型转换成包装类，如何将包装类转换成int类型。

3. 包装类与基本类型的转换

• 我们一般将“基本数据类型转换成包装类”的过程叫做装箱，将“包装类转换成基本数据类型”的过程叫做拆箱

• 当包装类与编程客栈基本数据类型比较，会自动将包装类拆箱为基本数据类型

  java1.5之后又自动装箱（autoboxing）和自动拆箱（autounboxing）功能

3.1 装箱

1. 把基本数据类型转为包装类对象。
2. 可以分为手动装箱和自动装箱：
3. 是为了使用专门为对象设计的API和特性

下面以 int 类型为例：

int i = 10; // 定义一个 int 基本类型值js
Integer x = new Integer(i); //手动装箱
Integer y = i; // 自动装箱

3.2 拆箱

1. 把包装类对象拆为基本数据类型
2. 可以分为手动拆箱和自动拆箱
3. 一般是因为需要运算，Java中的大多数运算符是为基本数据类型设计的。比较、算术等

下面以 int 类型为例：

Integer j = new Integer(8); // 定义一个 Integer 包装类对象，值为8
int m = j.intValue(); // 手动拆箱 int 类型
int n = j; // 自动拆箱为 int 类型

注： 由于我们经常要做基本类型与包装类之间的转换，从JDK5.0 开始，基本类型与包装类的装箱、拆箱动作可以自动完成

• 注意：只能与自己对应的类型之间才能实现自动装箱与拆箱

4.基本数据类型、包装类与字符串间的转换

（1）包装类转换成其他基本数据类型

Integer i = new Integer(100);
//转换成double类型
double d = i.doubleValue();
//转换成float类型
float f = i.floatValue();

（2）基本数据类型转为字符串

1. 使用包装类的toString()方法；
2. 使用String类的valueOf()方法；
3. 使用一个空字符串加上基本类型。

int a = 10;
// 方法1
String s3 = Integer.toString(a);
// 方法2
String s1 = String.valueOf(a);
// 方法3
String s2 = a + "";

（3）字符串转为基本数据类型

方式1：除了Character类之外，其他所有包装类都具有parseXxx静态方法可以将字符串参数转换为对应的基本类型，例如：

• public static int parseInt(String s)：将字符串参数转换为对应的int基本类型。
• public static long parseLong(String s)：将字符串参数转换为对应的long基本类型。
• public static double parseDouble(String s)：将字符串参数转换为对应的double基本类型。

String a="123";
Integer.parseInt(a);
Short.parseShort(a);
Byte.parseByte(a);
Long.parseLong(a);
Float.parseFloat(a);
Double.parseDouble(a);
Boolean.parseBoolean(a);

方式2：字符串转为包装类，然后可以自动拆箱为基本数据类型

• public static Integer valueOf(String s)：将字符串参数转换为对应的Integer包装类，然后可以自动拆箱为int基本类型
• public static Long valueOf(String s)：将字符串参数转换为对应的Long包装类，然后可以自动拆箱为long基本类型
• public static Double valueOf(String s)：将字符串参数转换为对应的Double包装类，然后可以自动拆箱为double基本类型

注意:如果字符串参数的内容无法正确转换为对应的基本类型，则会抛出java.lang.NumberFormatException异常。

5. 包装类对象的特点

包装类	缓存对象
Byte	-128  - 127
Short	-128 - 127
Integer	-128 - 127
Long	-128 - 127
Float	没有
Double	没有
Character	0 - 127
Boolean	true 和 false

（1）Integer128 问题

public static void main(String[] args) {
    Integer a = 127;
    Integer b = 127;
    Integer c = 128;
    Integer d = 128;
    int e = 128;
    System.out.println(a == b); // true
    System.out.println(c == d); // false
    System.out.println(d == e); // true
}

• 其中在判断(c == d)时输出了false，很明显输出结果并不符合预期，在逻辑上也并不正确，而同样的128==128的比较在基本数据类型int下便可以正常输出true，首先要先弄清在128赋值时发生了什么，接下来通过javap -c反编译查看测试代码的字节码。

提醒一下：使用equals比较时，无论赋什么值都可以正确输出true，下文所有讨论都建立在使用==比较的前提上，同时出现问题的另一个本质也可以说是因为==比较的是地址。

在反编译结果，可以知道Integer在初始化时调用了Integer.valueOf()方法，这也就是我们上面所讲的Java的自动装箱机制.。

在Integer对象创建过程中：

• 如果传入value数值在-128~127范围内，那么所有在这个范围内被创建的对象（句柄）实际都指向同一个地址，即被预创建Integer对象所在的地址。
• 如果传入value数值不在范围内，那么每次被创建的对象（句柄）都指向一个新的且不同的地址，即通过new关键字由JVM分配的新地址。

（2）Integer 和 new Integer 问题

案例：

// python情况一：
public static void main(String[] args) {
    Integer m = new Integer(1);//新new的在堆中
    Integer n = 1;//这个用的是缓冲的常量对象，在方法区
    Sy编程stem.out.println(m == n);//false
    Integer x = new Integer(1);//新new的在堆中
    Integer y = new Integer(1);//另一个新new的在堆中
    System.out.println(x == y);//fa
}
// 情况二：
public static void main(String[] args) {
    int a = 10;
    String b = "10";
    Integer a1 = a;
    Integer b1 = Integer.parseInt(b);
    System.out.println(a1 == b1); // true
    Integer a2 = new Integer(a);
    Integer b2 = new Integer(b);
    System.out.println(a2 == b2); // false
}

Integer n = 1;

• Integer变量指向的是 java 常量池中的对象

new Integer(1);

• new Integer() 的变量指向堆中新建的对象,两者在内存中的地址不同。

（3）类型转换问题

public static void main(String[] args) {
    Integer i1 = 10;
    double i2 = 10;
    // 会将i 自动拆箱为 int，然后根据基本数据类型 ”自动类型转换"规则，转为 double 比较
    System.out.println(i1 == i2); // true 
    int i3 = 10;
    // 会自动拆箱，按照基本数据类型进行比较
    System.out.println(i1 == i3); // true
    Integer i4 = new Integer(10);  
    System.out.println(i3 == i4); // true
    System.out.println(i1 == i4); // false
    Double i5 = 10.0;
    System.out.println(i1 == i5); //编译报错
}

int 变量与 Integer、 int 变量与new Integer() 比较时，只要两个的值是相等，则为true因为包装类Integer 和 基本数据类型int 比较时，java会自动拆包装为int ，然后进行比较，实际上就变为两个int变量的比较。

脚下留心：使用包装类时候的注意事项

使用包装类时，需要注意以下几点：

1. 包装类都重写了Object 类中的toString()方法，以字符串的形式返回被包装的基本数据类型的值。
2. 除了Character外，包装类都有valueOf(String s)方法，可以根据String类型的参数S创建包装类对象，但参数s不能为null，而且该字符串必须是可以解析为相应基本类型的数据，否则虽然可以编译通过，但运行时会报错。具体示例如下：

   Integer i = Integer.valueof("123");
   //合法
   Integer i = Integer,valueof("12a");
   //不合法，“12a“不能被正确解析为基本数据类型

3. 除了Character 外，包装类都有parseXxx(String s）静态方法，该方法的作用是将字符串转换为对应的基本类型的数据。参数不能为null，而且该字符串必须可以解析为相应基本类型的数据，否则虽然可以编译通过，但运行时会报错。具体示例如下:

int i= Integer.parseInt("123");
//合法
Integer in= Integer.parseInt("itcast");
1/不合法 

6. 小结

包装类的特点：

1. 对象化: 包装类使基本数据类型可以作为对象处理，允许与 Java 的集合框架配合使用。
2. 不可变性: 包装类对象是不可变的，即一旦创建，其值不能更改。
3. 类型转换: 包装类可以自动进行基本类型与对象之间的转换（自动装箱和拆箱）。
   • 自动装箱：将基本数据类型自动转换为对应的包装类。
   • 拆箱：将包装类对象自动转换为对应的基本数据类型。

包装类是 Java 中一个重要的特性，它使得基本数据类型能够以对象的形式进行处理，增强了语言的灵活性与功能性。通过了解包装类的特点和使用场景，可以在 Java 编程中更有效地处理数据。

到此这篇关于Java 包装类详解：从基本概念到实战技巧的文章就介绍到这了,更多相关Java 包装类内容请搜索编程客栈(www.devze.com)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程客栈(www.devze.com)！