Comment convertir de int en chaîne?

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

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

Je ne connais pas Java.

Est-ce une pratique habituelle ou quelque chose ne va pas, comme je suppose?

Les voies normales seraient Integer.toString(i)ou String.valueOf(i).

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

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 publié en:

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

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

Pour répondre à un commentaire de Grodriguez: ** Non, le compilateur n'optimiser la chaîne vide dans ce cas - regard:

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

Initialisez 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;

Ajoutez l'entier:

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

Extrayez 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 des travaux en cours pour changer ce comportement, ciblés pour JDK 9.

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

String strI = Integer.toString(i);

Ce n'est pas un bon moyen.

Lors de la conversion de int en chaîne, cela doit être utilisé:

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

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

"" + i

car il n'exprime pas ce que je veux vraiment faire ² .

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, obtenez 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 d' une concaténation réelle comme dans System.out.println("Index: " + i); ou String id = "ID" + i;}

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

• Cela ne nécessite pas de compréhension des classes ou des méthodes. Habituellement, cela est enseigné bien avant que le mot «classe» ne soit jamais mentionné - ni même les appels de méthode. Donc, utiliser quelque chose comme String.valueOf(…)cela dérouterait les étudiants.

• Il est une illustration de « surcharge opérateur » - en fait, cela nous a été vendu comme l' opérateur surchargée idiomatiques (petite merveille ici, puisque Java ne permet pas la surcharge d'opérateur personnalisé).

Il peut donc être né d'une nécessité didactique (bien que je dirais que ce n'est qu'un mauvais enseignement) ou être utilisé pour illustrer un principe qui est par ailleurs assez difficile à démontrer en Java.

L'expression

"" + i

conduit à la conversion de chaînei lors de l'exécution. Le type global de l'expression est String. iest d'abord converti en Integerobjet ( new Integer(i)), puis String.valueOf(Object obj)est appelé. C'est donc équivalent à

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

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

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

(Référence: JLS 15.8.1 )

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

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

Quant au choix entre Integer.toStringou String.valueOf, tout est affaire de goût.
... Et en interne, les String.valueOfappels la Integer.toStringméthode d'ailleurs. :)

L'autre façon dont je suis au courant vient de la Integerclasse:

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"

Il fonctionne également pour d'autres types primitifs, par exemple Double.toString.

Voir ici pour plus de détails.

Cette technique a été enseignée dans un cours d'introduction à Java de premier cycle que j'ai suivi il y a plus de dix ans. Cependant, je dois noter que, IIRC, nous n'étions pas encore arrivés aux méthodes de classe String et Integer.

La technique est simple et rapide à taper. Si tout ce que je fais, c'est 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 il est utilisé. De plus, si les performances sont un problème, elles semblent plus lentes (plus ci-dessous, ainsi que dans d'autres réponses).

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

Juste pour le sourire :) J'ai écrit des cours pour tester les trois techniques: "" + i, Integer.toString et String.ValueOf. Chaque test vient de convertir les ints de 1 à 10000 en chaînes. J'ai ensuite exécuté cinq fois la commande Linux time . 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 "" + i était plus lente que les deux sur tous les tests sauf un, alors qu'elle était 1 milliseconde plus rapide que Integer.toString () et 1 milliseconde plus lente que String.valueOf () (évidemment sur le même test où String.valueOf () était plus rapide que Integer.toString ()). Bien qu'il ne soit généralement que de quelques millisecondes plus lent, il y avait un test où il était environ 50 millisecondes plus lent. YMMV .

Il existe différentes façons de convertir en chaînes:

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

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

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

Idem pour SimonJ. Je n'aime vraiment pas l 'idiome "" + i. Si vous dites String.valueOf (i), Java convertit l'entier en une chaîne et renvoie le résultat. Si vous dites "" + i, Java crée un objet StringBuilder, y ajoute une chaîne vide, convertit l'entier en chaîne, ajoute ceci au StringBuilder, puis convertit le StringBuilder en chaîne. C'est beaucoup d'étapes supplémentaires. Je suppose que si vous le faites une fois dans un grand programme, ce n'est pas grave. Mais si vous faites cela tout le temps, vous faites faire beaucoup de travail à l'ordinateur et créez tous ces objets supplémentaires qui doivent ensuite être nettoyés. Je ne veux pas devenir fanatique de la micro-optimisation, mais je ne veux pas non plus être inutile.

