zoukankan      html  css  js  c++  java
  • int型数据的自动拆/装箱机制

    从JAVA 5开始引入基本数据类型的自动拆/装箱机制,Java 为每个原始类型提供了包装类型,如下:
    - 原始类型: boolean,char,byte,short,int,long,float,double
    - 包装类型:Boolean,Character,Byte,Short,Integer,Long,Float,Double

    先看看下边这段代码:

     1 class AutoUnboxingTest {
     2  
     3     public static void main(String[] args) {
     4         Integer a = new Integer(3);
     5         Integer b = 3;                  // 将3自动装箱成Integer类型
     6         int c = 3;
     7         System.out.println(a == b);     // false 两个引用没有引用同一对象
     8         System.out.println(a == c);     // true a自动拆箱成int类型再和c比较
     9     }
    10 }

    对象b的初始化默认调用了Integer类静态方法valuesOf,因此和a相比较是两个独立的对象;a和c在作比较的时候,a会自动拆箱成基本类型的int数据。

    再看下边一段代码:

    1 public class Test03 {
    2  
    3     public static void main(String[] args) {
    4         Integer f1 = 100, f2 = 100, f3 = 150, f4 = 150;
    5  
    6         System.out.println(f1 == f2);  //true
    7         System.out.println(f3 == f4);  //false
    8     }
    9 }

    如果不明就里很容易认为两个输出要么都是true要么都是false。首先需要注意的是f1、f2、f3、f4四个变量都是Integer对象引用,所以下面的==运算比较的不是值而是引用。装箱的本质是什么呢?当我们给一个Integer对象赋一个int值的时候,会调用Integer类的静态方法valueOf,如果看看valueOf的源代码就知道发生了什么。

    1 public static Integer valueOf(int i) {
    2     if (i >= IntegerCache.low && i <= IntegerCache.high)
    3         return IntegerCache.cache[i + (-IntegerCache.low)];
    4     return new Integer(i);
    5 }

    IntegerCache是Integer的内部类,其代码如下所示:

     1 /**
     2      * Cache to support the object identity semantics of autoboxing for values between
     3      * -128 and 127 (inclusive) as required by JLS.
     4      *
     5      * The cache is initialized on first usage.  The size of the cache
     6      * may be controlled by the {@code -XX:AutoBoxCacheMax=<size>} option.
     7      * During VM initialization, java.lang.Integer.IntegerCache.high property
     8      * may be set and saved in the private system properties in the
     9      * sun.misc.VM class.
    10      */
    11  
    12     private static class IntegerCache {
    13         static final int low = -128;
    14         static final int high;
    15         static final Integer cache[];
    16  
    17         static {
    18             // high value may be configured by property
    19             int h = 127;
    20             String integerCacheHighPropValue =
    21                 sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
    22             if (integerCacheHighPropValue != null) {
    23                 try {
    24                     int i = parseInt(integerCacheHighPropValue);
    25                     i = Math.max(i, 127);
    26                     // Maximum array size is Integer.MAX_VALUE
    27                     h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
    28                 } catch( NumberFormatException nfe) {
    29                     // If the property cannot be parsed into an int, ignore it.
    30                 }
    31             }
    32             high = h;
    33  
    34             cache = new Integer[(high - low) + 1];
    35             int j = low;
    36             for(int k = 0; k < cache.length; k++)
    37                 cache[k] = new Integer(j++);
    38  
    39             // range [-128, 127] must be interned (JLS7 5.1.7)
    40             assert IntegerCache.high >= 127;
    41         }
    42  
    43         private IntegerCache() {}
    44     }

    简单的说,如果整型字面量的值在-128到127之间,那么不会new新的Integer对象,而是直接引用常量池中的Integer对象,所以上面的面试题中f1==f2的结果是true,而f3==f4的结果是false。

  • 相关阅读:
    Saltstack module acl 详解
    Saltstack python client
    Saltstack简单使用
    P5488 差分与前缀和 NTT Lucas定理 多项式
    CF613D Kingdom and its Cities 虚树 树形dp 贪心
    7.1 NOI模拟赛 凸包套凸包 floyd 计算几何
    luogu P5633 最小度限制生成树 wqs二分
    7.1 NOI模拟赛 dp floyd
    springboot和springcloud
    springboot集成mybatis
  • 原文地址:https://www.cnblogs.com/NoctisYang/p/8876874.html
Copyright © 2011-2022 走看看