Integer和String内存分配分析

最新推荐文章于 2023-03-08 11:33:35 发布

BHBshy

最新推荐文章于 2023-03-08 11:33:35 发布

阅读量593

点赞数

分类专栏： Java基础文章标签： java jvm 堆栈字符串

本文链接：https://blog.csdn.net/qq_40395687/article/details/106211964

版权

Java基础专栏收录该内容

8 篇文章 0 订阅

订阅专栏

一.关于Integer的分析

直接上图

开始分析：

1. i == j ：false

直接看一下编译之后的字节码

可以看到，当执行Integer i= 200;的时候会执行Integer.valueOf这个方法,然后发现是创建了两个对象，所以肯定不相等

public static Integer valueOf(int i) {
    // 这里就是传说中的Integer的常量池大小是 -128 ---- 127
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        // 当在常量池的时候 就会直接使用常量池的Integer对象
        return IntegerCache.cache[i + (-IntegerCache.low)];
    // 所以说当Integer i = 200;的时候，相当于创建了一个Integer对象,所以说i j 不相等
    return new Integer(i);
}

接着看字节码，我们可以看到，ASTORE 1,ASTORE 2

ASTORE :将栈顶引用类型值保存到局部变量indexbyte中。

ALOAD 1,ALOAD 2:从局部变量indexbyte中装载引用类型值入栈。

结合上面也就是说，把前两个引用对象入栈

IF_ACMPNE：若栈顶两引用类型值不相等则跳转。

2. i == k : true

结合上面字节码指令的分析可以发现，首先GETSTATIC java/lang/System.out : Ljava/io/PrintStream;获取静态字段的值。然后把之前的 i 对象入栈，接下来

INVOKEVIRTUAL java/lang/Integer.intValue ()I：运行时方法绑定调用方法。

也就是说会把i执行intValue方法

public int intValue() {
    // 我们可以看到上面的定义就是int类型的
    return value;
}

ILOAD 3 : 从局部变量indexbyte中装载int类型值入栈。也就是把上面定义的k变量入栈

IF_ICMPNE L9 ：若栈顶两int类型值不相等则跳转。看到没有就是比较的int类型的值，而上一步已经把i变成了int类型，所以两个200相等。所以不跳转。

ICONST_1 ： 1(int)值入栈。结合上面分析，也就是说入栈1就是true，入栈0就是false

GOTO L10 ：无条件跳转到指定位置。

INVOKEVIRTUAL java/io/PrintStream.println (Z)V ：运行时方法绑定调用方法而之前得到的是true，所以直接打印true

3. j == k : true 略

4. h == l ： true

整体步骤分析：

ALOAD 4：对象h入栈，但是结合上面的分析可知，会先执行valueOf,然后会发现在常量池中。
ALOAD 5：同上
IF_ACMPNE L15：若栈顶两引用类型值不相等则跳转。因为引用的是常量池中的缓存，所以肯定是相等的。
ICONST_1：1入栈，也就是说true
GOTO L16：去这里
INVOKEVIRTUAL java/io/PrintStream.println (Z)V：执行打印

5. valueOf()方法分析

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

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++)
            // 可以看出来这里直接new了一些数组
            cache[k] = new Integer(j++);

        // range [-128, 127] must be interned (JLS7 5.1.7)
        assert IntegerCache.high >= 127;
    }

    private IntegerCache() {}
}

6. 其它存在缓存的类型

Character

public static Character valueOf(char c) {
    if (c <= 127) { // must cache
        return CharacterCache.cache[(int)c];
    }
    return new Character(c);
}

Short

public static Short valueOf(short s) {
    final int offset = 128;
    int sAsInt = s;
    if (sAsInt >= -128 && sAsInt <= 127) { // must cache
        return ShortCache.cache[sAsInt + offset];
    }
    return new Short(s);
}

Long

public static Long valueOf(long l) {
    final int offset = 128;
    if (l >= -128 && l <= 127) { // will cache
        return LongCache.cache[(int)l + offset];
    }
    return new Long(l);
}

