Question Comment puis-je convertir d'int en String?


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

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

Je ne suis pas familier avec Java. Est-ce une pratique habituelle ou quelque chose ne va pas, comme je suppose?


667
2017-11-05 11:11


origine


Réponses:


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

La concaténation fonctionnera, mais elle est non conventionnelle et pourrait être une mauvaise odeur car elle suggère que l'auteur ne connaît pas les deux méthodes ci-dessus (que ne pourraient-elles pas savoir d'autre?).

Java a un support spécial pour l'opérateur + lorsqu'il est utilisé avec des chaînes (voir La documentation) qui traduit le code que vous avez posté:

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

à la compilation. C'est un peu moins efficace (sb.append() finit par appeler Integer.getChars(), lequel est quoi Integer.toString() aurait fait de toute façon), mais cela fonctionne.

Pour répondre au commentaire de Grodriguez: ** Non, le compilateur ne pas optimiser 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

Initialiser le StringBuilder:

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

Ajoutez la chaîne vide:

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

Ajouter l'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 le travail en cours pour changer ce comportement, ciblé pour JDK 9.


884
2017-11-05 11:22



C'est acceptable, mais je n'ai jamais rien écrit de tel. Je préférerais ceci:

String strI = Integer.toString(i);

236
2017-11-05 11:14



Ce n'est pas un bon moyen.

Lorsque vous effectuez une conversion de int en chaîne, ceci doit être utilisé:

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

108
2017-11-05 11:13



Ce n'est pas seulement l'optimisation1. Je n'aime pas

"" + i

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

Je ne veux pas ajouter un entier à une chaîne (vide). Je veux convertir un entier en chaîne:

Integer.toString(i)

Ou, pas mon préféré, mais toujours mieux que la concaténation, obtenir une représentation sous forme de 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 également un point pour ne pas utiliser la concaténation.

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


56
2017-11-05 13:43



Beaucoup de cours d'introduction à l'université semblent enseigner ce style, pour deux raisons (selon mon expérience):

  • Il ne nécessite pas de compréhension des classes ou des méthodes. Habituellement, cela est enseigné avant que le mot "classe" ne soit mentionné - ni même les appels de méthode. Donc, en utilisant quelque chose comme String.valueOf(…) embrouillerait les étudiants.

  • C'est une illustration de "surcharge d'opérateur" - en fait, cela nous a été vendu comme la opérateur surchargé idiomatique (petite merveille ici, puisque Java n'autorise pas la surcharge de l'opérateur personnalisé).

Donc, il peut être né de la nécessité didactique (bien que je dirais que c'est juste un mauvais enseignement) ou être utilisé pour illustrer un principe qui est par ailleurs assez difficile à démontrer en Java.


22
2017-11-05 14:08



L'expression

"" + i

mène à conversion de chaîne de i lors de l'exécution. Le type global de l'expression est String. i est d'abord converti en Integer objet (new Integer(i)), puis String.valueOf(Object obj) est appelé. Donc c'est équivalent à

"" + String.valueOf(new Integer(i));

De toute évidence, cela est légèrement moins performant que de simplement appeler String.valueOf(new Integer(i))ce qui produira le même résultat.

L'avantage de ""+i est-ce que la dactylographie est plus facile / plus rapide et certaines personnes pourraient penser que c'est plus facile à lire. Ce n'est pas un odeur de code car cela n'indique aucun problème plus profond.

(Référence: JLS 15.8.1)


16
2017-11-05 11:38



Personnellement, je ne vois rien de mal dans ce code.

C'est très utile lorsque vous voulez enregistrer une valeur int, et l'enregistreur accepte simplement une chaîne. Je dirais qu'une telle conversion est pratique quand vous devez appeler une méthode acceptant une chaîne, mais vous avez une valeur int.

Quant au choix entre Integer.toString ou String.valueOf, tout est une question de goût.
... Et à l'interne, le String.valueOf appelle le Integer.toString méthode en passant. :)


14
2017-11-05 11:35



L'autre moyen que je connais est de Integer classe:

Integer.toString(int n);
Integer.toString(int n, int radix);

Un exemple concret (bien que je ne pense pas que vous en ayez besoin):

String five = Integer.toString(5); // returns "5"

Cela fonctionne aussi pour d'autres types primitifs, par exemple Double.toString.

Voir ici pour plus de détails.


12
2017-11-05 11:14



Cette technique a été enseignée dans un cours d'introduction au Java de premier cycle, il y a une dizaine d'années. Cependant, je devrais noter que, IIRC, nous n'avions pas encore atteint les méthodes de classe String et Integer.

La technique est simple et rapide à taper. Si tout ce que je fais est d'imprimer quelque chose, je vais l'utiliser (par exemple, System.out.println("" + i);. Cependant, je pense que ce n'est pas la meilleure façon de faire une conversion, car il faut une seconde de réflexion pour comprendre ce qui se passe quand on l'utilise de cette façon. En outre, si la performance est une préoccupation, elle semble plus lente (plus bas, ainsi que dans d'autres réponses).

Personnellement, je préfère Integer.toString (), car il est évident que ce qui se passe. String.valueOf () serait mon deuxième choix, car il semble être déroutant (voir les commentaires après la réponse de Darioo).

Juste pour les sourires :) J'ai écrit des classes pour tester les trois techniques: "" + i, Integer.toString, et String.ValueOf. Chaque test vient de convertir les nombres de 1 à 10000 en Strings. J'ai ensuite couru chacun à travers le Linux temps commande cinq fois. Integer.toString () était légèrement plus rapide que String.valueOf () une fois, ils étaient liés trois fois, et String.valueOf () était plus rapide une fois; Cependant, la différence n'a jamais été supérieure à quelques millisecondes.

La technique "+" était plus lente que les deux sur tous les tests sauf un, quand il était 1 milliseconde plus rapide que Integer.toString () et 1 milliseconde plus lent que String.valueOf () (évidemment sur le même test où String.valueOf () était plus rapide que Integer.toString ()). Alors qu'il n'était généralement que quelques millisecondes plus lent, il y avait un test où il était environ 50 millisecondes plus lent. YMMV.


9
2017-11-05 13:59



Il existe plusieurs façons de convertir en chaînes:

StringBuilder string = string.append(i).toString();
String string = String.valueOf(i);
String string = Integer.toString(i);

6
2017-08-14 11:29



Cela dépend de la façon dont vous voulez utiliser votre chaîne. Cela peut aider:

String total =  Integer.toString(123) + Double.toString(456.789);

6
2017-07-09 16:44