Apakah kaedah penyambungan rentetan biasa di Jawa?

Kaedah satu: + Kaedah yang paling biasa

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

Kaedah kedua: StringBuilder.append() dan StringBuffer.append()

Terdapat StringBuffer dahulu dan kemudian StringBuilder Si kembar mempunyai segala-galanya yang sepatutnya mereka miliki, tetapi abang sulung StringBuffer mempunyai kebanyakan kaedahnya diubah suai dengan disegerakkan, jadi StringBuffer selamat untuk benang, tetapi kecekapannya lebih rendah daripada 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());

Kaedah 3: Kelas String The cocat () kaedah

Jika rentetan bercantum adalah nol, concat akan membuang NullPointerException. Jika rentetan bercantum ialah rentetan kosong (""), maka concat adalah lebih cekap. Sekiranya terdapat banyak rentetan yang perlu disambung, kecekapan concat akan berkurangan, kerana lebih banyak objek rentetan dicipta, lebih besar overhed.

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

Kaedah 4: Kaedah Join() di bawah kelas String

JDK1.8 menyediakan postur penyambung rentetan baharu: Kelas rentetan menambah gabungan kaedah statik, yang pertama Parameter ialah penyambung rentetan

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

Kaedah 5: StringJoiner

StringJoiner ialah kelas dalam JDK1.8, pakej java.util, digunakan untuk membina jujukan aksara yang disambungkan semula oleh pembatas

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

Kod sumber StringJoiner

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());
    }
}

Kaedah 6: StringUtils.join()

Dalam projek sebenar, apabila kami memproses rentetan, kami sering menggunakan class.org ini di bawah pakej apache.commons.lang3.StringUtils, ini kaedah adalah lebih baik untuk menyambung rentetan dalam tatasusunan, dan tidak perlu risau tentang NullPointerException.

rreeee

Atas ialah kandungan terperinci Apakah kaedah penyambungan rentetan biasa di Jawa?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!