web-dev-qa-db-fra.com

Comment concaténer deux chaînes en Java?

J'essaie de concaténer des chaînes en Java. Pourquoi ça ne marche pas?

public class StackOverflowTest {  
    public static void main(String args[]) {
        int theNumber = 42;
        System.out.println("Your number is " . theNumber . "!");
    }
}
javastring-concatenation
59
nn2

Vous pouvez concaténer des chaînes à l'aide de l'opérateur +:

System.out.println("Your number is " + theNumber + "!");

theNumber est implicitement converti en String "42".

86
Peter Lang

L'opérateur de concaténation en Java est +, pas .

Lisez ceci (y compris toutes les sous-sections) avant de commencer. D'essayer d'arrêter de penser à la manière php;)

Pour élargir votre vision de l'utilisation de chaînes en Java, l'opérateur + pour les chaînes est en réalité transformé (par le compilateur) en quelque chose de similaire à:

new StringBuilder().append("firstString").append("secondString").toString()
44
Bozho

Il y a deux réponses de base à cette question:

  1. [simple] Utilisez l'opérateur + (concaténation de chaînes). "your number is" + theNumber + "!" (comme indiqué ailleurs)
  2. [moins simple]: Utilisez StringBuilder (ou StringBuffer).
StringBuilder value;
value.append("your number is");
value.append(theNumber);
value.append("!");

value.toString();

Je recommande contre les opérations d'empilement comme ceci:

new StringBuilder().append("I").append("like to write").append("confusing code");

Edit: à partir de Java 5, l’opérateur de concaténation de chaînes est traduit en appels StringBuilder par le compilateur. Pour cette raison, les deux méthodes ci-dessus sont égales. 

Remarque: une marchandise non souhaitable, démontrée, démontrée.

Avertissement: l'exemple 1 ci-dessous génère plusieurs instances StringBuilder et est moins efficace que l'exemple 2 ci-dessous

Exemple 1

String Blam = one + two;
Blam += three + four;
Blam += five + six;

Exemple 2

String Blam = one + two + three + four + five + six;
14
DwB

Par défaut, vous avez 3 moyens d'injecter la valeur d'une variable dans un String pour atteindre les objectifs suivants:

1. Le moyen le plus simple

Vous pouvez simplement utiliser l'opérateur + entre un String et tout type d'objet ou de primitive. Il concaténera automatiquement les String et 

  1. Dans le cas d'un objet, la valeur de String.valueOf(obj) correspondant à String "null" si obj est null sinon la valeur de obj.toString().
  2. Dans le cas d'un type primitif, l'équivalent de String.valueOf(<primitive-type>).

Exemple avec un objet non null:

Integer theNumber = 42;
System.out.println("Your number is " + theNumber + "!");

Sortie:

Your number is 42!

Exemple avec un objet null:

Integer theNumber = null;
System.out.println("Your number is " + theNumber + "!");

Sortie:

Your number is null!

Exemple avec un type primitif:

int theNumber = 42;
System.out.println("Your number is " + theNumber + "!");

Sortie:

Your number is 42!

2. La voie explicite et potentiellement la plus efficace

Vous pouvez utiliser StringBuilder (ou StringBuffer la contrepartie obsolète thread-safe) pour créer votre String à l'aide des méthodes append. 

Exemple:

int theNumber = 42;
StringBuilder buffer = new StringBuilder()
    .append("Your number is ").append(theNumber).append('!');
System.out.println(buffer.toString()); // or simply System.out.println(buffer)

Sortie:

Your number is 42!

En coulisse, c’est ainsi que les compilateurs Java récents convertissent toutes les concaténations String effectuées avec l’opérateur +; la seule différence avec la méthode précédente est que vous avez le contrôle full. 

En effet, les compilateurs utiliseront le constructeur default pour que la capacité par défaut (16) n’ait aucune idée de la longueur finale de String à construire, ce qui signifie que si la longueur finale est supérieure à 16, les capacités seront nécessairement étendues ce qui a un prix en terme de performances. 

Donc, si vous savez à l'avance que la taille de votre String final sera supérieure à 16, il sera beaucoup plus efficace d'utiliser cette approche pour fournir une meilleure capacité initiale. Par exemple, dans notre exemple, nous créons un String dont la longueur est supérieure à 16; ainsi, pour obtenir de meilleures performances, il convient de le réécrire comme suit:

Exemple optimisé:

int theNumber = 42;
StringBuilder buffer = new StringBuilder(18)
    .append("Your number is ").append(theNumber).append('!');