Byte

public static Byte valueOf(byte b) {
    final int offset = 128;
    return ByteCache.cache[(int)b + offset];
}

二.关于String类型的分析

1. str1 == str2 : false

1.对象创建和内存分配

String str1 = “hello”;

对应的字节码：

L0
LINENUMBER 11 L0
LDC “hello” // 直接在元空间中分配一块内存作为hello
ASTORE 1 // 把这个引用压栈

所以说这个对象是在元空间开辟的内存所以假设内存为0x0001

String str2 = new String(“hello”);

我们先看一下源码：

public String(String original) {
    // 这个value就是一个字符数组
    this.value = original.value;
    this.hash = original.hash;
}

所以说，这个对象就是简单的一个对象，他就是在堆区中进行创建的。

接下来看一下字节码：

L1
LINENUMBER 12 L1
NEW java/lang/String //创建一个对象
DUP // 下面详细介绍
LDC “hello” // 这个会先在常量池中进行查找，如果存在就不用创建，把hello推入栈顶
INVOKESPECIAL java/lang/String. (Ljava/lang/String;)// 执行初始化方法，把常量池中的值复制过来
ASTORE 2 // 把这个字符串的地址放入局部变量表

DUP:可以看到，new字节码指令的作用是创建指定类型的对象实例、对其进行默认初始化，并且将指向该实例的一个引用压入操作数栈顶；
然后因为invokespecial会消耗掉操作数栈顶的引用作为传给构造器的“this”参数，所以如果我们希望在invokespecial调用后在操作数栈顶还维持有一个指向新建对象的引用，就得在invokespecial之前先“复制”一份引用——这就是这个dup的来源。

进一步分析：（通过局部变量表和堆栈元空间进行分析）

0 ldc #2
2 astore_1
3 new #3 <java/lang/String>
6 dup
7 ldc #2
9 invokespecial #4 <java/lang/String.>
12 astore_2
13 new #5 <java/lang/StringBuilder>
16 dup
17 invokespecial #6 <java/lang/StringBuilder.>
20 new #3 <java/lang/String>
23 dup
24 ldc #7
26 invokespecial #4 <java/lang/String.>
29 invokevirtual #8 <java/lang/StringBuilder.append>
32 new #3 <java/lang/String>
35 dup
36 ldc #9
38 invokespecial #4 <java/lang/String.>
41 invokevirtual #8 <java/lang/StringBuilder.append>
44 invokevirtual #10 <java/lang/StringBuilder.toString>
47 astore_3
48 ldc #2
50 astore 4
52 getstatic #11 <java/lang/System.out>
55 aload_1
56 aload_2
57 if_acmpne 64 (+7)
60 iconst_1
61 goto 65 (+4)
64 iconst_0
65 invokevirtual #12 <java/io/PrintStream.println>
68 getstatic #11 <java/lang/System.out>
71 aload_1
72 aload_3
73 if_acmpne 80 (+7)
76 iconst_1
77 goto 81 (+4)
80 iconst_0
81 invokevirtual #12 <java/io/PrintStream.println>
84 getstatic #11 <java/lang/System.out>
87 aload_1
88 aload 4
90 if_acmpne 97 (+7)
93 iconst_1
94 goto 98 (+4)
97 iconst_0
98 invokevirtual #12 <java/io/PrintStream.println>
101 getstatic #11 <java/lang/System.out>
104 aload_2
105 aload_3
106 if_acmpne 113 (+7)
109 iconst_1
110 goto 114 (+4)
113 iconst_0
114 invokevirtual #12 <java/io/PrintStream.println>
117 getstatic #11 <java/lang/System.out>
120 aload_3
121 aload 4
123 if_acmpne 130 (+7)
126 iconst_1
127 goto 131 (+4)
130 iconst_0
131 invokevirtual #12 <java/io/PrintStream.println>
134 return

判断的字节码分析：

