包装类

包装类

  1. 针对八种基本定义相应的引用类型——包装类
  2. 有类的特点,就可以调用类中的方法。
  • 包装类的分类

    基本数据类型 包装类
    boolean Boolean
    char Character
    byte Byte
    short Short
    int Integer
    long Long
    float Float
    double Double

Wrapper

  • 包装类和基本数据的转换(装箱和拆箱)

    1. jdk5 前的是手动装箱和拆箱的方式。(装箱:基本类型 -> 包装类,反之拆箱)
    2. jdk5 后(含jdk5) 的自动装箱和拆箱方式。
    3. 自动装箱底层调用的是valueOf方法,比如Integer.valueOf()。
    4. 其他包装类的用法类似。
    public class Integer01 {
        public static void main(String[] args) {
            // 演示Integer的装箱和拆箱
            // jdk5.0 前是手动装箱和拆箱
            //手动装箱 int -> Integer
            int n1 = 100;
            Integer integer = new Integer(n1);
            Integer integer1 = Integer.valueOf(n1);
    
            // 手动拆箱 Integer -> int
            int i = integer.intValue();
    
            //jdk5以后,就可以自动装箱和自动拆箱
            int n2 = 200;
            //自动装箱 int -> Integer
            Integer integer2 = n2;//在底层依旧使用的是Integer.valueOf(n2)方法,这个方法,只是优化了语法
            //自动拆箱 Integer -> int
            int n3 = integer2;//在底层依旧使用的是intValue()方法。
        }
    }
    
  • 包装类型和String类型的相互转换

    public class WrapperVSString {
        public static void main(String[] args) {
            //包装类 -> String
            Integer i = 100;//自动装箱
            //方式(1)
            String str = i + "";
            //方式(2)
            String str1 = i.toString();
            //方式(3)
            String str3 = String.valueOf(i);//底层用的还是toString方法
    
            //String -> 包装类(Integer)
            String str4 = "1234";
            //方式(1):
            Integer i2 = Integer.parseInt(str4);//有使用到自动装箱,以下两个方法实质都是利用者方式1
    
            //方式(2):
            Integer i1 = Integer.valueOf(str4);
            //Integer.valueOf(str4) 中 valueOf方法的源码:
            //public static Integer valueOf(String s) throws NumberFormatException {
            //        return Integer.valueOf(parseInt(s, 10));
            //    }
    
            //方式(3):
            Integer i3 = new Integer(str4);
            //new Integer(str4) 中 这个构造方法源码:
            //public Integer(String s) throws NumberFormatException {
            //        this.value = parseInt(s, 10);
            //    }
        }
    }
    
  • Integer创建机制

    Integer类内部有一个静态内部类IntegerCache,内部有静态成员储存了-128到127的Integer数组。

    当利用valueOf方法创建Integer类对象时,而值又在[-128,127]范围内时它就会返回这个数组中值对应的对象。

    //IntegerCache源码    
    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() {}
        }
    
    //valueOf方法    
    public static Integer valueOf(int i) {
            if (i >= IntegerCache.low && i <= IntegerCache.high)
                return IntegerCache.cache[i + (-IntegerCache.low)];
            return new Integer(i);
        }
    

    预先就创建好了共256个Integer对象供后续使用。整个IntegerCache类中的代码均被static修饰,目的是确保在被实际使用时就已经完成了初始化,IntegerCache类中使用cache[]数组缓存了从-128~127供256个Integer对象。

    回到valueOf方法,可见,如果传入的int值在cache缓存-128~127的范围中,则直接返回预先创建好的对象,如果不在范围中,则创建一个新的Integer对象返回。

    //案例
    public void method1(){
    	Integer i new Integer(1);
    	Integer j new Integer(1);
    	System.out.printin(i==j)://False
    	//所以,这里主要是看范围-128~127就是直接返回
    	Integer m=1;//底层Integer.valueOf(1);->阅读源码
    	Integer n=1;//底层Integer.valueOf(1)i
    	System.out.printin(m == n); //T
    	//所以,这里主要是看范围-128~127就是直接返回
    	//,否则,就new Integer(xx);
    	Integer x = 128;//底层Integer.valueOf(1):
    	Integer y = 128;//底层Integer..valueOf(1):
    	System.out.printin(x == y)//False
    }
    
hmoban主题是根据ripro二开的主题,极致后台体验,无插件,集成会员系统
自学咖网 » 包装类