装箱和拆箱、类型比较

转自https://www.cnblogs.com/youyingchou/p/6386358.html

转自https://blog.youkuaiyun.com/wyy6713/article/details/59500293

装箱和拆箱

1.装箱，值类型向引用类型转换：

                      在托管堆中分配内存，分配的内存量是类型各字段所需的内存量+类型对象指针所需的内存量+同步块索引所需的内存量。

                      值类型的字段复制到分配好的内存中

                      返回对象地址，现在对象地址是对象引用

2.拆箱，引用类型向值类型转换：

                      获取已装箱类型中的未装箱部分，也就是对象的原始值的各个字段

                      复制字段的值从堆中到栈中的值类型实例中

 

所以拆箱是不需要分配内存的，但是都要复制。

 

== Equals的比较

object的equlas是比较引用地址。equlas可以重写。object的==为比较引用，为静态方法。object的equlas为比较引用。所有类型的最终基类都是object。

 

引用类型：直接继承与object。所以如果类型没有重写equlas的话，equlas默认是调用object的方法，会比较引用地址。如果重写则调用重写的方法。

如果类型没有重写==的话，会调用object的==，为比较引用地址。如果重写，会自动调用类型的重写的方法。

比如string类型，重写了equlas和重写了==，所以string的==和equlas都是比较值。

 

值类型：直接继承System.ValueType，这个类型继承object。System.ValueType把equlas重写为比较值，所以如果没有重写，值类型的equlas都是比较值。如果重写，则调用重写的方法。

如果值类型没有重载==的话，无法使用==操作。（因为都是值类型，比较引用没任何意义，所以不调用object的==）

基元类型（比如int、double之类的）每个都重载了==，所以基元类型的==都比较值。

 

Test a = new Test { a = 1 };
Test b = new Test { a = 1 };

Console.WriteLine(a == b); //false 因为test没有重载==，所以调用object的==，比较的是引用的地址，两个引用类型的对象引用地址自然不同
Console.WriteLine(a.Equals(b));//false 因为Test类没有重写equlas，则调用的是Object.equals，而Object的equlas比较的是引用的地址

 

object c = 1;
object d = 1;

Console.WriteLine(c==d);//false  两个参数都已经装箱，成为引用类型，所以引用地址不同。这里调用的是object的==，所以比较引用地址
Console.WriteLine(c.Equals(d));//true，这里调用的是object.equlas，但是值类型的基类System.ValueType重写了equlas，所以这里比较的时候比较的两个参数的值

 

string e = "123";
string f = "123";//编译源代码时，编译器必须处理每个字面值字符串，并在托管模块的元数据中嵌入。但是这样会让元数据变得庞大，所以引用该字符串的所有代码都被修改成引用元数据中的同一个字符串，所以引用地址相同。（字符串池）因此这里e和f引用的同一个字符串

Console.WriteLine(ReferenceEquals(e, f));//true 所以说明这两个参数的引用地址相等
Console.WriteLine(e == f); //true string类型==比较值
Console.WriteLine(e.Equals(f));//true string类型equlas比较值
Console.WriteLine((object)e == (object)f); //true 这里的==调用的是object的==，比较引用，但是因为引用e和f的引用地址相同，所以还是返回true

string z = string.Copy(e);
Console.WriteLine(ReferenceEquals(z, e));//false 直接copy，另外分配内存复制值进去，就和普通引用对象一样，所以引用地址不同
Console.WriteLine(z==e); //true 虽然引用地址已经不相同了，但是string的==比较值，所以相等

Console.WriteLine(z.Equals(e));//true 虽然引用地址已经不相同了，但是string的equals比较值

 

object j = z;
object k = e;
Console.WriteLine(j.Equals(k));//true 因为string类型重写了object的equlas方法，所以当调用object的equlas方法的时候执行的是string的方法，比较j和k的值
Console.WriteLine(j == k);//false 调用的object的==，比较引用，所以是false（需要注意的是==是静态方法，所以这里调用的==会直接执行object的，而上面的equlas不同，因为进行了重写，所以会最终调用string的equlas方法）
Console.WriteLine(ReferenceEquals(j, k)); //false 地址不同

 

