java字符串拼接过程

java字符串拼接过程

// str.java
public void static main(int args,String argv){
    String str = "hello";
   	String result = str + "World";
    System.out.println(result);
}
//输出：helloWorld

通过javap命令反编译上述代码

javap -c str

 Code:
    0: ldc           #5                  // String hello   //-> 压入栈顶
    2: astore_1
    3: new           #6                  // class java/lang/StringBuilder  //-> 生成一个StringBuilder类
    6: dup
    7: invokespecial #7                  // Method java/lang/StringBuilder."<init>":()V
   10: aload_1
   11: invokevirtual #8                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;								 //-> 将hello拼接到StringBuilder
   14: ldc           #9                  // String World
   16: invokevirtual #8                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;								 //-> 将world拼接到StringBuilder
   19: invokevirtual #10                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
       																	   //-> 调用toString()生成字符串
   22: astore_1
   23: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
   26: aload_1
   27: invokevirtual #11                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
   30: return

toString方法

    public String toString() {
        // Create a copy, don't share the array
        return new String(value, 0, count);
    }

append方法

append方法实现字符串的拼接。

1. 首先生成一个新的字符数组，并copy原字符串的值，并将私有变量value赋值为新的数组。

2. 将余下字符串copy到value中。

    public AbstractStringBuilder append(String str) {
        if (str == null)
            return appendNull();
        int len = str.length();
        ensureCapacityInternal(count + len); //扩容，并copy原字符串，并将value赋值为最新的
        str.getChars(0, len, value, count);  //copy新增字符串到value中
        count += len;
        return this;
    }

    private void ensureCapacityInternal(int minimumCapacity) {
        // overflow-conscious code
        if (minimumCapacity - value.length > 0) {
            value = Arrays.copyOf(value,
                    newCapacity(minimumCapacity));
        }
    }
	// 计算容量
    private int newCapacity(int minCapacity) {
        // overflow-conscious code
        int newCapacity = (value.length << 1) + 2;
        if (newCapacity - minCapacity < 0) {
            newCapacity = minCapacity;
        }
        return (newCapacity <= 0 || MAX_ARRAY_SIZE - newCapacity < 0)
            ? hugeCapacity(minCapacity)
            : newCapacity;
    }

	//生成一个新容量的数组，并copy原数组
    public static char[] copyOf(char[] original, int newLength) {
        char[] copy = new char[newLength];
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }
	//将余下字符copy到新字符串变量中
    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);
        }
        System.arraycopy(value, srcBegin, dst, dstBegin, srcEnd - srcBegin);
    }
	// 调用native方法
    public static native void arraycopy(Object src,  int  srcPos,
                                        Object dest, int destPos,
                                        int length);