String strI = String.valueOf(i);

String string = Integer.toString(i);

Les deux façons sont correctes.

Il existe plusieurs façons de convertir un entier en chaîne:

1)

Integer.toString(10);

2)

 String hundred = String.valueOf(100); // You can pass an int constant
 int ten = 10;
 String ten = String.valueOf(ten)

3)

String thousand = "" + 1000; // String concatenation

4)

String million = String.format("%d", 1000000)

Il existe trois façons de convertir en chaînes

1. String string = "" + i;
2. String string = String.valueOf(i);
3. String string = Integer.toString(i);

L'utilisation de "" + i est le moyen le plus court et le plus simple de convertir un nombre en chaîne. Ce n'est pas le plus efficace, mais c'est l'IMHO le plus clair et c'est généralement plus important. Plus le code est simple, moins vous risquez de faire une erreur.

Personnellement, je pense que "" + je ressemble à l'affiche de la question d'origine "malodorante". J'ai utilisé beaucoup de langages OO en plus de Java. Si cette syntaxe était destinée à être appropriée, Java interpréterait simplement le i seul sans avoir besoin que le "" comme vous le souhaitez soit converti en chaîne et le fasse puisque le type de destination est sans ambiguïté et qu'une seule valeur serait fournie à droite . L'autre semble être une «astuce» pour tromper le compilateur, mauvais mojo lorsque différentes versions de Javac faites par d'autres fabricants ou d'autres plates-formes sont envisagées si le code doit jamais être porté. Heck for my money, il devrait aimer de nombreux autres OOL prendre un Typecast: (String) i. winks

Étant donné ma façon d'apprendre et pour faciliter la compréhension d'une telle construction lors de la lecture rapide du code des autres, je vote pour la méthode Integer.toString (i). Oublier un ns ou deux dans la façon dont Java implémente les choses en arrière-plan par rapport à String.valueOf (i) cette méthode me semble juste et dit exactement ce qui se passe: j'ai et Integer et je souhaite qu'il soit converti en String.

Un bon point soulevé à quelques reprises est peut-être que l'utilisation de StringBuilder à l'avant est une bonne réponse à la construction de chaînes mélangées de texte et d'entiers ou d'autres objets, car c'est ce qui sera utilisé en arrière-plan de toute façon, non?

Juste mes deux cents jetés dans le minou déjà bien payé des réponses à la question du Mans ... sourires

MODIFIER MA RÉPONSE APRÈS UNE RÉFLEXION:

Ok, Ok, je réfléchissais un peu plus à cela et String.valueOf (i) est également parfaitement bon, ainsi il est dit: je veux une chaîne qui représente la valeur d'un entier. lol, l'anglais est de loin plus difficile à analyser que Java! Mais, je laisse le reste de ma réponse / commentaire ... On m'a toujours appris à utiliser le plus bas niveau d'une chaîne de méthode / fonction si possible et conserve toujours la lisibilité, donc si String.valueOf appelle Integer.toString, alors pourquoi utiliser une orange entière si tu veux juste le peler de toute façon, Hmmm?

Pour clarifier mon commentaire sur StringBuilder, je construis beaucoup de chaînes avec des combos de texte et d'intels principalement littéraux et ils finissent par être longs et laids avec des appels aux routines mentionnées ci-dessus intégrées entre les +, il me semble si celles-ci deviennent Les objets SB de toute façon et la méthode append a des surcharges, il pourrait être plus propre d'aller de l'avant et de l'utiliser ... Donc je suppose que je suis jusqu'à 5 cents sur celui-ci maintenant, hein? lol ...

utilisation Integer.toString(tmpInt).trim();

Essayez une conversion de caractères simple

char c = (char) i;