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();
    }
}


相关文章
|
3月前
|
JavaScript Java 编译器
Java包装类和泛型的知识点详解
Java包装类和泛型的知识点的深度理解
|
3月前
|
存储 Java 数据库
java包装类的作用、基本类型和包装类型的区别
java包装类的作用、基本类型和包装类型的区别
64 0
java包装类的作用、基本类型和包装类型的区别
|
6天前
|
前端开发 Java
【前端学java】java中的包装类(12)
【8月更文挑战第10天】java中的包装类
7 1
|
8天前
|
存储 Java 测试技术
Java零基础(11) - 包装类详解
【8月更文挑战第11天】🏆本文收录于「滚雪球学Java」专栏,专业攻坚指数级提升,希望能够助你一臂之力,帮你早日登顶实现财富自由🚀;同时,欢迎大家关注&&收藏&&订阅!持续更新中,up!up!up!!
20 1
|
12天前
|
算法 Java
12 Java常用类(一)(内部类+object类+包装类)
12 Java常用类(一)(内部类+object类+包装类)
25 5
|
1月前
|
存储 Java 测试技术
day18:Java零基础 - 包装类
【7月更文挑战第18天】🏆本文收录于「滚雪球学Java」专栏,专业攻坚指数级提升,希望能够助你一臂之力,帮你早日登顶实现财富自由🚀;同时,欢迎大家关注&&收藏&&订阅!持续更新中,up!up!up!!
24 9
|
6天前
|
Java API
【Java】Object、Objects、包装类、StringBuilder、StringJoiner
【Java】Object、Objects、包装类、StringBuilder、StringJoiner
|
1月前
|
存储 Java
Java中的基本数据类型及其包装类
Java中的基本数据类型及其包装类
|
1月前
|
存储 Java
Java中的基本数据类型及其包装类
Java中的基本数据类型及其包装类
|
2月前
|
Java
【Java】Java的包装类(Wrapper Classes)
【Java】Java的包装类(Wrapper Classes)
16 0