那些java中的包装类

说到Java中的包装类就不得不介绍一下Java中的基本数据类型（8种）：byte、short、int、long、float、double、char、boolean。下面以表格的形式详细介绍这八种数据类型：

	byte	short	int	long	float	double	char	boolean
位数	8	16	32	64	32	64	16	1
字节数	1	2	4	8	4	8	2	1(1/8)
默认值	0	0	0	0L	0.0f	0.0d		false
包装类型	Byte	Short	Integer	Long	Float	Double	Character	Boolean

特别说明：

• char类型占2个字节，可以表示汉字，所以无论是汉字还是英文字符都占2字节
• boolean类型理论上占1bit（1/8字节），而实际中按1byte（1字节）处理
• 基本数据类型之间的转换：低级向高级自动转换（隐式），高级向低级强制转换（显式）

   1 public class DataTypeDemo {
   2 
   3     byte a;
   4     short b;
   5     int c;
   6     long d;
   7     float e;
   8     double f;
   9     boolean g;
  10     char h;
  11     
  12     public static void main(String[] args) {
  13         /*
  14          * 几种基本数据类型的大小(bit)
  15          */
  16         System.out.println(Byte.SIZE); //8
  17         System.out.println(Short.SIZE);//16
  18         System.out.println(Integer.SIZE);//32
  19         System.out.println(Long.SIZE);//64
  20         System.out.println(Float.SIZE);//32
  21         System.out.println(Double.SIZE);//64
  22         System.out.println(Character.SIZE);//16
  23         
  24         /*
  25          * 基本数据类型的默认值
  26          */
  27         DataTypeDemo dtd = new DataTypeDemo();
  28         System.out.println(dtd.a);//0
  29         System.out.println(dtd.b);//0
  30         System.out.println(dtd.c);//0
  31         System.out.println(dtd.d);//0
  32         System.out.println(dtd.e);//0.0
  33         System.out.println(dtd.f);//0.0
  34         System.out.println(dtd.g);//false
  35         System.out.println(dtd.h);//
  36         
  37         /*
  38          * char类型可以表示汉字
  39          */
  40         char ch = '犇';
  41         System.out.println(ch);//犇
  42     }
  43 
  44 }

public class DataTypeDemo {

    byte a;
    short b;
    int c;
    long d;
    float e;
    double f;
    boolean g;
    char h;
    
    public static void main(String[] args) {
        /*
         * 几种基本数据类型的大小(bit)
         */
        System.out.println(Byte.SIZE); //8
        System.out.println(Short.SIZE);//16
        System.out.println(Integer.SIZE);//32
        System.out.println(Long.SIZE);//64
        System.out.println(Float.SIZE);//32
        System.out.println(Double.SIZE);//64
        System.out.println(Character.SIZE);//16
        
        /*
         * 基本数据类型的默认值
         */
        DataTypeDemo dtd = new DataTypeDemo();
        System.out.println(dtd.a);//0
        System.out.println(dtd.b);//0
        System.out.println(dtd.c);//0
        System.out.println(dtd.d);//0
        System.out.println(dtd.e);//0.0
        System.out.println(dtd.f);//0.0
        System.out.println(dtd.g);//false
        System.out.println(dtd.h);//
        
        /*
         * char类型占2字节，可以表示汉字
         */
        char ch = '犇';
        System.out.println(ch);//犇
        
        /*
         * 基本数据类型的转换
         *     低级->高级：自动转换，隐式的
         *     高级->低级：强制转换，显式的
         * 另外，常规的算术运算(+、-、*、/)都要求是int型的
         *     所以对于较int低级的数据类型会进行隐式转换，而较int高级的则要求强转，否则报错
         */
        byte n1 = 10, n2 = 20;
        int n3, n4 = 100;
        long n5 = 200;
        //隐式转换
        n3 = n1;
        //显式转换
//        n3 = n5;    编译报错
        n3 = (int) n5;
        
        //算术运算,"+"两边的操作数会自动转换为int型
        n3 = n1 + n2;
//        n3 = n4 + n5;  编译报错：需要强转
        //修改后
        n3 = n4 + (int)n5;
        n3 = (int) (n4 + n5);
        
//        n3 = n4/(int)n5;
//        n3 = (int) (n4/n5);
    }
}

一、包装类的理解

 为了满足Java语言面向对象的这一特性，上述基本数据类型中的每一个在java.lang包中都有一个包装类，即将每个基本类型都包装成了一个类。常用的包装类可以分为三类：Character、Number、Boolean，具体见上表所示。

这里总结一下包装类的一些特性：

• 所有包装类都可以将与之对应的基本数据类型作为参数来创建它们的实例对象
• 除了Character类之外，其他包装类都可以将一个字符串作为参数来构造它们的实例
• Boolean类的构造方法参数为String类型时，若该字符串为true（不论大小写），则该对象表示true，否则表示false
• 当包装类Number构造方法的参数为String类型时，字符串不能为null，并且该字符串必须能够解析为基本类型的数据

代码示例：

