Shame, Java string concatenation has so many poses

Aside from the “+” operator, StringBuilder’s append method is the second commonly used string concatenation position.

Append: StringBuilder appEnd: StringBuilder appEnd: StringBuilder appEnd

public StringBuilder append(String str) {
    super.append(str);
    return this;
}
Copy the code

AbstractStringBuilder > AbstractStringBuilder > AbstractStringBuilder < AbstractStringBuilder >

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;
}
Copy the code

1) Check whether the concatenated string is null, if so, treat it as string “NULL”. The appendNull method has the following source code:

private AbstractStringBuilder appendNull() {
    int c = count;
    ensureCapacityInternal(c + 4);
    final char[] value = this.value;
    value[c++] = 'n';
    value[c++] = 'u';
    value[c++] = 'l';
    value[c++] = 'l';
    count = c;
    return this;
}
Copy the code

2) Whether the length of the character array after concatenation exceeds the current value. If so, expand and copy it. The ensureCapacityInternal method is as follows:

private void ensureCapacityInternal(int minimumCapacity) {
    // overflow-conscious code
    if (minimumCapacity - value.length > 0) {
        value = Arrays.copyOf(value,
                newCapacity(minimumCapacity));
    }
}
Copy the code

3) Copy the concatenated string STR into the destination array value.

str.getChars(0, len, value, count)
Copy the code

In terms of posture alone, the concat method of The String class is like the Append of the StringBuilder class.

String chenmo = "silence "; String wanger = "wanger "; System.out.println(chenmo.concat(wanger));Copy the code

While writing this article, I suddenly had a wonderful idea. Suppose there are two lines of code:

chenmo += wanger
chenmo = chenmo.concat(wanger)
Copy the code

How different are they?

Chenmo += wanger = new StringBuilder(String.Valueof (chenmo))).appEnd (wanger).toString().

To explore the difference between the “+” operator and concat, look at the difference between the append and concat methods.

The source code for the append method has been analyzed before. Let’s take a look at the source of the concat method.

public String concat(String str) {
    int otherLen = str.length();
    if (otherLen == 0) {
        return this;
    }
    int len = value.length;
    char buf[] = Arrays.copyOf(value, len + otherLen);
    str.getChars(buf, len);
    return new String(buf, true);
}
Copy the code

1) If the length of the concatenated string is 0, return the string before concatenation.

if (otherLen == 0) {
    return this;
}
Copy the code

2) Copy the character array value of the original string into the variable buf array.

char buf[] = Arrays.copyOf(value, len + otherLen);
Copy the code

3) Copy the concatenated string STR into the character array buf and return the new string object.

str.getChars(buf, len);
return new String(buf, true);
Copy the code

Through source code analysis, we can roughly draw the following conclusions:

1) If the concatenated string is null, a NullPointerException will be thrown during concat and the “+” operator will be treated as a “NULL” string.

2) Concat is more efficient if the concatenated string is an empty string (“”). After all, you don’t need a New StringBuilder object.

3) Concat becomes less efficient if a large number of strings are concatenated, because the more string objects you create, the more overhead.

Attention!!

Weakly ask ah, still have the classmate that uses JSP? The “+” operator is not allowed to concatenate strings in EL expressions. Instead, concat is used.

${chenmo.concat('-').concat(wanger)}
Copy the code

Practical projects, when we deal with string, often use this class — org.apache.com mons. Lang3. StringUtils, the class of the join method is a kind of new posture of string concatenation.

String chenmo = "silence "; String wanger = "wanger "; StringUtils.join(chenmo, wanger);Copy the code

This method is better at concatenating strings from arrays without worrying about NullPointerExceptions.

StringUtils.join(null)            = null
StringUtils.join([])              = ""
StringUtils.join([null])          = ""
StringUtils.join(["a", "b", "c"]) = "abc"
StringUtils.join([null, "", "a"]) = "a"
Copy the code

Looking at the source code, we can see that the StringBuilder is still used internally.

public static String join(final Object[] array, String separator, final int startIndex, final int endIndex) { if (array == null) { return null; } if (separator == null) { separator = EMPTY; } final StringBuilder buf = new StringBuilder(noOfItems * 16); for (int i = startIndex; i < endIndex; i++) { if (i > startIndex) { buf.append(separator); } if (array[i] ! = null) { buf.append(array[i]); } } return buf.toString(); }Copy the code

When you read this, you will have such a feeling: I rely on (sound to be prolonged), did not expect ah did not expect, string stitching fully 6 postures ah, back home at night must try one by one.

Thank you for your reading. It is not easy to be original. If you like it, please click 👍, which will be my strongest motivation for writing. If you find this article helpful and interesting, please pay attention to my public account “Silent King ii”. Reply “666” also has 500G high quality teaching video to send (classified).