Was sind die gängigen String-Splicing-Methoden in Java?

Methode 1: + Der gebräuchlichste Weg

        String aa = "今天";
        String bb = "明天";
        System.out.println(aa+bb);

Methode 2: StringBuilder.append() und StringBuffer.append()

Es gibt zuerst StringBuffer und dann StringBuilder , Die beiden sind wie Zwillinge, sie haben alles, was sie haben sollten, außer dass die meisten Methoden des älteren Bruders StringBuffer synchronisiert sind, sodass StringBuffer threadsicher ist, aber seine Effizienz geringer ist als die von StringBuilder

        String aa = "今天";
        String bb = "明天";
        StringBuilder sber = new StringBuilder();
        StringBuffer sbf = new StringBuffer();
        sber.append(aa).append(bb);
        System.out.println(sber.toString());
        sbf.append(aa).append(bb);
        System.out.println(sbf.toString());

#🎜🎜 #Methode 3: cocat()-Methode unter der String-Klasse

Wenn die verkettete Zeichenfolge null ist, löst concat eine NullPointerException aus. Wenn die verkettete Zeichenfolge eine leere Zeichenfolge ("") ist, ist concat effizienter. Wenn sehr viele Strings gespleißt werden müssen, nimmt die Effizienz von concat ab, denn je mehr String-Objekte erstellt werden, desto größer ist der Overhead.

        String aa = "今天";
        String bb = "明天";
        String concat = aa.concat(bb);
        System.out.println(concat);

Methode 4: Die join()-Methode unter der String-Klasse

JDK1.8 bietet eine neue String-Spleißhaltung: Die String-Klasse fügt eine statische Methode hinzu, die erste Parameter ist der String-Joiner

		String aa = "今天";
        String bb = "明天";
        String join = String.join("-", aa, bb);
        System.out.println(join);

Methode 5: StringJoiner

StringJoiner ist eine Klasse in JDK1.8, java.util-Paket, die zum Erstellen einer durch Trennzeichen wieder verbundenen Zeichenfolge verwendet wird# 🎜🎜#

		String aa = "今天";
        String bb = "明天";
        StringJoiner sj = new StringJoiner(":", "[", "]");
        sj.add(aa).add(bb);
        System.out.println(sj.toString());

StringJoiner-Quellcode

package java.util;

public final class StringJoiner {
    private final String prefix;//前缀
    private final String delimiter;//间隔符
    private final String suffix;//后缀
    private StringBuilder value;//值

    private String emptyValue;//空值

    public StringJoiner(CharSequence delimiter) {
        this(delimiter, "", "");//默认前缀和后缀为"",重载调用
    }

    public StringJoiner(CharSequence delimiter,
                        CharSequence prefix,
                        CharSequence suffix) {
        //间隔符，前缀和后缀判断是否为null，null将抛出异常
        Objects.requireNonNull(prefix, "The prefix must not be null");
        Objects.requireNonNull(delimiter, "The delimiter must not be null");
        Objects.requireNonNull(suffix, "The suffix must not be null"); 
        // 成员变量赋值
        this.prefix = prefix.toString();
        this.delimiter = delimiter.toString();
        this.suffix = suffix.toString();
        this.emptyValue = this.prefix + this.suffix;//空值被设置为只有前后缀
    }
	//设置空值，检查是否为null
    public StringJoiner setEmptyValue(CharSequence emptyValue) {
        this.emptyValue = Objects.requireNonNull(emptyValue,
            "The empty value must not be null").toString();
        return this;
    }

    @Override
    public String toString() {
        if (value == null) {
            return emptyValue;//没有值将返回空值或者后续设置的空值
        } else {
            if (suffix.equals("")) {
                return value.toString();//后缀为""直接返回字符串，不用添加
            } else {
	            //后缀不为""，添加后缀，然后直接返回字符串，修改长度
                int initialLength = value.length();
                String result = value.append(suffix).toString();
                // reset value to pre-append initialLength
                value.setLength(initialLength);
                return result;
            }
        }
    }
    初始化，先添加前缀，有了之后每次先添加间隔符，StringBuilder后续append字符串
    public StringJoiner add(CharSequence newElement) {
        prepareBuilder().append(newElement);
        return this;
    }
	//合并StringJoiner，注意后面StringJoiner 的前缀就不要了，后面的appen进来
    public StringJoiner merge(StringJoiner other) {
        Objects.requireNonNull(other);
        if (other.value != null) {
            final int length = other.value.length();
            // lock the length so that we can seize the data to be appended
            // before initiate copying to avoid interference, especially when
            // merge 'this'
            StringBuilder builder = prepareBuilder();
            builder.append(other.value, other.prefix.length(), length);
        }
        return this;
    }
	//初始化，先添加前缀，有了之后每次先添加间隔符
    private StringBuilder prepareBuilder() {
        if (value != null) {
            value.append(delimiter);
        } else {
            value = new StringBuilder().append(prefix);
        }
        return value;
    }

    public int length() {
        // Remember that we never actually append the suffix unless we return
        // the full (present) value or some sub-string or length of it, so that
        // we can add on more if we need to.
        //不忘添加后缀的长度
        return (value != null ? value.length() + suffix.length() :
                emptyValue.length());
    }
}

Methode 6: StringUtils.join()

In praktischen Projekten behandeln wir diese Klasse Wird häufig im Paket .org.apache.commons.lang3.StringUtils verwendet. Diese Methode eignet sich besser zum Zusammenfügen von Zeichenfolgen in Arrays, und es besteht kein Grund zur Sorge über NullPointerException.

		String aa = "今天";
        String bb = "明天";
        String ids[] = {"1","2","3"};
        System.out.println(StringUtils.join(aa,bb,"-","124"));
        String join1 = StringUtils.join(ids,",");
        System.out.println(join1);

Das obige ist der detaillierte Inhalt vonWas sind die gängigen String-Splicing-Methoden in Java?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!