标签：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了。相当于前者用“==”比较的是字符串，而后者比较的是内存地址。
标签：for 装箱 parse bsp 传递参数 种类型 通过 最小 阶段
原文地址：https://www.cnblogs.com/naihuangbao/p/9444530.html
