Nous concaténons souvent des chaînes pendant le développement. Par exemple, nous avons maintenant un tableau:

private static final String[] names = {"我", "大意了啊", "年轻人", "不讲武德", "来骗"};

Nous devons extraire les éléments, puis les épisser en une chaîne entière, l'effet cible est le suivant:

我, 大意了啊, 年轻人, 不讲武德, 来骗

épissage "+"

Donc qu'est ce que tu vas faire:

@Test
public void test() {
    String str = names[0] +","+ names[1] +","+ names[2] +","+ names[3] +","+ names[4];
    System.out.println(str);
}

La plupart des gens le feront, mais nous avons constaté qu'il y avait trop de "," et "+" dedans. On a l'impression que l'épissage n'est pas très flexible.

Épissage de StringBuilder

Nous avons donc une nouvelle approche, en utilisant StringBuilder pour épisser:

StringBuilder sb = new StringBuilder();
sb.append(names[0]);
sb.append(",");
sb.append(names[1]);
sb.append(",");
sb.append(names[2]);
sb.append(",");
sb.append(names[3]);
sb.append(",");
sb.append(names[4]);
System.out.println(sb.toString());

Bien que cela sauve le "+", il y en a encore beaucoup de "," et le code n'est pas assez élégant. Dans cet esprit, vous pouvez utiliser une forboucle:

StringBuilder sb2 = new StringBuilder();
int length = names.length;
for (int i = 0; i < length; i++) {
    sb2.append(names[i]);
    if (i != length - 1) {
        sb2.append(",");
    }
}

Cela a l'air bien, mais cela reste très compliqué et vous devez envisager le traitement à la fin.

épissage concat ()

L'épissage simple peut également utiliser des concat()méthodes:

public void test() {
    String str = "Lvshen";
    String concat = str.concat(",").concat("Hello");
    System.out.println(concat);
}
//输出
//Lvshen,Hello

Épissage String.join ()

Ayons une méthode en une étape:

public void test() {
    String str = String.join(",", names[0], names[1], names[2], names[3], names[4]);
    System.out.println(str);
}

De cette manière, nous pouvons également obtenir des résultats.

我,大意了啊,年轻人,不讲武德,来骗

String.join()C'est une méthode derrière Java 8, simple et facile à utiliser. Le code source est le suivant:

Avez-vous découvert, il est utilisé à l'intérieur pour StringJoinerréaliser des épissures.

Maintenant, nous avons une telle exigence que le résultat de l'épissage est:

[我,大意了啊,年轻人,不讲武德,来骗]

Ajoutez "[]" sur la base du précédent, si nous utilisons directement "+" ou StringBuilder. La mise en œuvre est encore très lourde, bien sûr, il n'est pas mal d'extraire la lourde mise en œuvre dans une méthode pour faciliter la réutilisation future.

En fait, la plupart des roues d'épissure ont été implémentées, jetons un coup d'œil à quelques API couramment utilisées.

Coutures StringJoiner

Les éléments mentionnés ci-dessus StringJoinerpeuvent répondre à cette exigence:

public void test() {
    StringJoiner stringJoiner = new StringJoiner(",", "[", "]");
    for (String name : names) {
        stringJoiner.add(name);
    }
    System.out.println(stringJoiner.toString());
}

new StringJoiner(",", "[", "]");Représente séparé par ",", le préfixe est "[" et le suffixe est "]". Les résultats sont les suivants:

[我,大意了啊,年轻人,不讲武德,来骗]

StringJoinerLa couche inférieure est toujours utilisée StringBuilder.

La méthode ci-dessus semble toujours très gênante, je veux enregistrer la boucle for. Ensuite, nous devons adopter d'autres méthodes.

Collectors.joining couture

Nous pouvons utiliser Collectors.joiningpour épisser, qui est également une fonctionnalité de Java8:

Stream<String> stream1 = Stream.of(names);
// 拼接成 [x, y, z] 形式
String result1 = stream1.collect(Collectors.joining(", ", "[", "]"));

Peut également obtenir l'effet:

[我,大意了啊,年轻人,不讲武德,来骗]

Bien sûr, cela peut également être fait en une seule étape:

 Stream.of(names).collect(Collectors.joining(", ", "[", "]"));

Par rapport au précédent String.join:

 String str = String.join(",", names[0], names[1], names[2], names[3], names[4]);

Il n'est pas nécessaire d'obtenir les éléments du tableau un par un, ce qui est beaucoup plus pratique.

Joiner.on couture

En plus d'utiliser la méthode d'épissage Java8, nous pouvons également utiliser le célèbre framework Google: Guava. Tout d'abord, nous devons introduire les dépendances Maven:

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>18.0</version>
</dependency>

Maintenant, pour écrire un exemple d'utilisation:

Joiner joiner = Joiner.on(",").skipNulls();
String join = joiner.join("公众号", null, "Lvshen的技术小屋");
System.out.println("join:" + join);

Nous utilisons Joiner.on()cette méthode pour filtrer les éléments dont la valeur est nulle. Le résultat de l'exécution du code ci-dessus est:

join:公众号,Lvshen的技术小屋

Bien sûr, il y a parfois des exigences anormales, et la valeur de null n'est pas filtrée, et l'élément nul doit être remplacé par d'autres valeurs, telles que la chaîne vide "".

Joiner joiner1 = Joiner.on(",").useForNull("");
String content1 = joiner1.join("公众号", null, "Lvshen的技术小屋", "欢迎订阅");
System.out.println("content1:" + content1);

useForNull()Il est utilisé pour remplacer la valeur nulle. Exécutez comme suit:

content1:公众号,,Lvshen的技术小屋,欢迎订阅

Pour résumer

Dans le développement normal, il ne faut pas utiliser le « + » ou couture StringBuilder, mosaïque complexe que nous pouvons utiliser StringJoiner, Collectors.joining, Joiner.onet d' autres méthodes. Ils utilisent tous StringBuilder en bas. Si vous prévoyez d'utiliser StringBuilder pour concaténer des chaînes, vous pouvez envisager ces méthodes.

Recommandé dans le passé

Scannez le code QR pour devenir plus excitant. Ou recherchez Lvshen_9 sur WeChat , vous pouvez répondre pour obtenir des informations en arrière-plan

回复"java" 获取java电子书；

回复"python"获取python电子书；

回复"算法"获取算法电子书；

回复"大数据"获取大数据电子书；

回复"spring"获取SpringBoot的学习视频。

回复"面试"获取一线大厂面试资料

回复"进阶之路"获取Java进阶之路的思维导图

回复"手册"获取阿里巴巴Java开发手册(嵩山终极版)

回复"总结"获取Java后端面试经验总结PDF版

回复"Redis"获取Redis命令手册，和Redis专项面试习题（PDF）

回复"并发导图"获取Java并发编程思维导图（xmind终极版）

Un autre: cliquez sur [ Mes avantages ] pour avoir plus de surprises.

Vous utilisez toujours StringBuilder pour l'épissage de chaînes? Alors tu es OUT