Quelles sont les méthodes courantes de concaténation de chaînes en Java ?

Méthode 1 : + La méthode la plus courante

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

Méthode 2 : StringBuilder.append() et StringBuffer.append()

Il y a d'abord StringBuffer, puis StringBuilder. Les deux sont comme des jumeaux. Ils ont tout ce qu'ils devraient avoir. . Cependant, la plupart des méthodes du frère aîné StringBuffer sont synchronisées, donc StringBuffer est thread-safe, mais son efficacité est inférieure à celle de 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());

Méthode 3 : méthode cocat() sous la classe String

Si l'épissage. La chaîne est null , concat lancera NullPointerException. Si la chaîne concaténée est une chaîne vide (""), alors la concaténation est plus efficace. S'il y a un très grand nombre de chaînes à épisser, l'efficacité de la concatérisation diminuera, car plus il y a d'objets chaîne créés, plus la surcharge est importante.

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

Méthode 4 : La méthode join() sous la classe String

JDK1.8 fournit une nouvelle posture d'épissage de chaîne : la classe String ajoute une méthode statique join, le premier paramètre est le connecteur de chaîne

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

Méthode 5 : StringJoiner

StringJoiner est une classe du JDK1.8, package java.util, utilisée pour construire une séquence de caractères reconnectée par des délimiteurs

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

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

Méthode 6 : StringUtils.join()

Dans des projets pratiques, lorsque nous traiter les chaînes, nous utilisons souvent cette classe sous le package .org.apache.commons.lang3.StringUtils. Cette méthode est meilleure pour épisser des chaînes dans des tableaux, et il n'y a pas lieu de s'inquiéter de 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);

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!