System.out.println(buffer)

Sortie:

Your number is 42!

3. La manière la plus lisible

Vous pouvez utiliser les méthodes String.format(locale, format, args) ou String.format(format, args) qui reposent toutes les deux sur un Formatter pour construire votre String. Cela vous permet de spécifier le format de votre String final en utilisant des espaces réservés qui seront remplacés par la valeur des arguments. 

Exemple:

int theNumber = 42;
System.out.println(String.format("Your number is %d!", theNumber));
// Or if we need to print only we can use printf
System.out.printf("Your number is still %d with printf!%n", theNumber);

Sortie:

Your number is 42!
Your number is still 42 with printf!

L’aspect le plus intéressant de cette approche est le fait que nous avons une idée précise de ce que sera la version finale String car elle est beaucoup plus facile à lire et donc plus facile à maintenir.

7
Nicolas Filotto

La façon dont Java 8:

StringJoiner sj1 = new StringJoiner(", ");
String joined = sj1.add("one").add("two").toString();
// one, two
System.out.println(joined);


StringJoiner sj2 = new StringJoiner(", ","{", "}");
String joined2 = sj2.add("Jake").add("John").add("Carl").toString();
// {Jake, John, Carl}
System.out.println(joined2);
6
Andrejs

Vous devez être un programmeur PHP.

Utilisez un signe +.

System.out.println("Your number is " + theNumber + "!");
4
Ed Manet

Pour l'opération de concaténation exacte de deux chaînes, veuillez utiliser:

file_names = file_names.concat(file_names1);

Dans votre cas, utilisez + au lieu de .

3
Learner

Pour de meilleures performances, utilisez str1.concat(str2) où str1 et str2 sont des variables de chaîne.

3
amanraj

"+" au lieu de "."

3
Mateusz Dymczyk

Utilisez + pour la concaténation de chaînes.

"Your number is " + theNumber + "!"
3
Greg

Cela devrait marcher

public class StackOverflowTest
{  
    public static void main(String args[])
    {
        int theNumber = 42;
        System.out.println("Your number is " + theNumber + "!");
    }
}
3
bragboy

En Java, le symbole de concaténation est "+" . Si vous essayez de concaténer deux ou trois chaînes en utilisant jdbc, utilisez ceci:

String u = t1.getString();
String v = t2.getString();
String w = t3.getString();
String X = u + "" + v + "" + w;
st.setString(1, X);

Ici "" est utilisé pour l'espace seulement.

2
Surajchamp

En Java, le symbole de concaténation est "+", pas ".".

1
Uncommented

"+" pas "."

Mais soyez prudent avec la concaténation de chaînes. Voici un lien qui présente quelques idées de IBM DeveloperWorks .

1
JohnMetta
import com.google.common.base.Joiner;

String delimiter = "";
Joiner.on(delimiter).join(Lists.newArrayList("Your number is ", 47, "!"));

C’est peut-être exagéré de répondre à la question de l’opérateur, mais il est bon de connaître les opérations de jointure plus complexes. Cette question de stackoverflow figure en bonne place dans les recherches google générales dans ce domaine, donc bon à savoir.

0
Daniel Gerson

Donc, parmi les réponses pertinentes, vous avez peut-être compris pourquoi votre extrait de code ne fonctionne pas. Maintenant, je vais ajouter mes suggestions sur la façon de le faire efficacement. This article est un bon endroit où l'auteur parle de différentes manières de concaténer la chaîne et également compte tenu des résultats de la comparaison de temps entre différents résultats.

Différentes manières de concaténer des chaînes en Java

  1. En utilisant + opérateur (20 + "")
  2. En utilisant la méthode concat dans la classe String
  3. Utiliser StringBuffer
  4. En utilisant StringBuilder

Méthode 1:

C'est une façon de faire non recommandée. Pourquoi? Lorsque vous l'utilisez avec des entiers et des caractères, vous devez être explicitement très conscient de la transformation de l'entier en toString() avant d'ajouter la chaîne. Dans le cas contraire, les caractères seront traités avec les entiers ASCI et seront ajoutés en haut.

String temp = "" + 200 + 'B';

//This is translated internally into,

new StringBuilder().append( "" ).append( 200 ).append('B').toString();

Méthode 2:

Ceci est l'implémentation de la méthode concat intérieure

