Java数据类型—包装类

爱被打了一巴掌 2022-12-28 11:09 158阅读 0赞

### 文章目录 ###

*   *  包装类
     *   *  那么为什么需要包装类
         *  拆箱与装箱
         *  自动拆箱与自动装箱
         *  什么时候进行自动拆装箱？
         *  注意的点
         *  包装类型与switch
     *  总结

## 包装类 ##

在Java5 中添加了两个新特性，那就是自动装箱和拆箱，因为基本类型的广泛使用，但是Java 又是面向对象的语言，所以提供了包装类型的支持

我们知道基本数据类型包括byte, short, int, long, float, double, char, boolean，对应的包装类分别是Byte, Short, Integer, Long, Float, Double, Character, Boolean。关于基本数据类型的介绍可参考[八大基本数据类型][Link 1]

在这一节里我们主要以Integer和int 进行讲解，其他的可以类比

### 那么为什么需要包装类 ###

**JAVA是面向对象的语言，很多类和方法中的参数都需使用对象(例如集合)，但基本数据类型却不是面向对象的，这就造成了很多不便**。

如：`List<int> = new ArrayList<>();`，就**无法编译通过**

为了解决该问题，我们引入了包装类，顾名思义，就是将基本类型“**包装起来**“，**使其具备对象的性质**，包括可以添加属性和方法，位于java.lang包下。

### 拆箱与装箱 ###

既然有了基本数据类型和包装类，就必然存在它们之间的转换，如：

public static void main(String[] args) {
        Integer a = 0;
        for(int i = 0; i < 100; i++){
            a += i;
        }
    }

将基本数据类型转化为对应类型的包装类的过程叫“**装箱**”；将包装类转为对应类型的基本数据类型的过程叫“**拆箱**”

在上面中给变量a赋值的时候就发生了装箱，而在参与计算的过程中就发生了拆箱，但是我们好像什么都没做，这句是自动拆装箱

下面我们再给一个例子

**装箱**

int num = 25;
    Integer i = Integer.valueOf(num);
    Integer i = 25;

**拆箱**

Integer i = new Integer(10);
    //unboxing
    int num = i;
    Float f = new Float(56.78);
    float fNum = f;

### 自动拆箱与自动装箱 ###

**Java为了简便拆箱与装箱的操作，提供了自动拆装箱的功能**，这极大地方便了程序员们。**那么到底是如何实现的呢？**。这个特性是在java5中引入的

上面的例子就是一个自动拆箱与装箱的过程，通过反编译工具我们得到，

public static void main(String[] args) {
        Integer a = Integer.valueOf(0);
        for (int i = 0; i < 100; i++) {
            a = Integer.valueOf(a.intValue() + i);
        }
    }

我们不难发现，主要调用了两个方法，**Integer.intValue()** 和 **Integer.valueOf( int i)** 方法

查看Integer源码，我们找到了对应代码：

/** * Returns the value of this {@code Integer} as an {@code int}. * 返回一个 Integer 的int 值 */
      public int intValue() { 
          return value;
      }
    /** * Returns an {@code Integer} instance representing the specified {@code int} value. * 返回一个代表特定int 值的 Integer 对象 * If a new {@code Integer} instance is not required, this method should generally be used in preference to the constructor {@link #Integer(int)}, * 如果不需要一个新的Integer 实例，则通常应优先使用此方法而不是构造函数 * as this method is likely to yield significantly better space and time performance by caching frequently requested values. * 因为这种方法可以通过缓存频繁请求的值来获得更好的空间和时间性能。 * This method will always cache values in the range -128 to 127,inclusive, and may cache other values outside of this range. * 此方法将始终缓存-128到127（含）范围内的值，并可能缓存此范围之外的其他值。 * @param i an {@code int} value. * @return an {@code Integer} instance representing {@code i}. * @since 1.5 */
    public static Integer valueOf(int i) { 
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

很明显，我们我们得出，Java帮你隐藏了内部细节。拆箱的过程就是通过Integer 实体调用intValue()方法；装箱的过程就是调用了 Integer.valueOf(int i) 方法，帮你直接new了一个Integer对象

### 什么时候进行自动拆装箱？ ###

其实很简单(就是在需要对象的时候就装箱需要基本类型的时候就拆箱)

1.添加到集合中时，进行自动装箱

2.涉及到运算的时候，“加，减，乘， 除” 以及 “比较 equals,compareTo”，进行自动拆箱

例如下面这一段代码，则发生了自动装箱

List<Integer> li = new ArrayList<>();
    for (int i = 1; i < 10; i++){ 
        li.add(i);
    }

### 注意的点 ###

在上述的代码中，关于Integer valueOf(int i)方法中有IntegerCache类，在自动装箱的过程中有个条件判断

if (i >= IntegerCache.low && i <= IntegerCache.high)

结合注释

`This method will always cache values in the range -128 to 127, inclusive, and may cache other values outside of this range`

大意是：该方法总是缓存-128 到 127之间的值，同时针对超出这个范围的值也是可能缓存的。

那么为什么可能缓存？其实在IntegerCache源码中可以得到答案

/** * Cache to support the object identity semantics of autoboxing for values between * -128 and 127 (inclusive) as required by JLS. * * The cache is initialized on first usage. The size of the cache * may be controlled by the {@code -XX:AutoBoxCacheMax=<size>} option. * During VM initialization, java.lang.Integer.IntegerCache.high property * may be set and saved in the private system properties in the sun.misc.VM class. */
    
    private static class IntegerCache { 
        static final int low = -128;
        static final int high;
        static final Integer cache[];
    
        static { 
            // high value may be configured by property
            int h = 127;
            String integerCacheHighPropValue =
                sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
            if (integerCacheHighPropValue != null) { 
                try { 
                    int i = parseInt(integerCacheHighPropValue);
                    i = Math.max(i, 127);
                    // Maximum array size is Integer.MAX_VALUE
                    h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
                } catch( NumberFormatException nfe) { 
                    // If the property cannot be parsed into an int, ignore it.
                }
            }
            high = h;
    
            cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);
    
            // range [-128, 127] must be interned (JLS7 5.1.7)
            assert IntegerCache.high >= 127;
        }
    
        private IntegerCache() { }
    }