L4
LINENUMBER 15 L4
GETSTATIC java/lang/System.out : Ljava/io/PrintStream;
ALOAD 1 // 从局部变量indexbyte中装载引用类型值入栈。就是把astore_1入栈
ALOAD 2 // 就是把astore_2入栈
IF_ACMPNE L5 // 若栈顶两引用类型值不相等则跳转。现在比较，看图可以清晰的看出来不一样#2与#3
ICONST_1
GOTO L6

L5
ICONST_0 // 代表false

2. str1 == str5 ：false

L7
LINENUMBER 16 L7
GETSTATIC java/lang/System.out : Ljava/io/PrintStream; // 得到System.out对象
ALOAD 1 // 从局部变量indexbyte中装载引用类型值入栈。就是把astore_1入栈
ALOAD 3 // 从局部变量indexbyte中装载引用类型值入栈。就是把astore_3入栈
IF_ACMPNE L8 // 若栈顶两引用类型值不相等则跳转。现在比较，看图可以清晰的看出来不一样#2与#4
ICONST_1
GOTO L9

L8
ICONST_0 // 代表false

INVOKEVIRTUAL java/io/PrintStream.println (Z)V //执行打印

3. str1 == str6：true

L10
LINENUMBER 17 L10
GETSTATIC java/lang/System.out : Ljava/io/PrintStream;
ALOAD 1
ALOAD 4
IF_ACMPNE L11 // 这回看一下 #2与#2 store_1 与 store_4
ICONST_1 //这回不跳转执行这个，1(int)值入栈。表示true
GOTO L12 // 无条件进行调换

L12

INVOKEVIRTUAL java/io/PrintStream.println (Z)V //打印

4. str2 == str5：false

L13
LINENUMBER 18 L13
GETSTATIC java/lang/System.out : Ljava/io/PrintStream;
ALOAD 2
ALOAD 3
IF_ACMPNE L14 //肯定不同，比较一下是 #3与#4不同
ICONST_1
GOTO L15

5. str5 == str6：false

L16
LINENUMBER 19 L16
GETSTATIC java/lang/System.out : Ljava/io/PrintStream;
ALOAD 3
ALOAD 4
IF_ACMPNE L17 //#4与#2
ICONST_1
GOTO L18

6.关于String str5 = new String(“hel”)+new String(“lo”);

直接先看一下字节码把：

L2
LINENUMBER 13 L2
NEW java/lang/StringBuilder
DUP
INVOKESPECIAL java/lang/StringBuilder. ()V
NEW java/lang/String
DUP
LDC “hel”
INVOKESPECIAL java/lang/String. (Ljava/lang/String;)V
INVOKEVIRTUAL java/lang/StringBuilder.append (Ljava/lang/String;)Ljava/lang/StringBuilder;
NEW java/lang/String
DUP
LDC “lo”
INVOKESPECIAL java/lang/String. (Ljava/lang/String;)V
INVOKEVIRTUAL java/lang/StringBuilder.append (Ljava/lang/String;)Ljava/lang/StringBuilder;
INVOKEVIRTUAL java/lang/StringBuilder.toString ()Ljava/lang/String;
ASTORE 3

流程：

首先通过new关键字在堆空间中创建StringBuilder对象
执行空参构造方法
又创建了一个String对象，在堆空间中
DUP上面已经分析了一下，这里不说了
LDC "hel"常量池中的常量值（int, float, string reference, object reference）入栈。就是常量池中有不用创建，没有就创建一个。
执行String类型的带参(String参数)构造方法
继续执行StringBuilder的append方法，一会分析源码的时候会看到，其实把String对象里的char数组赋值到StringBuilder的char[]数组中，也就是说这个时候StringBuilder.value=“hel”
继续创建一个String对象，在堆空间中
DUP上面已经分析了一下，这里不说了
LDC "lo"常量池中的常量值（int, float, string reference, object reference）入栈。就是常量池中有不用创建，没有就创建一个。
执行String类型的带参(String参数)构造方法
继续执行StringBuilder的append方法，一会分析源码的时候会看到，其实把String对象里的char数组赋值到StringBuilder的char[]数组中，也就是说这个时候StringBuilder.value=“hello”
最后一步是执行StringBuilder的toString方法，这个源码会分析，这里简单介绍，就是把StringBuilder.value复制到一个char[]数组中，然后会重新创建一个String类型的对象，并把value指向StringBuilder.value。
ASTORE 3 入栈，局部变量表中存在的是最后toString创建的String对象的引用

