Java 包装类

标签：for   装箱   parse   bsp   传递参数   种类型   通过   最小   阶段   

先说说为什么会出现包装类呢？java是一门面向对象的编程语言，基本类型并不具有对象的性质，虽然java可以直接处理基本类型，但有时候需要将其作为对象来处理，这就需要将基本类型改为包装类型。

Java中八种基本数据类型对应的包装类型。

基本数据类型      包装类型

byte                    java.lang.Byte

short                   java.lang.Short

int                       java.lang.Integer

long                    java.lang.Long

float                    java.lang.Float

double                java.lang.Double

boolean              java.lang.Boolean

char                   java.lang.Character

先来看看包装类的继承关系，如下图：

结合以下代码来看为什么Java中会出现包装类型。

//需求：规定m1方法可以接受Java中的任何一种数据类型
public class IntegerTest01{
 public static void  m1(Object o){   
   System.out.println(o);
 }
 public static void main(String[] args){
   //基本数据类型
   byte b=10;
   //引用数据类型
   Byte b1=new Byte(b);
   m1(b1);   //10  Byte已经将Object中的toString方法重写
 }
}

以上代码定义了一个m1()方法，它的参数类型为Object类，是引用数据类型，m1方法如果想接受byte类型的数据，（byte类型的数据是基本数据类型），可以先将byte类型的数据包装成java.lang.Byte,再传递参数。

下面以java.lang.Integer;类型为例，讲解八种类型，也就是说这八种类型的方法是通用的。

public class IntegerTest02{
 public static void main(String[] args){
   //获取int类型的最大值和最小值
   System.out.println("int类型的最大值是: "+Integer.MAX_VALUE);
   System.out.println("int类型的最大值是："+Integer.MIN_VALUE);
   //以int推byte
   System.out.println("byte类型的最大值是："+Byte.MAX_VALUE);
   System.out.println("byte类型的最大值是："+Byte.MIN_VALUE);
   //创建integer类型的对象
   Integer i1=new Integer(10);   //将int类型转换为Integer类型
   Integer i2=new Integer("123");  //将字符串类型转换为Integer类型  （虽然可以将字符串类型转换为Integer类型，但该字符串也必须是数字）
    Integer i3=new Integer("abc");    //编译通过，运行时报异常：NumberFormatException
    System.out.println(i1);
   System.out.println(i2);
 }
}

再来看看Integer中常用的方法。

/*
Integer中常用的方法
*/
public class IntegerTest03{
 public static void main(String[] args){
   Integer i1=new Integer(10);  //int类型转换为Integer类型  基本数据类型转换为引用数据类型
    System.out.println(i1);     //10
   int i2=i1.intValue();        //Integer类型转换为int类型
   System.out.println(i2);     //10
   
   //static int parseInt(String s)  String类型转换为int类型
   int i3=Integer.parseInt("123");
   System.out.println(i3+1);    //124
   //int i4=Integer.parseInt("abc");   //报错：java.lang.NumberFormatException，String类型转换为字符串，这个字符串必须为数字字符串
    //System.out.println(i4);
   //static double parseDouble(String s) 
       //String类型转换为double类型    
   double i5=Double.parseDouble("2234.342");  
   System.out.println(i5+22.23);   //2256.572
   //将int类型的十进制转换为二进制
   String s1=Integer.toBinaryString(10);   //1010
   System.out.println(s1);
   //将int类型的十进制转换为八进制
   String s2=Integer.toOctalString(10);    //12
   System.out.println(s2);
   //将int类型的十进制转换为十六进制
   String s3=Integer.toHexString(10);      //a
   System.out.println(s3);    
   //int--->Integer
   Integer s4=Integer.valueOf(10);
   System.out.println(s4);              //10
   //String--->Integer
   Integer s5=Integer.valueOf("10");
   System.out.println(s5);             //10
 }
}

Integer，int，String三种类型相互转换。

/*
Integer
int 
String
三种类型相互转换
*/
public class IntegerTest04{
 public static void main(String[] args){
   //int-->Integer
   Integer i1=Integer.valueOf(10);    
   System.out.println(i1);               //10
   //Integer-->int
   int i2=i1.intValue();
   System.out.println(i2);              //10
   //String-->Integer
   Integer i3=Integer.valueOf("21131");
   System.out.println(i3);                //21131
   //Integer-->String
   String i6=Integer.toString(i3);   
   System.out.println(i6);                 //211131
   String i4=i3.toString();
   System.out.println(i4);                //21131
   //String-->int
   int i8=Integer.parseInt("23");
   System.out.println(i8);             //23
   //int-->String
   String i7=10+"";
 }
}

有了上面内容的基础，我们就可以来了解一下什么叫自动拆箱和自动装箱了。

1.自动装箱和自动拆箱是程序编译阶段的一个概念，和程序运行无关

2.自动装箱和自动拆箱的主要目的是方便程序员的调用

public class IntegerTest05{
 public static void main(String[] args){
   //JDK5.0之前的版本
   Integer i1=new Integer(10);    //int-->Integer
   int i2=i1.intValue();      //Integer-->int
   //自动装箱
   Integer i3=10;
   //自动拆箱
   int i4=i3;
   m1(10);       //自动装箱
 }
 public static void m1(Object o){
   System.out.println(o);
 }
 
}

结合以下代码深入讲解一下自动拆箱和自动装箱。

public class IntegerTest06{
 public static void main(String[] args){
   Integer i1=new Integer(10);
   Integer i2=new Integer(10);
   //这里不会有自动拆箱
   System.out.println(i1==i2);    //false
   //比较两个Integer类型的数据是否相等，不能用==
   //Integer已经重写了Object中的toString方法
   System.out.println(i1.equals(i2));   //true
   //注意以下程序
   //如果数据在[-128~127]之间，Java中引入了一个“整型常量池”，在方法区中。
   //该整型常量池只存储-128~127之间的数据。
   Integer i3=128;
   Integer i4=128;
   //上面的等同于
   //Integer i3=new Integer(128);
   //Integer i4=new Integer(128);
   System.out.println(i3==i4);    //false
   String s1="abc";
   String s2="abc";
   System.out.println(s1==s2);    //true
         Integer i5=127;      //这个程序不会在堆中创建对象，会直接在整型常量池中拿
                Integer i6=127;
               System.out.println(i5==i6);    //true
   Integer i7=-128;
   Integer i8=-128;
   System.out.println(i7==i8);     //true
   Integer i9=-129;
   Integer i10=-129;
   System.out.println(i9==i10);     //false
   }
}

Integer i1=new Integer(10);

Integer i2=new Integer(10);

System.out.println(i1==i2);

这里要注意i1和i2为Integer类型，没有自动拆箱，因此比较两个Integer类型的数据是否相等，不能用== ，跟之前讲String类型的比较方法是一致的，需要用equals()方法。接下来敲黑板了，如果数据在[-128~127]之间，Java中引入了一个“整型常量池”，在方法区中，该整型常量池只存储-128~127之间的数据。这就是为什么Integer i5=127;Integer i6=127;（这两句等同于Integer i5=new Integer(127);Integer i6=new Integer(127);）System.out.println(i5==i6); 结果为true，而Integer i3=128;Integer i4=128; System.out.println(i3==i4); 结果为false了。相当于前者用“==”比较的是字符串，而后者比较的是内存地址。

Java 包装类

标签：for   装箱   parse   bsp   传递参数   种类型   通过   最小   阶段   

原文地址：https://www.cnblogs.com/naihuangbao/p/9444530.html