Java中的八种包装类

简介: Java中的八种包装类


文章目录

为什么需要包装类?

读以下程序:

public class IntegerTest01 {
    public static void dosome(Object obj){
        System.out.println(obj);
    }
    public static void main(String[] args) {
    }
}

如果我们想将一个基本数据类型传入dosome方法中,直接传是不行的,应为基本数据类型它不是类的对象,所以我们可以对这个基本数据类型进行包装,如下:

//自己模拟实现的一个包装类
public  MyInt {
    int value;
    public MyInt(int value) {
        this.value = value;
    }
    public MyInt(){
    }
}
public class IntegerTest01 {
    public static void dosome(Object obj){
        System.out.println(obj);
    }
    public static void main(String[] args) {
        //这里的MyInt是自己模拟实现的一个包装类
        MyInt a = new MyInt(100);
        dosome(a);
    }
}

通过以上程序我们可以知道,如果基本数据想要参与面向对象开发,那么就需要包装类。其实,八种基本数据结构的包装类Java已经帮我们实现了。

Java提供的八种包装类

基本数据类型                   包装类型                  父类型
      -----------------------------------------------------------------------
      byte                            java.lang.Byte             Number
      short                           java.lang.Short            Number
      int                             java.lang.Integer          Number
      long                            java.lang.Long             Number
      float                           java.lang.Float            Number
      double                          java.lang.Double           Number
      boolean                         java.lang.Boolean          Object
      char                            java.lang.Character        Object

装箱和拆箱

装箱:基本数据类型向包装类型数据的转换。

拆箱:包装类型数据类型向基本数据类型的转换。

手动装箱和拆箱

//装箱   基本数据类型 -->  包装数据类型
//方法一(这个装箱方法已经过时):
 Integer b = new Integer(100);
 //方法二
 Integer c = Integer.valueOf(100);
//拆箱      包装数据类型 --> 基本数据类型
 int i = b.intValue();

自动装箱和拆箱

//装箱
Integer x = 100;//将基本数据100转化包装类型数据
//拆箱
int y = x;//将包装类型x转化为基本数据类型

整数型常量池

读以下程序,并判断程序的编译结果。

public class IntegerTest02 {
    public static void main(String[] args) {
        Integer a = 1000;
        Integer b = 1000;
        System.out.println(a == b);
        Integer c = 100;
        Integer d = 100;
        System.out.println(c == d);//编译结果为true
    }
}

编译结果:

为什么会是这样的结果呢?

Java中为了提高程序的执行效率,将整形数据 -128 到 127 之间的所有的包装对象提前创建好, 放到了 方法区的"整数型常量池"当中,在使用这个区间的数据时,不需要再new对象了, 可以直接从池子中取出来。

所以程序中的c和d都存的是整数型常量池中100的包装类对象的地址,所以他们两个是相等的。

整数1000并没有提前在整数型常量池中创建对象,所以在装箱时,需要在堆内存中创建对象,他们的地址也各不相同。

注意:

当程序中使用到了Integer,程序在类加载时会在整数型常量池中自动创建 -128 到 127之间的包装类对象(注意与字符串常量池的区别,字符串常量池只会在使用字符串时创建对象,并且没有范围限制)。

Integer中的常用方法

public class IntegerTest03 {
    public static void main(String[] args) {
        // 静态方法 static int parseInt(String s)
        //将s转换为int型数字
        int i = Integer.parseInt("123");
        System.out.println(i);//编译结果为123
        //如果传入该方法的参数不是数字字符串,编译器就会报错
        //int j = Integer.parseInt("中文");报错:java.lang.NumberFormatException
        //同理,在其他包装类中也存在类似方法 :Double.parseDouble , Float.parseFloat ......
        //静态方法  static String toBinaryString(int i)
        //将i转换为二进制字符串
        System.out.println(Integer.toBinaryString(5));//编译结果:101
        //同理还存在以下方法:
        //static String toHexString(int i)//将i转换为16进制字符串
        //static String toOctalString(int i)//将i转换为8进制字符串
        //实例方法  String toString()
        //该方法已经被重写,字符串的形式返回包装类数据
        Integer x = 1000;
        System.out.println(x.toString() + 1);//编译结果为10001
        //实例方法  boolean equals(Object obj)
        //判断两个包装类对象是否一样,并非对象地址
        Integer y = 1000;
        System.out.println(x.equals(y));//编译结果为:true
    }
}

