Java装箱拆箱及String转型分析

最新推荐文章于 2024-04-23 18:52:22 发布

JTuring~

最新推荐文章于 2024-04-23 18:52:22 发布

阅读量184

点赞数

分类专栏： JavaEE 文章标签： java 字符串

本文链接：https://blog.csdn.net/weixin_42376667/article/details/113946285

版权

JavaEE 专栏收录该内容

16 篇文章 0 订阅

订阅专栏

八大基本类型都有对应的包装类boolean-Boolean,char-Charanter,byte-Byte,short-Short,int-Integer,long-Long,float-Float,double-Double，但包装类中使用缓存机制的就只有Byte、Short、Integer、Long、Character。

基本类型字面量

基本类型定义的变量，其值都是字面量，大小可知，生命周期可知。由于栈的存取速度比堆快，效率高，所以字面量就直接被存放于栈中。

装箱： 基本类型转换为包装类型，自动装箱是在编译阶段自动调用valurOf方法。

拆箱： 包装类型转换为基本类型，自动拆箱是在编译阶段自动调用xxxValue()方法。

缓存机制

包装类的缓存是通过其中的静态内部类来实现的。

Integer

Integer中实现缓存的静态内部类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
                // 最大值再小也不能小于127
                // 最大值+最小值的绝对值不能超出int范围，防止溢出
                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;
        // 初始化缓存数组数据 -128~127
        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(int)方法中：

public static Integer valueOf(int i) {
    // 先判断I是否存在缓存数组中
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        // 如果存在则返回i在缓存数组中的位置
        return IntegerCache.cache[i + (-IntegerCache.low)];
    // 如果不存在，则直接通过i新建对象
    return new Integer(i);
}

Byte

Byte中实现缓存的静态内部类ByteCache，实现如下:

private static class ByteCache {
    private ByteCache(){}
    // 初始化缓存数组空间
    static final Byte cache[] = new Byte[-(-128) + 127 + 1];

    static {
        // 初始化缓存数组数据 -128~127
        for(int i = 0; i < cache.length; i++)
            cache[i] = new Byte((byte)(i - 128));
    }
}

Character

Character中实现缓存的静态内部类CharacterCache，实现如下:

private static class CharacterCache {
    private CharacterCache(){}
    // 初始化缓存数组空间 128个
    static final Character cache[] = new Character[127 + 1];

    static {
    // 初始化缓存数组数据 0~127
        for (int i = 0; i < cache.length; i++)
            cache[i] = new Character((char)i);
    }
}

Short

Short中实现缓存的静态内部类ShortCache，实现如下:

private static class ShortCache {
    private ShortCache(){}
    // 初始化缓存数组空间
    static final Short cache[] = new Short[-(-128) + 127 + 1];

    static {
        // 初始化缓存数组数据 -128~127
        for(int i = 0; i < cache.length; i++)
            cache[i] = new Short((short)(i - 128));
    }
}

Long

Short中实现缓存的静态内部类LongCache，实现如下:

    private static class LongCache {
        private LongCache(){}
        // 初始化缓存数组空间
        static final Long cache[] = new Long[-(-128) + 127 + 1];

        static {
            // 初始化缓存数组数据 -128~127
            for(int i = 0; i < cache.length; i++)
                cache[i] = new Long(i - 128);
        }
    }

Float/Double

对于float和double，装箱操作都是新建对象：

public static Float valueOf(float f) {
    return new Float(f);
}

public static Double valueOf(double d) {
    return new Double(d);
}

Boolean

Boolean有点特殊，通过valueof(boolean)进行装箱操作的boolean值相同则其包装对象相同，：

/**
 * The {@code Boolean} object corresponding to the primitive
 * value {@code true}.
 */
public static final Boolean TRUE = new Boolean(true);

/**
 * The {@code Boolean} object corresponding to the primitive
 * value {@code false}.
 */
public static final Boolean FALSE = new Boolean(false);

public static Boolean valueOf(boolean b) {
    return (b ? TRUE : FALSE);
}

如上，这是因为valueOf(boolean)方法始终返回静态常量TRUE/FALSE。

下面以int为例分析装箱拆箱的内存情况。

例1

int a=3;
int b=3;
a=4;

执行第一句：首先在栈中创建变量为a的引用，然后在栈中找有没有字面值为3的地址，没找到就在栈中开辟一个空间存放3，然后将a指向值为3的空间的地址。

执行第二句：首先在栈中创建变量为b的引用，然后在栈中找有没有字面值为3的地址，找到有，则把b指向3的地址。

这时会出现a,b都会指向栈中3的地址的现象。

执行第三句，首先在栈中找有没有字面值为4的地址，没有则创建空间存放4，然后把a指向4的地址。

例2

Integer aI=new Integer（3);

