Comment convertir un int en String ?

Question

Je travaille sur un projet où toutes les conversions de int à String se font comme ceci :

int i = 5;
String strI = "" + i;

Je ne suis pas familier avec Java.

Est-ce une pratique habituelle ou y a-t-il un problème, comme je le suppose ?

Answer 1

Les moyens normaux seraient Integer.toString(i) o String.valueOf(i) .

La concaténation fonctionnera, mais elle n'est pas conventionnelle et pourrait être un mauvais signe car elle suggère que l'auteur ne connaît pas les deux méthodes ci-dessus (qu'est-ce qu'il pourrait ne pas savoir d'autre ?).

Java dispose d'une prise en charge spéciale de l'opérateur + lorsqu'il est utilisé avec des chaînes de caractères (cf. la documentation ) qui traduit le code que vous avez posté en :

StringBuilder sb = new StringBuilder();
sb.append("");
sb.append(i);
String strI = sb.toString();

au moment de la compilation. C'est légèrement moins efficace ( sb.append() finit par appeler Integer.getChars() qui est ce que Integer.toString() aurait fait de toute façon), mais ça marche.

Pour répondre au commentaire de Grodriguez : ** Non, le compilateur n'a pas optimise la chaîne vide dans ce cas - regardez :

simon@lucifer:~$ cat TestClass.java
public class TestClass {
  public static void main(String[] args) {
    int i = 5;
    String strI = "" + i;
  }
}
simon@lucifer:~$ javac TestClass.java && javap -c TestClass
Compiled from "TestClass.java"
public class TestClass extends java.lang.Object{
public TestClass();
  Code:
   0:    aload_0
   1:    invokespecial    #1; //Method java/lang/Object."<init>":()V
   4:    return

public static void main(java.lang.String[]);
  Code:
   0:    iconst_5
   1:    istore_1

Initialise le StringBuilder :

   2:    new    #2; //class java/lang/StringBuilder
   5:    dup
   6:    invokespecial    #3; //Method java/lang/StringBuilder."<init>":()V

Ajoute la chaîne vide :

   9:    ldc    #4; //String
   11:    invokevirtual    #5; //Method java/lang/StringBuilder.append:
(Ljava/lang/String;)Ljava/lang/StringBuilder;

Ajoutez le nombre entier :

   14:    iload_1
   15:    invokevirtual    #6; //Method java/lang/StringBuilder.append:
(I)Ljava/lang/StringBuilder;

Extraire la chaîne finale :

   18:    invokevirtual    #7; //Method java/lang/StringBuilder.toString:
()Ljava/lang/String;
   21:    astore_2
   22:    return
}

Il y a une proposition et un travail en cours pour changer ce comportement, ciblé pour le JDK 9.

Answer 2

C'est acceptable, mais je n'ai jamais rien écrit de tel. Je préfère ça :

String strI = Integer.toString(i);

Answer 3

Ce n'est pas un bon moyen.

Lors de la conversion de int en string, il faut l'utiliser :

int i = 5;
String strI = String.valueOf(i);

Answer 4

Ce n'est pas seulement l'optimisation 1 . Je n'aime pas

"" + i

parce qu'il n'exprime pas ce que je veux vraiment faire. 2 .

Je ne veux pas ajouter un nombre entier à une chaîne (vide). Je veux convertir un nombre entier en chaîne de caractères :

Integer.toString(i)

Ou, ce qui n'est pas ma préférence, mais c'est toujours mieux que la concaténation, obtenir une représentation en chaîne d'un objet (entier) :

String.valueOf(i)

1. Pour le code qui est appelé très souvent, comme dans les boucles, l'optimisation est certainement aussi un point pour ne pas utiliser la concaténation .

2. ce n'est pas valable pour l'utilisation de réel concaténation comme dans System.out.println("Index: " + i); ou String id = "ID" + i;

Answer 5

De nombreux cours d'introduction à l'université semblent enseigner ce style, pour deux raisons (d'après mon expérience) :

• Il n'est pas nécessaire de comprendre les classes ou les méthodes. En général, elle est enseignée bien avant que le mot "classe" ne soit mentionné, ni même les appels de méthode. Ainsi, en utilisant quelque chose comme String.valueOf(…) rendrait les étudiants confus.

• Il s'agit d'une illustration de la "surcharge de l'opérateur" - en fait, on nous l'a vendu en tant que le site opérateur surchargé idiomatique (petite merveille ici, puisque Java ne permet pas la surcharge d'opérateurs personnalisés).

Il peut donc soit être né d'une nécessité didactique (même si je dirais qu'il s'agit simplement d'un mauvais enseignement), soit être utilisé pour illustrer un principe qui est autrement assez difficile à démontrer en Java.