int 、Integer、String之间的相互转换

//int    String    Integer   之间的类型转换
public class IntergerTest04 {
    public static void main(String[] args) {
        // int --> String
        //数字后面加一个空字符串
        int i = 100;
        String j = 100 + "";
        System.out.println(j + 1);//编译结果:1001
        //String --> int
        //使用静态方法 Integer.parseInt()
        String x = "1234";
        int y = Integer.parseInt(x);
        System.out.println(y + 1);//编译结果:1235
        //int --> Integer
        //自动装箱
        Integer m = 100;
        //手动装箱
        Integer m2 = Integer.valueOf(100);
        //手动装箱(已过时)
        Integer m3 = new Integer(100);
        //Integer --> int
        //自动拆箱
        int n = m;
        //手动拆箱
        int n2 = m.intValue();
        //String --> Integer
        Integer p = Integer.valueOf("1234");
        //Integer --> String
        //方法一
        String q = String.valueOf(m);
        //方法二
        Integer p2 = 1000;
        String q2 = p2.toString();
    }
}


相关文章
|
7月前
|
JavaScript Java 编译器
Java包装类和泛型的知识点详解
Java包装类和泛型的知识点的深度理解
|
1月前
|
存储 缓存 Java
大厂面试必看!Java基本数据类型和包装类的那些坑
本文介绍了Java中的基本数据类型和包装类,包括整数类型、浮点数类型、字符类型和布尔类型。详细讲解了每种类型的特性和应用场景,并探讨了包装类的引入原因、装箱与拆箱机制以及缓存机制。最后总结了面试中常见的相关考点,帮助读者更好地理解和应对面试中的问题。
57 4
|
3月前
|
Java 编译器 容器
Java——包装类和泛型
包装类是Java中一种特殊类,用于将基本数据类型(如 `int`、`double`、`char` 等)封装成对象。这样做可以利用对象的特性和方法。Java 提供了八种基本数据类型的包装类:`Integer` (`int`)、`Double` (`double`)、`Byte` (`byte`)、`Short` (`short`)、`Long` (`long`)、`Float` (`float`)、`Character` (`char`) 和 `Boolean` (`boolean`)。包装类可以通过 `valueOf()` 方法或自动装箱/拆箱机制创建。
44 9
Java——包装类和泛型
|
2月前
|
Java
【Java】什么是泛型?什么是包装类
【Java】什么是泛型?什么是包装类
23 0
|
4月前
|
Java 程序员
【Java基础面试八】、为啥要有包装类?
这篇文章解释了Java中存在包装类的原因:为了让基本数据类型具备对象的特性,使得它们可以被用作对象,以符合Java"一切皆对象"的设计理念,并简化将基本数据类型作为Object类型参数传递的问题。
【Java基础面试八】、为啥要有包装类?
|
3月前
|
存储 Java 测试技术
Java零基础教学(10):包装类
【9月更文挑战第1天】Java零基础教学篇,手把手实践教学!
49 1
|
4月前
|
前端开发 Java
【前端学java】java中的包装类(12)
【8月更文挑战第10天】java中的包装类
25 1
|
4月前
|
算法 Java
12 Java常用类(一)(内部类+object类+包装类)
12 Java常用类(一)(内部类+object类+包装类)
41 5
|
4月前
|
存储 Java 测试技术
Java零基础(11) - 包装类详解
【8月更文挑战第11天】🏆本文收录于「滚雪球学Java」专栏,专业攻坚指数级提升,希望能够助你一臂之力,帮你早日登顶实现财富自由🚀;同时,欢迎大家关注&&收藏&&订阅!持续更新中,up!up!up!!
53 1
|
5月前
|
存储 Java 测试技术
day18:Java零基础 - 包装类
【7月更文挑战第18天】🏆本文收录于「滚雪球学Java」专栏,专业攻坚指数级提升,希望能够助你一臂之力,帮你早日登顶实现财富自由🚀;同时,欢迎大家关注&&收藏&&订阅!持续更新中,up!up!up!!
44 9
下一篇
DataWorks