public Integer(int value) {
    this.value = value;
}

手动装箱，aI是实例，在栈中。new出来的是对象在堆中。栈中aI空间的值就是堆中对象的地址。对象内存中有一个value域，它的值为3。

例3

Integer aI=2;

编译优化：

Integer aI=Integer.valueOf(2);

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

自动装箱，调用Integer.valueOf(2)。i存在于valueOf(int)代码块中，是局部变量，首先会在栈中创建变量i的空间，并将2赋给i，也就是i的空间里存的是值2。

方法内部，判断2存在缓存池中，返回2在缓存池中的地址，所以aI的地址就是2在缓存池中的地址。

如果是：

Integer aI=128;

128不在缓存池中，调用构造方法新建对象。堆中对象内存中value域的值为128。aI的地址就是堆中这个对象的地址。

例4

int a=3;
Integer aI=a;

编译优化：

int a=3;
Integer aI=Integer.valueOf(a);

自动装箱，a变量在栈中有一个空间，a的地址指向栈中字面量为3的地址（没有则先创建）。

调用Integer.valueOf(a),i存在于valueOf(int)代码块中，是局部变量，首先会在栈中创建变量i的空间，并将a的值赋给i，也就是i的空间里存的是值3。之后和例2一样。

例5

Integer aI = 3;
int a = aI;

编译优化：

Integer aI = Integer.valueOf(3);;
int a = aI.intValue();

自动装箱、自动拆箱。我们只用关注第二行，第一行自动装箱前面已经分析过了。

第二行的aI实际会调用iniValue()方法来获取Integer类中的value值。前门我们分析到，aI的地址有两种情况：堆中对象地址或缓存池中值的地址。那么这里执行第二句代码时的内存是怎样的呢？
我们不妨再添加一行代码：

Integer aI = Integer.valueOf(3);;
int a = aI.intValue();
aI=null;

这样aI在栈中的空间就被释放了，但是对a却是没有任何影响的，所以执行第二句，就是将intValue()返回值存放在栈中a的内存空间，其实就是普通方法返回一个基本类型的值被基本类型变量接收而已。

调用Integer.valueOf(int a);

-128<=a<=127：则堆中不会新建对象（不会new），aI的地址就是缓存池中a的地址。
a<-128 || a>127：会在堆中创建对象(new)，对象中的vaule值就是a，aI的地址就是堆中对象的地址。
形参变量a和调用该方法的实参变量在内存上无关，形参变量a的值是对形参变量的值的拷贝。

String

String是不可变字符串，类声明由final修饰，它的内部通过字符数组常量存储字符串

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];

    /** Cache the hash code for the string */
    private int hash; // Default to 0
    ...
}

字符串常量池

由于字符串的使用率非常高，内存分配同样也需要消耗时间和空间，JVM为了提高性能、减少内存开销，使用字符串常量池来进行优化，字符串常量池位于堆中。

每当创建字符串常量时，JVM会首先检查这个字符串是否存在常量池中，如果不存在则会实例化该字符串并将其放入常量池中，如果存在，那么就直接返回这个字符串在常量池中的实例引用。字符串常量池中不存在两个相同的字符串。

至此我们了解到，字符串实例引用的地址可能是在字符串常量池中，也可能是在堆中。

“+”连接符

对于字符串来说，“+”是作为连接符来使用的，而不是二元算术运算符。字符串对象可以使用“+”来连接其他对象，其他对象对通过调用toString()方法来和字符串对象进行连接。

字符串字面量

直接使用双引号括起来的一系列字符就是字符串字面量。字符串字面量是存储在堆中的字符串常量池中。

和字符串字面量拼接

拼接对象为字符串字面量或基本类型数据

String s="ab";
String s1="a"+"b";
String s2="a"+true; // boolean
String s3="a"+'c'; //char
String s4 = 10+"a"; // int
String s5="a"+10f; // float
String s6=10.0+"a"; // double
String s7="a"+10L; // long

String s8="a"+010; // octal
String s9="a"+0x10; // hex
.....

会被编译优化：

String s="ab";
String s1="ab";
String s2 = "atrue";
String s3 = "ac";
String s4 = "10a";
String s5 = "a10.0";
String s6 = "10.0a";
String s7 = "a10";
String s8 = "a8";
String s9 = "a16";

如上都会被编译器整合为一个字符串字面量，如果带进制数值,会先转化为10进制再拼接，像这样直接是字符串字面量的，实例的引用s*都是指向字符串常量池中的字符串对象地址。

拼接对象为引用类型数据

String s="a";

String s1 = s + true;
String s2 = s + 1;
String s3 = s + '1';
String s4 = s + "1";
String s5 = s + new Object();

会被编译器优化为以下形式:

(new StringBuilder()).append(s).append(xxx).toString();

