Java中的包装类

作者: Arvin Chen 分类: Java 来源: Break易站(www.breakyizhan.com)

Wrapper类是一个对象包装或包含基本数据类型的类。当我们为包装类创建一个对象时,它包含一个字段,在这个字段中,我们可以存储一个原始数据类型。换句话说,我们可以将原始值包装到包装器类对象中。

Java中的包装类

Java中哪些需要包装类

  1. 它们将原始数据类型转换为对象。如果我们希望修改传递给方法的参数,则需要对象(因为基元类型是按值传递的)。
  2. java.util包中的类只处理对象,因此在这种情况下包装类也有帮助。
  3. Collection框架中的数据结构(如ArrayList和Vector)仅存储对象(引用类型)而不存储基本类型。
  4. 需要一个对象来支持多线程中的同步。

Java原始数据类型及其对应的包装类

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

Java中的自动装箱和拆箱

自动装箱:将原始类型自动转换为相应包装类的对象称为自动装箱。例如 - 将int转换为Integer,将long转换为Long,将double转换为Double等
示例:

// Java program to demonstrate Autoboxing

import java.util.ArrayList;
class Autoboxing
{
    public static void main(String[] args)
    {
        char ch = 'a';;

        // Autoboxing- primitive to Character object conversion
        Character a = ch;

        ArrayList<Integer> arrayList = new ArrayList<Integer>();

        // Autoboxing because ArrayList stores only objects
        arrayList.add(25);

        // printing the values from object
        System.out.println(arrayList.get(0));
    }
}

输出:

25

拆箱:这只是自动装箱的逆向过程。自动将包装类的对象转换为其对应的基元类型称为拆箱。例如 - 将Integer转换为int,Long转换为long,将Double转换为double等。

// Java program to demonstrate Unboxing
import java.util.ArrayList;

class Unboxing
{
    public static void main(String[] args)
    {
        Character ch = 'a';

        // unboxing - Character object to primitive conversion
        char a = ch;

        ArrayList<Integer> arrayList = new ArrayList<Integer>();
        arrayList.add(24);

        // unboxing because get method returns an Integer object
        int num = arrayList.get(0);

        // printing the values from primitive data types
        System.out.println(num);
    }
}

输出:

24

Java履行Implementation

// Java program to demonstrate Wrapping and UnWrapping
// in Java Classes
class WrappingUnwrapping
{
    public static void main(String args[])
    {
        //  byte data type
        byte a = 1;

        // wrapping around Byte object
        Byte byteobj = new Byte(a);

        // int data type
        int b = 10;

        //wrapping around Integer object
        Integer intobj = new Integer(b);

        // float data type
        float c = 18.6f;

        // wrapping around Float object
        Float floatobj = new Float(c);

        // double data type
        double d = 250.5;

        // Wrapping around Double object
        Double doubleobj = new Double(d);

        // char data type
        char e='a';

        // wrapping around Character object
        Character charobj=e;

        //  printing the values from objects
        System.out.println("Values of Wrapper objects (printing as objects)");
        System.out.println("Byte object byteobj:  " + byteobj);
        System.out.println("Integer object intobj:  " + intobj);
        System.out.println("Float object floatobj:  " + floatobj);
        System.out.println("Double object doubleobj:  " + doubleobj);
        System.out.println("Character object charobj:  " + charobj);

        // objects to data types (retrieving data types from objects)
        // unwrapping objects to primitive data types
        byte bv = byteobj;
        int iv = intobj;
        float fv = floatobj;
        double dv = doubleobj;
        char cv = charobj;

        // printing the values from data types
        System.out.println("Unwrapped values (printing as data types)");
        System.out.println("byte value, bv: " + bv);
        System.out.println("int value, iv: " + iv);
        System.out.println("float value, fv: " + fv);
        System.out.println("double value, dv: " + dv);
        System.out.println("char value, cv: " + cv);
    }
}

输出:

Values of Wrapper objects (printing as objects)
Byte object byteobj:  1
Integer object intobj:  10
Float object floatobj:  18.6
Double object doubleobj:  250.5
Character object charobj: a
Unwrapped values (printing as data types)
byte value, bv: 1
int value, iv: 10
float value, fv: 18.6
double value, dv: 250.5
char value, cv: a

在Java中,原始包装类是不可变的

考虑下面的Java程序。

// Java program to demonstrate that prmitive
// wrapper classes are immutable
class Demo
{
    public static void main(String[] args)
    {
        Integer i = new Integer(12);
        System.out.println(i);
        modify(i);
        System.out.println(i);
    }
 
    private static void modify(Integer i)
    {
        i = i + 1;
    }
}

输出:

12
12

参数i在修改中引用并引用与main()中的i相同的对象,但对i的更改未反映在main()中,为什么?思考一下,答案在这篇文章:在Java中,原始包装类是不可变的

Java中包装类的详解

我们知道基本类型都有对应的包装类,下面列出了对于的包装类的介绍和用法:

更多关于包装类的转换:

  •   本文标题:Java中的包装类 - Break易站
    转载请保留页面地址:https://www.breakyizhan.com/java/4999.html
      微信返利机器人
      免费:淘宝,京东,拼多多优惠券
      腾讯,爱奇艺,优酷的VIP视频免费解析,免费看
      即刻扫描二维码,添加微信机器人!

    发表笔记

    电子邮件地址不会被公开。 必填项已用*标注