Pourquoi devrais-je utiliser Entier.toString() au lieu de juste l'impression de l'Entier?

J'ai suivi un tutoriel Java et il est obligé de me faire quelque chose comme:

int k = 5;
System.out.println("The number is " + Integer.toString(k));

Donc, comme un bon sport j'ai suivi tout le long, mais je ne peux pas aider mais se demander, pourquoi utiliser cette méthode à tous? Semble que beaucoup de saisie de texte supplémentaire pour obtenir la même fonctionnalité que:

int k = 5;
System.out.println("The number is " + k);

Est-il une bonne raison pour utiliser le toString() méthode non-types de données chaîne? Et dans mon exemple, il y a aucune int valeurs qui ne peuvent pas être auto toString ed?

Il n'y a pas de différence significative entre les deux. Le tutoriel peut-être voulu souligner que toString est appelé "sous les couvertures", mais, pour le jour-à-jour de la programmation, c'est juste encombrement supplémentaire.
J'ai déjà posté une réponse plus tôt, mais je voulais souligner pour les lecteurs occasionnels qu'il existe des cas dans lesquels vous devez utiliser Entier.toString(int) et/ou d'autres garanties lors de la concaténation d'éléments dans une longue Chaîne avec le + de l'opérateur. Si vous n'êtes pas prudent, de concaténation de Chaîne avec la + opérateur peut produire des résultats inattendus.

InformationsquelleAutor Mike | 2013-01-02

19

C'est l'un des nombreux "coffre-fort de la programmation" les pratiques que vous pouvez adopter afin d'améliorer la clarté et de prévenir les subtiles erreurs qui vous ou un futur responsable de votre code pourrait introduire. Prenons l'exemple suivant:
```
private static void printMessage(int k) {
    System.out.println("number" + '=' + k);
}
```
de sortie: number=5

Maintenant, supposons que vous souhaitez imprimer le nombre premier et le dernier texte. Tout ce que je suis en train de faire est de remplacer le premier et le dernier élément de la concaténation de chaîne:
```
private static void printMessage2(int k) {
    System.out.println(k + '=' + "number");
}
```
de sortie: 66number

Oups! L'int valeur de = a été ajouté à k au lieu d'être concaténées. Une solution est de faire de la = dans un String. Une autre solution est de convertir explicitement le int à un String:
```
private static void printMessage2Safe(int k) {
    System.out.println(Integer.toString(k) + '=' + "number");
}   
```
de sortie: 5=number

"Oh, mais je n'avais jamais le faire, de toute façon," dites-vous. "Quelqu'un dans son esprit droit serait ont simplement fait le = partie de l'autre de la Chaîne." Mais que faire si vous êtes à la mise en œuvre de la partie d'une calculatrice de base de l'app, et vous voulez à la sortie de l'expression et de son résultat? Si vous êtes vraiment essayer d'être prudent, je suppose que vous allez utiliser StringBuilder.append() pour concaténer les parties de l'expression. Mais si non, alors j'espère que vous n'avez pas écrit la première mise en œuvre de la display méthode ci-dessous.
```
public class Calculator {

    public static void main(String[] args) {
        display(2, '+', 3, 5);
        displaySafe(2, '+', 3, 5);
    }

    public static void display(int num1, char operator, int num2, int result) {
        System.out.println(num1 + operator + num2 + '=' + result);
    }

    public static void displaySafe(int num1, char operator, int num2, int result) {
        System.out.println(Integer.toString(num1) + operator + Integer.toString(num2) + "=" + result);
    }

}
```
de sortie:
```
114
2+3=5
```
- très bon exemple de la raison pour utiliser toString
InformationsquelleAutor rob
5

Est-il une bonne raison pour utiliser la méthode toString() pour les non-types de données string?

Certaines personnes croient qu'il est plus clair. esp pour les débutants qui ne peuvent pas rendu compte qu'ils font essentiellement la même chose.

Remarque: Dans Java 7 update 9, il n'a pas créer la Chaîne abord comme append(int) ressemble à ceci
```
//from AbstractStringBuilder 
public AbstractStringBuilder append(int i) {
    if (i == Integer.MIN_VALUE) {
        append("-2147483648");
        return this;
    }
    int appendedLength = (i < 0) ? Integer.stringSize(-i) + 1
                                 : Integer.stringSize(i);
    int spaceNeeded = count + appendedLength;
    ensureCapacityInternal(spaceNeeded);
    Integer.getChars(i, spaceNeeded, value);
    count = spaceNeeded;
    return this;
}
```
Il convertit le nombre détroit dans le StringBuilder en évitant la nécessité de créer une Chaîne de premier.

Et dans mon exemple, il y a tout int les valeurs qui ne peuvent pas être auto toString ed?

Pas. Toutes les valeurs primitives peuvent être toString ed.

La seule exception que je connaisse est de signalisation et de calme not-A-Number valeurs que Java ne se soucie pas de telles choses. Les deux apparaissent comme des "NaN" et il n'y a aucun moyen de faire la différence dans les méthodes toString() (ou la plupart des fonctions en Java)
- Mais notez que ces signaux/NaN valeurs ne sont utilisés que par virgule flottante primitives comme float/double, et pas int.
InformationsquelleAutor Peter Lawrey
0
```
System.out.println("The number is " + Integer.toString(k));
```
Dans le print ci-dessus "Le nombre est " est une chaîne, donc Chaîne+(n'importe quoi) est Chaîne seulement.Donc, dans ce cas, pas besoin d'appeler toString() à tous.Donc, si vous voulez imprimer la valeur de k seulement alors pas besoin d'appeler toString() comme S.O.P internaqlly appels toString().

Donc , finalement, nous pouvons dire, à moins que vous souhaitez convertir en Entier en Chaîne de caractères, vous ne devez pas appeler la méthode toString ().

InformationsquelleAutor Android Killer
0

Utiliser la deuxième version. Pour la chaîne de concatination des expressions comme
```
"The number is " + k;
```
javac construit le code à l'aide de StringBuilder comme
```
new StringBuilder("The number is ")).append(Integer.toString(k)).toString());
```
Système.out.println imprime simplement la chaîne résultante, le code complet est
```
System.out.println((new StringBuilder("The number is ")).append(Integer.toString(k)).toString());
```
InformationsquelleAutor Evgeniy Dorofeev
-6

Il permet le nombre de devenir un type de données String c'est tout une chaîne de caractères. Que la Foule dit cependant, il n'est même pas un entier pour commencer. Vous devez analyser un nombre entier avant de le devenir.
- Il n'a pas besoin d'être un nombre Entier, depuis Entier.toString(int) ne s'attend pas à un nombre Entier.
- Et tout comme la réponse de parrot, c'est incorrect.
- println effectue cette conversion automatiquement,nous n'avons pas À le FAIRE
InformationsquelleAutor Dustin Koeller

Vous devez vous connecter pour publier un commentaire.