所以是将“+”转化为StringBuilder对象的append(xxx)进行连接，而且每一个语句都会新建一个StringBuilder的实例。

StringBuilder和StringBuffer都是可变字符串，编译使用StringBuilder的原因是因为StringBuilder比StringBuffer效率更高。StringBuilder线程不安全，StringBuffer线程安全，因为在StringBuffer的每一个更新操作方法上都使用了synchronized进行加锁同步，单线程环境下相对于使用StringBuilder极大的降低了效率。

String.valueOf(xxx)

将不同数据类型通过String.valueOf(xxx)转换为String存在不同的形式。

String s=String.valueOf(boolean)

public static String valueOf(boolean b) {
    return b ? "true" : "false";
}

s实例地址指向字符串常量池中字符串对象地址。

String s=String.valueOf(char)

public static String valueOf(char c) {
    char data[] = {c};
    return new String(data, true);
}

s实例地址指向堆中字符串对象地址。

String s=String.valueOf(int)

public static String valueOf(int i) {
    return Integer.toString(i);
}

Integer.toString(int):

public static String toString(int i) {
    if (i == Integer.MIN_VALUE)
        return "-2147483648";
    int size = (i < 0) ? stringSize(-i) + 1 : stringSize(i);
    char[] buf = new char[size];
    getChars(i, size, buf);
    return new String(buf, true);
}

s实例地址指向堆中字符串对象地址。

String s=String.valueOf(long)

public static String valueOf(long l) {
    return Long.toString(l);
}

Integer.toString(long):

public static String toString(long i) {
    if (i == Long.MIN_VALUE)
        return "-9223372036854775808";
    int size = (i < 0) ? stringSize(-i) + 1 : stringSize(i);
    char[] buf = new char[size];
    getChars(i, size, buf);
    return new String(buf, true);
}

s实例地址指向堆中字符串对象地址。

String s=String.valueOf(float)

public static String valueOf(float f) {
    return Float.toString(f);
}

浮点型数据有点复杂，下面是具体调用：
Float.toString(float):

public static String toString(float f) {
    return FloatingDecimal.toJavaFormatString(f);
}

FloatingDecimal.toJavaFormatString(float):

public static String toJavaFormatString(float var0) {
    return getBinaryToASCIIConverter(var0).toJavaFormatString();
}

toJavaFormatString():

public String toJavaFormatString() {
    int var1 = this.getChars(this.buffer);
    return new String(this.buffer, 0, var1);
}

所以，s实例地址指向堆中字符串对象地址。

String s=String.valueOf(double)

double类型和float类型数据一样，s实例地址指向堆中字符串对象地址。

String s=String.valueOf(Object)

public static String valueOf(Object obj) {
    return (obj == null) ? "null" : obj.toString();
}

obj.toString():

