Java SE之装箱与拆箱【基本数据类型的包装类/==与equals方法】

 对象包装器、自动装箱与拆箱   2016/11/30  晚

 

特点

      1.所有的基本类型都有一个包装器类与之对应。[Integer,Boolean,Long,Character,Short,Float,Double,Void,Byte]

public abstract class Number implements java.io.Serializable {

public final class Float extends Number implements Comparable<Float> {

      2.对象包装器类是final的,意味着：

                                      ①不能定义他们的子类。

                                      ②一旦构造了包装器，就不允许修改包装在其中的值.//如何理解其深意？内部不可变，外部装拆

                                            Eg1. public static void  triple(Integer x){  //won't work 

                                                    。。。   

                                                 }    //Integer x做形参，在函数体内是无法修改其值的。

                                            Eg2. public static void  triple(int x){  //will work 

                                                    x =  x+1;   

                                                  }    //对应的基本类型int x做形参，在函数体内是无法修改其值的。

      3.利用包装器的类特性为基本类型使用泛型。泛型<>的尖括号内的类型参数，不允许是基本类型。【泛型只允许类类型】

        Eg.我们要定义一个整型数组列表。而尖括号内的参数是不允许是基本类型，

           即：不允许写成ArrayList<int>.      解决办法：ArrayList<Integer>

原理：

      1.装箱：把基本类型用它们相应的引用类型包装起来，使其具有类对象的性质。

              Eg.Integer x = 100;                  

              自动装箱[声明并创建int x,将x的值放入Integer类中]  (编译器调用的是static Integer valueOf(int i))

                                                    

      2.拆箱：和装箱相反，将引用类型的对象简化成值类型的数据。

              Eg.int     y = new Integer(100);    自动拆箱

      Eg. Integer n=3;

           n++;   // [n拆箱；自增；n装箱]   注意与作形参的包装器区别。         

==与.equals(Object obj)

      ==与.equals(Object obj)：

          A.java的==有两种作用：【用于比较对象的存储区域或比较基本类型的数值】

                    ①用于比较两对象是否指向同一存储区域.       【比较对象的存储区域】 

                    ②用于比较两对象包装器对象：[具体分情况：]

                                a.比较两包装器的值：满足自动规范对象要求：int,short∈[-128,127];boolean,byte,char≤127     【比较基本类型】                     

                                b.不满足a条件时,执行①.

                          Eg3.Integer a = 1000; 

                              Integer b = 1000;

                              (a == b)           //result:fasle; 【比较对象的存储区域】 

                                                                  必须双方均为包装类对象，才以对象方式进行比较

                          Eg4.Integer a =100;

                              Integer b =100;

                              (a==b)             //result:true;  【比较基本类型】 

                          Eg5.Integer a = 100;

                              int b = 100; 

                              (a==b)             //result:true;  【比较基本类型】 

                          Eg6.int a = 1000;

                              Integer b = 1000; 

                              (a==b)             //result:true;  【比较基本类型】一旦有一方为基本类型，就以基本类型数值比较            B..equals(Object obj)仅用于单纯地进行比较两对象的内容，而非存储区域！

        

       综上，在比较两对象的内容时，建议使用equals()方法。

        

常用方法：

        .equals()  

        .toString()

        .praseX()   //字符串与基本类型值的转化的常用方法

        .compareTo()

        .XValue()

        .valueOf()  //自动装箱时也会调用。

测试试题

public class Main{
    public static void main(String []args){
        String str1 = new String("hello");
        String str2 = new String("hello");
        System.out.println(str1==str2);
        System.out.println(str1.equals(str2));//String equals已重写，比较内容

        Integer int1 = 127;
        Integer int2 = 127;
        System.out.println(int1==int2);
        System.out.println(int1.equals(int2));//Integer equals已重写，比较内容

        Character ch1 = 128;
        Character ch2 = 128;
        System.out.println(ch1==ch2);
        System.out.println(ch1.equals(ch2));//Character equals已重写，比较内容

        A a1 = new A();
        A a2 = new A();
        System.out.println(a1.equals(a2));//equals未重写，比较内存地址
        a2 = a1;
        System.out.println(a1.equals(a2));//equals未重写，比较内存地址
    }
}

class A extends Object{
    public String a;

    public void setA(){
        this.a = a;
    }

    public String getA(){
        return this.a;
    }
}

//output
false
true

true
true

false
true

false
true

总结

　　1.定义：拆箱、装箱

　　2.二者效率：包装类的效率远远低于基本类型。因为：每new一个对象需要消耗更多内存，装箱操作会创建对象，频繁的装箱操作会消耗许多内存，影响性能，所以可以避免装箱的时候应该尽量避免。
　　3.==与equals(Obj)的区别

1）对于==，如果作用于基本数据类型的变量，则直接比较其存储的 “值”是否相等；

　  如果作用于引用类型的变量，则比较的是所指向的对象的地址

2）对于equals方法，注意：equals方法不能作用于基本数据类型的变量

如果没有对equals方法进行重写，则比较的是引用类型的变量所指向的对象的地址；

　 诸如String、Date等类对equals方法进行了重写的话，比较的是所指向的对象的内容。

<引用出处:https://www.cnblogs.com/dolphin0520/p/3592500.html>

推荐文献
　　[1] 详解Java的自动装箱与拆箱(Autoboxing and unboxing)

　　[2] 深入剖析Java中的装箱和拆箱

　　[3] 浅谈Java中的equals和==