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


相关文章
|
16天前
|
JavaScript Java 编译器
Java包装类和泛型的知识点详解
Java包装类和泛型的知识点的深度理解
|
1月前
|
存储 Java 数据库
java包装类的作用、基本类型和包装类型的区别
java包装类的作用、基本类型和包装类型的区别
31 0
java包装类的作用、基本类型和包装类型的区别
|
6月前
|
Java
java包装类
Java包装类是Java语言为每个基本数据类型提供的类。Java包装类的主要作用是将基本数据类型封装成对象,以便于在Java中使用。例如,int型的数据可以被封装成Integer对象,byte型的数据可以被封装成Byte对象,等等。Java包装类的主要方法包括:public static Object valueOf(String s):将字符串转换为对象;public static boolean isInstance(Object obj):检查对象是否是包装类的实例;public final int intValue():将对象转换为int型数据;public final byte by
39 0
|
7月前
|
Java
Java之包装类的详细解析
Java之包装类的详细解析
59 0
|
7月前
|
Java
Java包装类应用
Java包装类应用
32 0
|
6月前
|
Java
java包装类
Java中的包装类是为基本数据类型(byte、short、int、long、float、double、char)提供的类,它们的目的是为了解决基本数据类型在Java中的非面向对象性问题。 包装类的主要用途有两个: 提供了基本数据类型的一些额外的方法,如:toByte()、toShort()、toInt()、toLong()、toFloat()、toDouble()、toCharArray()等,这些方法可以将基本数据类型转换为对应的包装类对象。 将包装类对象转换为基本数据类型,可以使用包装类对象的intValue()、longValue()、floatValue()、doub
28 0
|
6月前
|
存储 缓存 Java
【面试题精讲】Java包装类缓存机制
【面试题精讲】Java包装类缓存机制
|
1月前
|
存储 缓存 Java
JAVA基本数据类型的包装类
JAVA基本数据类型的包装类
15 0
|
1月前
|
存储 Java API
Java 包装类:原始数据类型与迭代器
Iterator 接口提供了一种迭代集合的方法,即顺序访问集合中的每个元素。它支持 hasNext() 和 next() 方法,用于检查是否存在下一个元素以及获取下一个元素。 获取 Iterator 可以使用集合的 iterator() 方法获取 Iterator 实例:
52 0
|
1月前
|
存储 Java
Java面向对象之——包装类
Java面向对象之——包装类