public String toString() {
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

正在toString()中会进行字符串连接，上面我们说到，这样的字符串连接会被转化为通过StringBuilder的方式完成，会新建对象，所以即使相同的对象调用String.valueOf(Object)方法转化为String对象，两个s是不相同的，指向不同的对空间地址。

综上:

boolean类型转String通过String.valueOf(xxx)转String，s指向字符串常量池中的字符串对象地址；
char/char[]类型转String通过String.valueOf(xxx)转String，s指向堆中字符串对象地址；
数值型数据通过String.valueOf(xxx)转String都会在堆中创建对象，s指向堆中字符串对象地址；
引用型数据通过String.valueOf(xxx)转String都会在堆中创建对象，s指向堆中字符串对象地址；

new String(String)

String s = new String("abc");

s肯定指向堆中字符串对象地址。关于"abc"也会在字符串常量池中创建自己的地址。
这里创建了两个对象。

intern()

String类中的intern()是个本地方法：

/**
 * Returns a canonical representation for the string object.
 * <p>
 * A pool of strings, initially empty, is maintained privately by the
 * class {@code String}.
 * <p>
 * When the intern method is invoked, if the pool already contains a
 * string equal to this {@code String} object as determined by
 * the {@link #equals(Object)} method, then the string from the pool is
 * returned. Otherwise, this {@code String} object is added to the
 * pool and a reference to this {@code String} object is returned.
 * <p>
 * It follows that for any two strings {@code s} and {@code t},
 * {@code s.intern() == t.intern()} is {@code true}
 * if and only if {@code s.equals(t)} is {@code true}.
 * <p>
 * All literal strings and string-valued constant expressions are
 * interned. String literals are defined in section 3.10.5 of the
 * <cite>The Java™ Language Specification</cite>.
 *
 * @return  a string that has the same contents as this string, but is
 *          guaranteed to be from a pool of unique strings.
 */
public native String intern();

intern()方法的作用是返回该String对象的规范表示，也就是它的双引号形式，就是字面量。字面量存在于字符串常量池中。对于任何两个字符串s和t，s.intern() == t.intern()是true当且仅当s.equals(t)是true。也就是说字符串对象的值相等其调用intern()比较始终为true,因为intern()是将值从字符串常量池中直接返回的。

String s="abc";
String s1 = "a" + new String("bc");
String s2 = new String("abc");

System.out.println(s.intern()==s1.intern() && s1.intern()==s2.intern());

对于上面的s,s1,s2，不管是如何形式，只要它们的equals()比较为true，也就是值相等，s.intern()==s1.intern() && s1.intern()==s2.intern()永远成立。

案例

一

int a=127;
int b=128;
int c=-128;

Integer ia=127;
Integer ib=128;
Integer ic=-128;

Integer iaa=a;
Integer ibb=b;

Integer newa=new Integer(a);
Integer newb=new Integer(b);

Integer valueOfA = Integer.valueOf(a);
Integer valueOfB = Integer.valueOf(ib);

System.out.println(a=ia); // true
System.out.println(a=iaa);  // true
System.out.println(a=newa); // true
System.out.println(a=valueOfA); //true

System.out.println(ia=iaa); // true
System.out.println(ia=newa); // false
System.out.println(ia=valueOfA); // true

System.out.println(iaa=newa); // false
System.out.println(iaa=valueOfA); // true

System.out.println(newa=valueOfA); //false

System.out.println(b=ib); // true
System.out.println(b=ibb); // true
System.out.println(b=newb); // true
System.out.println(b=valueOfB); // true

System.out.println(ib=ibb); // false
System.out.println(ib=newb); // false
System.out.println(ib=valueOfB);// false

System.out.println(ibb=newb); // false
System.out.println(ibb=valueOfB);// false

System.out.println(newb=valueOfB);// false

二

String s1 = "a";
String s2 = "b";
String s3 = "ab";
String s4 = "a" + "b";
String s5 = s1 + s2;
String s6 = new String(s3);
String s7 = new String("ab");
String s8 = String.valueOf(s4);
String s9 = String.valueOf(s5);

System.out.println(s1==s2);// false
System.out.println(s3==s4);// true
System.out.println(s3==s5);// false
System.out.println(s3==s6);// false
System.out.println(s3==s7);// false
System.out.println(s3==s8);// true
System.out.println(s3==s9);// false

System.out.println(s4==s5);// false
System.out.println(s4==s6);// false
System.out.println(s4==s7);// false
System.out.println(s4==s8);// true
System.out.println(s4==s9);// false

System.out.println(s5==s6);// false
System.out.println(s5==s7);// false
System.out.println(s5==s8);// false
System.out.println(s5==s9);// true

System.out.println(s6==s7);// false
System.out.println(s6==s8);// false
System.out.println(s6==s9);// false

System.out.println(s7==s8);// false
System.out.println(s7==s9);// false

System.out.println(s8==s9);// false

三

class Demo {
}
Demo demo = new Demo();
String s1=String.valueOf(demo);
String s2 = String.valueOf(demo);
String s3 = demo.toString();
String s4 = demo.toString();

System.out.println(s1==s2);// false
System.out.println(s1==s3);// false
System.out.println(s1==s4);// false
System.out.println(s3==s4);// false

四

class Test {
}
Test test1 = new Test();
Test test2 = new Test();

String s1 = "a";
String s2 = "b";
System.out.println(s1==s2); // false


String s3 = "a" + 1;
String s4 = s1 + 1;
System.out.println(s3==s4); // false


String s5 = s1 + test1;
String s6 = "a"+test1;
System.out.println(s5==s6); // false



String s7 = s1 + 1 + test1;
String s8 = s1 + "1" + test1;
System.out.println(s7==s8); // false



String s9 = test1 + 1 + s1; // Compilation error
String s10 = test1 + "1"+s1 ;
System.out.println(s9==s10);



String s11 = test1+test2; // Compilation error
String s12 = ""+test1+test2;
String s13 = test1+""+test2;
String s14 = test1 + test2 + ""; // Compilation error
System.out.println(s11==s12);
System.out.println(s12==s13); // false
System.out.println(s13==s14);

JTuring~

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java装箱拆箱及String转型分析

八大基本类型都有对应的包装类boolean-Boolean,char-Charanter,byte-Byte,short-Short,int-Integer,long-Long,float-Float,double-Double，但包装类中使用缓存机制的就只有Byte、Short、Integer、Long、Character。基本类型字面量基本类型定义的变量，其值都是字面量，大小可知，生命周期可知。由于栈的存取速度比堆快，效率高，所以字面量就直接被存放于栈中。装箱：基本类型转换为包装类型，自动装箱是
复制链接

扫一扫