int h = 1;
int i = 1;

Console.WriteLine(h==i); //true 值类型==比较的两个数的值
Console.WriteLine(h.Equals(i));//true ，值类型的基类System.ValueType重写了equlas，使比较的时候比较的两个参数的值

 

ReferenceEquals

object的静态类型方法，比较两个参数的引用地址。和==操作运算符很像，但是==是可以被重载的。所以比较引用类型的引用地址时候用这个最好。（这个方法其实就是调用默认的==比较引用地址）

 

Equlas的重写

1.判断传递的值是否为null，如果为null，则返回false

2.判断传递的值和this是否引用同一地址，如果同一地址，则返回true

3.判断传递的值的类型和this的类型是否一致，类型不一致，则不可能相等,返回false

4.根据传递的值的字段和this的字段进行比较，只要有不一致，则返回false

5.调用基类的equlas，如果为true，则返回true，如果为false，则返回false。

——————————————————————————————第二篇：基本类型优先于装箱基本类—————————————————————————————————

在基本类型和装箱基本类型中有3个主要区别：
1、基本类型只有值，装箱基本类型具有与它们的值不同的统一性；
2、基本类型只有功能完备的值，而每个装箱基本类型除了它对应基本类型的所有功能值外，还有个非功能值–null；
3、基本类型比装箱基本类型更节省时间和空间。

看下面的一个小例子：

public class Unbelievable {
    static Integer i;
    public static void main(String[] args) {
        if (i == 42) {
            System.out.println("Unbelievable");
        }
    }
}

View Code

它不是打印出“Unbelievable”，而是在计算表达式i==42的时候，抛出“Exception in thread “main” java.lang.NullPointerException”。问题在于，i是个interger，而不是int，就像所有的对象引用域一样，它的初始值为null，当程序计算表达式i==42的时候，它会将integer与int进行比较，几乎在任何一种情况下，当在一项操作中混合使用基本类型和装箱基本类型时，装箱基本类型会自动拆箱，如果null对象引用被自动拆箱，就会得到一个NullPointerException异常，就像这个程序一样，它可以在任何位置发生。修正这个问题很简单，声明i为int而不是integer就行了。

下面继续看个小例子：

   public static void main(String[] args) {
        Long sum = 0L;
        long startTime = System.currentTimeMillis();
        for(long i = 0;i<Integer.MAX_VALUE;i++) {
            sum += i;
        }
        System.out.println(sum);
        System.out.println(System.currentTimeMillis() - startTime);
    }

View Code

这个程序运行起来比预期的要慢一些，因为不小心将局部变量sum声明成了装箱基本类型Long，程序编译起来没有警告或者错误，但是变量被反复的装箱和拆箱，导致性能明显下降。‘
将Long改成long之后，看看他们之间的性能比较：
long—–54ms；
Long—–6638ms，它们之间的性能相差了100多倍左右。
那么什么时候应该使用装箱基本类型呢？他们有几个合理的用处：
1.作为集合中的元素，键和值；
2.在参数化类型中，必须使用装箱基本类型作为类型参数，因为java不允许使用基本类型，例如ThreadLocal
3.在会进行反射的方法调用，必须使用装箱基本类型。

总之，在选择的时候，基本类型要优先于装箱基本类型。基本类型更加简单，也更加快速。当程序用==操作进行两个装箱基本类型时，它做了一个同一性比较，这不是你所希望看到的。
当程序进行涉及装箱和拆箱基本类型的混合类型计算的时候，它会进行拆箱，当程序进行拆箱时，会抛出NullPointerException异常。
最后，当程序装箱了基本类型的值时，会导致高开销和不必要的对象的创建。

转载于:https://www.cnblogs.com/lijingran/p/8672640.html