public String concat(String str) {
    int olen = str.length();
    if (olen == 0) {
        return this;
    }
    if (coder() == str.coder()) {
        byte[] val = this.value;
        byte[] oval = str.value;
        int len = val.length + oval.length;
        byte[] buf = Arrays.copyOf(val, len);
        System.arraycopy(oval, 0, buf, val.length, oval.length);
        return new String(buf, coder);
    }
    int len = length();
    byte[] buf = StringUTF16.newBytesFor(len + olen);
    getBytes(buf, 0, UTF16);
    str.getBytes(buf, len, UTF16);
    return new String(buf, UTF16);
}

Cela crée un nouveau tampon à chaque fois et copie l'ancien contenu dans le tampon nouvellement alloué. Donc, cela serait trop lent si vous le faites sur plus de chaînes.

Méthode 3:

Ceci est thread-safe et comparativement rapide par rapport à (1) et (2). Ceci utilise StringBuilder en interne et quand il alloue une nouvelle mémoire pour le tampon (disons que sa taille actuelle est 10), il incrémentera sa taille 2 * size + 2 (qui est 22). Ainsi, lorsque le tableau devient de plus en plus grand, cela fonctionnera vraiment mieux car il n’est pas nécessaire d’allouer la taille de la mémoire tampon à chaque fois pour chaque appel append.

    private int newCapacity(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = value.length >> coder;
        int newCapacity = (oldCapacity << 1) + 2;
        if (newCapacity - minCapacity < 0) {
            newCapacity = minCapacity;
        }
        int SAFE_BOUND = MAX_ARRAY_SIZE >> coder;
        return (newCapacity <= 0 || SAFE_BOUND - newCapacity < 0)
            ? hugeCapacity(minCapacity)
            : newCapacity;
    }

    private int hugeCapacity(int minCapacity) {
        int SAFE_BOUND = MAX_ARRAY_SIZE >> coder;
        int UNSAFE_BOUND = Integer.MAX_VALUE >> coder;
        if (UNSAFE_BOUND - minCapacity < 0) { // overflow
            throw new OutOfMemoryError();
        }
        return (minCapacity > SAFE_BOUND)
            ? minCapacity : SAFE_BOUND;
    }

Méthode 4

StringBuilder serait le plus rapide pour la concaténation String puisqu'il n'est pas sécurisé . À moins que vous ne soyez vraiment sûr que votre classe utilise cette tonne, je vous recommande fortement de ne pas l'utiliser.

En bref, utilisez StringBuffer jusqu'à ce que vous ne soyez pas sûr que votre code puisse être utilisé par plusieurs threads. Si vous êtes absolument sûr que votre classe est singleton, continuez avec StringBuilder pour la concaténation.

0
rm -rf star

Il existe plusieurs façons de le faire, mais Oracle et IBM affirment que l’utilisation de + est une mauvaise pratique, car chaque fois que vous concaténez String, vous créez des objets supplémentaires en mémoire. Elle utilisera de l'espace supplémentaire dans la machine virtuelle Java et votre programme risque de manquer d'espace ou de ralentir.

Utiliser StringBuilder ou StringBuffer est la meilleure solution. Veuillez regarder le commentaire de Nicolas Fillato ci-dessus pour un exemple lié à StringBuffer.

String first = "I eat";  String second = "all the rats."; 
System.out.println(first+second);
0
surendrapanday

Vous pouvez concaténer des chaînes à l'aide de l'opérateur +:

String a="hello ";
String b="world.";
System.out.println(a+b);

Sortie:

hello world.

C'est tout

0
user3176024

voici un exemple pour lire et concaténer 2 chaînes sans utiliser la 3ème variable:

public class Demo {
    public static void main(String args[]) throws Exception  {
        InputStreamReader r=new InputStreamReader(System.in);     
        BufferedReader br = new BufferedReader(r);
        System.out.println("enter your first string");
        String str1 = br.readLine();
        System.out.println("enter your second string");
        String str2 = br.readLine();
        System.out.println("concatenated string is:" + str1 + str2);
    }
}
0
Rejul jazz

vous pouvez utiliser stringbuffer, stringbuilder, et comme tout le monde avant moi l’a mentionné, "+". Je ne sais pas à quelle vitesse "+" est (je pense que c'est le plus rapide pour les chaînes plus courtes), mais pour plus longtemps, je pense que générateur et tampon sont à peu près égaux (le générateur est légèrement plus rapide car il n'est pas synchronisé).

0
Goodwin Lu

Première méthode: vous pouvez utiliser le signe "+" pour concaténer des chaînes, mais cela se produit toujours dans print . Une autre manière: La classe String inclut une méthode pour concaténer deux chaînes: string1.concat (string2);

0
PJ Tang