开始撸源码：

创建StringBuilder对象

public StringBuilder() {
    super(16);
}
// 这个是StringBuilder的父类，抽象类，就是创建一个字节数组，默认16，一会会测试一下创建一个超过16个字符 // 的
AbstractStringBuilder(int capacity) {
        value = new char[capacity];
}

创建了一个String对象，执行的是带参构造函数

public String(String original) {
    // 这个就是一个字节数组
    this.value = original.value;
    // 默认一直是0，我也不知道什么时候能变
    this.hash = original.hash;
}

执行append

public StringBuilder append(String str) {
    super.append(str);
    return this;
}
public AbstractStringBuilder append(String str) {
    if (str == null)
        return appendNull();
    int len = str.length();
    ensureCapacityInternal(count + len);
    // 这个里面挺有意思，主要就是数组的拷贝操作，下面介绍
    str.getChars(0, len, value, count);
    count += len;
    return this;
}
// 你一定要注意，这个是String类型的方法
public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) {
    if (srcBegin < 0) {
        throw new StringIndexOutOfBoundsException(srcBegin);
    }
    if (srcEnd > value.length) {
        throw new StringIndexOutOfBoundsException(srcEnd);
    }
    if (srcBegin > srcEnd) {
        throw new StringIndexOutOfBoundsException(srcEnd - srcBegin);
    }
    // 这个是静态方法
    /**
     *	参数说明：
     *	value:这个是String对象的value,也就是hel
     *	srcBegin:0
     *	dst:这个是StringBuilder的value，也就是一个16字节的空字符数组
     *	dstBegin:这个是StringBuilder对象中有效字符的长度
     *	srcEnd:就是String中字符数组的长度
     *	srcEnd - srcBegin:就是一共多少个字节
     *	功能说明：
     *	会把value中的字符从srcBegin位置开始复制到dst数组从dstBegin位置开始的地方，复制srcEnd - 	 *	srcBegin个
     *
     */
    System.arraycopy(value, srcBegin, dst, dstBegin位置开始的地方, srcEnd - srcBegin);
}

4.执行toString

public String toString() {
    // Create a copy, don't share the array
    // 可以看到分析的正确，就是重新创建一个String对象
    // 分析一下这个构造方法
    return new String(value, 0, count);
}
public String(char value[], int offset, int count) {
    if (offset < 0) {
        throw new StringIndexOutOfBoundsException(offset);
    }
    if (count <= 0) {
        if (count < 0) {
            throw new StringIndexOutOfBoundsException(count);
        }
        if (offset <= value.length) {
            this.value = "".value;
            return;
        }
    }
    // Note: offset or count might be near -1>>>1.
    if (offset > value.length - count) {
        throw new StringIndexOutOfBoundsException(offset + count);
    }
    // 主要是这里,下面有源码，很简单就是之前分析的哪个native方法的封装
    this.value = Arrays.copyOfRange(value, offset, offset+count);
}
public static char[] copyOfRange(char[] original, int from, int to) {
    int newLength = to - from;
    if (newLength < 0)
        throw new IllegalArgumentException(from + " > " + to);
    char[] copy = new char[newLength];
    System.arraycopy(original, from, copy, 0,
                     Math.min(original.length - from, newLength));
    return copy;
}

BHBshy

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Integer和String内存分配分析

一.关于Integer的分析直接上图开始分析：1. i == j ：false直接看一下编译之后的字节码可以看到，当执行Integer i= 200;的时候会执行Integer.valueOf这个方法,然后发现是创建了两个对象，所以肯定不相等public static Integer valueOf(int i) { // 这里就是传说中的Integer的常量池大小是 -128 ---- 127 if (i >= IntegerCache.low &&
复制链接

扫一扫