因为缓存最大值是可以配置的。这样设计有一定好处，我们可以根据应用程序的实际情况灵活地调整来提高性能。

可以在vm中修改即可调整缓存大小`java -Djava.lang.Integer.IntegerCache.high = xxxx Aclass.class` 或者 `-XX:AutoBoxCacheMax=xxxx`

但是这里有问题需要注意，就是从上面代码的逻辑我们可看出,我们**只能设置high而不能设置low,还有就是如果high 小于127 将不能生效**，其中的low的下限是最开始的时候就固定死了的 final int low = -128;而其中的high虽然是设置了final int的，但是最初的时候，是还没有赋值的；所以我们可以通过设置 `java -Djava.lang.Integer.IntegerCache.high = xxxx Aclass.class` 或者 `-XX:AutoBoxCacheMax=xxxx`

接下来我们通过一段代码进行验证一下,首先我们看一下代码，当运行之后我们可以设置参数`-XX:AutoBoxCacheMax=1000` 再运行一次

public class TestAutoBoxCache { 
    
        @Test
        public void test() { 
            Integer a = 127;
            Integer b = 127;
            System.out.println(a == b);
    
            Integer c = 128;
            Integer d = 128;
            System.out.println(c == d);
    
            Integer e = 1000;
            Integer f = 1000;
            System.out.println(e == f);
    
            Integer g = 1001;
            Integer h = 1001;
            System.out.println(g == h);
    
            Integer i = 20000;
            Integer j = 20000;
            System.out.println(i == j);
        }
    }
    // 没有设置参数之前的输出
    true
    false
    false
    false
    false
    // 设置参数之后的输出 -XX:AutoBoxCacheMax=1000 
    true
    true
    true
    false
    false

因为缓存设置的实1000，也就是在\[-128,1000\] 之间的就缓存了，也验证了我们上面的说法是正确的

与之类似的缓存还有:

Byte与ByteCache，缓存值范围-128到127，固定不可配置(其实就是全部缓存了)

Short与ShortCache，缓存值范围-128到127，固定不可配置

Long与LongCache，缓存值范围-128到127，固定不可配置

Character与CharacterCache，缓存值范围0到127，固定不可配置

### 包装类型与switch ###

public static void main(String[] args) { 
        int iVal = 7;
        switch(iVal) { 
            case 1: System.out.println("First step");
                break;
            case 2: System.out.println("Second step");
                break;
            default: System.out.println("There is some error");
        }
    }

包装类型和基本类型一样，或者说是和String 一样都是支持switch 的

## 总结 ##

1.  为什么需要包装类：**JAVA是面向对象的语言，很多类和方法中的参数都需使用对象(例如集合)，但基本数据类型却不是面向对象的，这就造成了很多不便**
2.  拆装箱的概念：将基本数据类型转为包装类的过程叫“**装箱**”，将包装类转为基本数据类型的过程叫“**拆箱**”
3.  自动拆装箱：**Java为了简便拆箱与装箱的操作，提供了自动拆装箱的功能**，对于Integer， 拆箱的过程就是通过Integer 实体调用intValue()方法；装箱的过程就是调用了 Integer.valueOf(int i) 方法，帮你直接new了一个Integer对象
4.  建议使用valueOf() 方法创建一个包装类实例而不是直接使用构造方法，因为该方法可以走缓存提高性能

[Link 1]: https://blog.csdn.net/king14bhhb/article/details/110631164