public static void main(String[] args) {
        //所有包装类都可以将与之对应的基本数据类型作为参数来创建它们的实例对象
        Integer a = new Integer(100);
        Double b = new Double(100.00);
        Character c = new Character('A');
        Boolean d = new Boolean(true);
        System.out.println(a+" "+ b+" "+c+" "+d);//100 100.0 A true
        
        //除了Character类之外，其他包装类都可以将一个字符串作为参数来构造它们的实例
        Integer a1 = new Integer("100");
        Double b1 = new Double("100.00");
        Boolean d1 = new Boolean("true");
        System.out.println(a1+" "+ b1+" "+d1);//100 100.0 true        
        
        /*
         * Boolean类的构造方法参数为String类型时:
         *     若该字符串为true（不论大小写），则该对象表示true，否则表示false
         */
        Boolean d2 = new Boolean("True");
        Boolean d3 = new Boolean("TRUE");
        Boolean d4 = new Boolean("hello");
        System.out.println(d2+" "+d3+" "+d4);//true true false
        
        /*
         * 当包装类Number构造方法的参数为String类型时，字符串不能为null
         *     并且该字符串必须能够解析为基本类型的数据
         *     否则会抛出数字格式异常。
         */
        Integer a2 = new Integer("");//NumberFormatException: For input string: ""
        Integer a3 = new Integer(null);//NumberFormatException: null
        Integer a4 = new Integer("abc");//NumberFormatException: For input string: "abc"
        
    }

二、包装类的作用

总的来说，包装类有以下一些用途：

• 集合不允许存放基本数据类型，故常用包装类
• 包含了每种基本数据类型的相关属性，如最大值、最小值、所占位数等
• 作为基本数据类型对应的类类型，提供了一系列实用的对象操作，如类型转换、进制转换等等

    private static void getInfo() {
        
        //获取基本数据类型的相关属性
        System.out.println(Byte.MIN_VALUE);//-128
        System.out.println(Byte.MAX_VALUE);//127
        System.out.println(Byte.SIZE);//8
        
        /*
         * 包装类型的一些实用操作，如类型转换、进制转换等
         *     这里以Integer为例，主要介绍intValue、（static）parseInt、（static）toString等方法
         */
        //调用构造器将int类型转换为integer类型，调用intValue方法将integer类型转换为int类型
        Integer in1 = new Integer(100);
        int in2 = in1.intValue();
        
        //将字符串转换为十进制数的int数，常用于任意进制数转换为十进制数
        int num1 = Integer.parseInt("100");
        System.out.println(num1); //100
        //将字符串按任意进制转换为int数
        int num2 = Integer.parseInt("100", 8);
        int num3 = Integer.parseInt("ff", 16);
        System.out.println(num2); //64
        System.out.println(num3);
        
        //将int数转换为对应的String类型的数
        String s1 = Integer.toString(100);
        System.out.println(s1);//100
        //将int数转换为任意进制的String类型的数，常用于十进制数转换为任意进制数
        String s2 = Integer.toString(100,8);
        String s3 = Integer.toString(100,16);
        System.out.println(s2);//144
        System.out.println(s3);//64
    }

事实上，从JDK1.5就开始引入了自动拆装箱的语法功能，也就是系统将自动进行基本数据类型和与之相对应的包装类型之间的转换，这使得程序员书写代码更加方便。

        //自动装箱
        int m = 10;
        Integer in = m;
        System.out.println(in);//10
        
        //自动拆箱
        Integer inn = new Integer(10);
        int n = inn;
        System.out.println(n);//10

 

补充一：包装类中“==”与equals的用法比较

值得注意的是，包装类中的equals方法和String类一样，都是重写了Object类中的equals方法，因此比较的是内容而不是地址，而“==”比较的依然是引用变量的地址，只是当包装类型和与之相对应的基本类型进行“==”比较时会先做自动拆箱处理。

    private static void equals() {
        // TODO Auto-generated method stub
        Integer a = new Integer(-100);
        Integer b = new Integer("-100");
        int c = -100;
        System.out.println(a == b);//false
        System.out.println(a == c);//true
        System.out.println(b == c);//true
        
        System.out.println(a.equals(b));//true
    
        String s1 = new String("hello");
        String s2 = new String("hello");
        System.out.println(s1 == s2);//false
        System.out.println(s1.equals(s2));//true
        
    }

 补充二：java中数组声明的正确语法

总的来说，数组声明的方式有两种：指定数组大小和初始化，并且二者不能同时存在。

public class ArrayDemo {
    public static void main(String[] args) {
        //指定数组大小
        int a[] = new int[3]; 
        //数组初始化
        int b[] = {1,2,3};    
        int[] c = {1,2,3};    
        int[] d = new int[]{1,2,3};
        
        /*
         * 几种错误的语法
         */
//        int a[10] = {};        错误：既指定了大小又想初始化
//        int a[3] = {1,2,3};    错误：理由同上
//        int[] a = new int[3]{1,2,3};错误：理由同上
        
        //必须将声明、创建、初始化都放在一条语句中，否则报错
//        int[] arr;
//        arr = {1,2,3};
    }

}