Come faccio a convertire da int a String?

Sto lavorando a un progetto in cui tutte le conversioni da inta Stringvengono eseguite in questo modo:

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

Non ho familiarità con Java.

Questa è la solita pratica o è qualcosa di sbagliato, come suppongo?

I modi normali sarebbero Integer.toString(i)o String.valueOf(i).

La concatenazione funzionerà, ma non è convenzionale e potrebbe essere un cattivo odore poiché suggerisce che l'autore non è a conoscenza dei due metodi sopra (cos'altro potrebbero non sapere?).

Java ha un supporto speciale per l'operatore + se usato con le stringhe (vedi la documentazione ) che traduce il codice che hai inserito in:

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

in fase di compilazione. È leggermente meno efficiente ( sb.append()finisce per chiamare Integer.getChars(), che è quello che Integer.toString()avrebbe fatto comunque), ma funziona.

Per rispondere al commento di Grodriguez: ** No, il compilatore non ottimizza la stringa vuota in questo caso - guarda:

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

Inizializza StringBuilder:

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

Aggiungi la stringa vuota:

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

Aggiungi il numero intero:

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

Estrai la stringa finale:

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

C'è una proposta e un lavoro in corso per cambiare questo comportamento, mirato a JDK 9.

È accettabile, ma non ho mai scritto niente del genere. Preferirei questo:

String strI = Integer.toString(i);

Non è un buon modo.

Quando si esegue la conversione da int a stringa, è necessario utilizzare questo:

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

Non è solo l'ottimizzazione ¹ . Non mi piace

"" + i

perché non esprime ciò che voglio davvero fare ² .

Non voglio aggiungere un numero intero a una stringa (vuota). Voglio convertire un numero intero in stringa:

Integer.toString(i)

Oppure, non il mio preferito, ma comunque migliore della concatenazione, ottenere una rappresentazione in forma di stringa di un oggetto (intero):

String.valueOf(i)

^{1. Per il codice chiamato molto spesso, come nei loop, l'ottimizzazione è sicuramente un punto per non usare la concatenazione .}

^{2. questo non è valido per l'uso di concatenazioni reali come in System.out.println("Index: " + i); o String id = "ID" + i;}

Molti corsi universitari introduttivi sembrano insegnare questo stile, per due ragioni (nella mia esperienza):

• Non richiede comprensione di classi o metodi. Di solito, questo viene insegnato molto prima che venga mai menzionata la parola "classe" - e nemmeno le chiamate di metodo. Quindi usare qualcosa del genere String.valueOf(…)confonderebbe gli studenti.

• È un'illustrazione del "sovraccarico dell'operatore" - in effetti, questo ci è stato venduto come l' operatore di sovraccarico idiomatico (piccola meraviglia qui, poiché Java non consente il sovraccarico dell'operatore personalizzato).

Quindi potrebbe essere nato per necessità didattica (anche se direi che questo è solo un cattivo insegnamento) o essere usato per illustrare un principio che altrimenti sarebbe piuttosto difficile da dimostrare in Java.

L'espressione

"" + i

porta alla conversione della stringa di iruntime. Il tipo generale dell'espressione è String. iviene prima convertito in un Integeroggetto ( new Integer(i)), quindi String.valueOf(Object obj)viene chiamato. Quindi è equivalente a

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

Ovviamente, questo è leggermente meno performante della semplice chiamata String.valueOf(new Integer(i))che produrrà lo stesso risultato.

Il vantaggio ""+iè che la digitazione è più facile / veloce e alcune persone potrebbero pensare che sia più facile da leggere. Non è un odore di codice in quanto non indica alcun problema più profondo.

(Riferimento: JLS 15.8.1 )

Personalmente, non vedo nulla di male in questo codice.

È piuttosto utile quando si desidera registrare un valore int e il logger accetta solo una stringa. Direi che una tale conversione è conveniente quando devi chiamare un metodo che accetta una stringa, ma hai un valore int.

Per quanto riguarda la scelta tra Integer.toStringo String.valueOf, è tutta una questione di gusti.
... E internamente, String.valueOfchiama il Integer.toStringmetodo tra l'altro. :)

L'altro modo di cui sono a conoscenza è della Integerclasse:

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

Un esempio concreto (anche se non credo che tu ne abbia bisogno):

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

Funziona anche per altri tipi primitivi, ad esempio Double.toString.

Vedi qui per maggiori dettagli.

Questa tecnica è stata insegnata in una lezione introduttiva alla classe Java che ho seguito oltre un decennio fa. Tuttavia, dovrei notare che, IIRC, non eravamo ancora arrivati ​​ai metodi di classe String e Integer.

La tecnica è semplice e veloce da digitare. Se tutto ciò che sto facendo è stampare qualcosa, lo userò (ad esempio,System.out.println("" + i); . Tuttavia, penso che non sia il modo migliore per fare una conversione, in quanto ci vuole un secondo pensiero per capire cosa sta succedendo quando viene utilizzato in questo modo Inoltre, se le prestazioni sono un problema, sembra più lento (più sotto, così come in altre risposte).

Personalmente, preferisco Integer.toString (), poiché è ovvio cosa sta succedendo. String.valueOf () sarebbe la mia seconda scelta, in quanto sembra confondere (testimoniare i commenti dopo la risposta di Darioo).

Solo per sorridere :) Ho scritto delle lezioni per testare le tre tecniche: "" + i, Integer.toString e String.ValueOf. Ogni test ha appena convertito gli ints da 1 a 10000 in stringhe. Ho quindi eseguito ciascuno attraverso il tempo di Linux cinque volte il comando . Integer.toString () era leggermente più veloce di String.valueOf () una volta, si legavano tre volte e String.valueOf () era più veloce una volta; tuttavia, la differenza non fu mai più di un paio di millisecondi.

La tecnica "" + i è stata più lenta di entrambe su ogni test tranne uno, quando era 1 millisecondo più veloce di Integer.toString () e 1 millisecondo più lenta di String.valueOf () (ovviamente sullo stesso test in cui String.valueOf () era più veloce di Integer.toString ()). Mentre di solito era solo un paio di millisecondi più lento, c'era un test in cui era più lento di circa 50 millisecondi. YMMV .

Esistono vari modi per convertire in stringhe:

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

Dipende da come si desidera utilizzare la stringa. Questo può aiutare:

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

Soprattutto idem su SimonJ. Non mi piace il "" + i idioma. Se dici String.valueOf (i), Java converte l'intero in una stringa e restituisce il risultato. Se dite "" + i, Java crea un oggetto StringBuilder, vi aggiunge una stringa vuota, converte l'intero in una stringa, lo aggiunge a StringBuilder, quindi converte StringBuilder in una stringa. Sono molti altri passaggi. Suppongo che se lo fai una volta in un grande programma, non è un grosso problema. Ma se lo fai sempre, stai facendo fare al computer un sacco di lavoro extra e creando tutti questi oggetti extra che devono essere ripuliti. Non voglio diventare fanatico della micro-ottimizzazione, ma non voglio nemmeno essere inutilmente dispendioso.

String strI = String.valueOf(i);

String string = Integer.toString(i);

Entrambi i modi sono corretti.

Esistono molti modi per convertire un numero intero in una stringa:

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)

Esistono tre modi per convertire in stringhe

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

L'uso di "" + i è il modo più breve e semplice per convertire un numero in una stringa. Non è il più efficiente, ma è l'IMHO più chiaro e di solito è più importante. Più è semplice il codice, meno è probabile che si commetta un errore.

Personalmente penso che "" + io appaia come il poster della domanda originale afferma "puzzolente". Ho usato molti linguaggi OO oltre a Java. Se quella sintassi fosse intesa come appropriata, allora Java avrebbe semplicemente interpretato l'i da solo senza aver bisogno di "" come desiderato per essere convertito in una stringa e farlo poiché il tipo di destinazione non è ambiguo e solo un singolo valore verrebbe fornito sulla destra . L'altro sembra un "trucco" per ingannare il compilatore, cattivo mojo quando vengono prese in considerazione versioni diverse di Javac realizzate da altri produttori o da altre piattaforme se il codice deve mai essere trasferito. Diamine per i miei soldi dovrebbe piacere a molti altri OOL solo prendi un Typecast: (String) i. strizza l'occhio

Dato il mio modo di apprendere e per facilitare la comprensione di un tale costrutto quando leggo rapidamente altri codici, voto per il metodo Integer.toString (i). Dimenticando un ns o due nel modo in cui Java implementa le cose in background vs. String.valueOf (i) questo metodo mi sembra giusto e dice esattamente cosa sta succedendo: ho e Integer e vorrei che fosse convertito in una stringa.

Un buon punto sottolineato un paio di volte è forse che usare StringBuilder in primo piano è una buona risposta alla costruzione di stringhe miste di testo e ints o altri oggetti poiché è quello che verrà comunque utilizzato in background, giusto?

Solo i miei due centesimi gettati nel gattino già ben pagato delle risposte alla domanda di Mans ... sorrisi

MODIFICA ALLA MIA RISPOSTA DOPO ALCUNE RIFLESSIONI:

Ok, ok, ci stavo pensando un po 'di più e String.valueOf (i) è anche perfettamente buono e dice anche: voglio una stringa che rappresenti il ​​valore di un intero. lol, l'inglese è di gran lunga più difficile da analizzare di Java! Ma lascio il resto della mia risposta / commento ... Mi è stato sempre insegnato a usare il livello più basso di una catena metodo / funzione, se possibile, e mantengo comunque la leggibilità, quindi se String.valueOf chiama Integer.toString, allora perché usare un'intera arancia se lo sbuccerai comunque, Hmmm?

Per chiarire il mio commento su StringBuilder, costruisco molte stringhe con combinazioni di testo e int per lo più letterali e finiscono per essere lunghe e brutte con chiamate alle routine sopra menzionate incorporate tra i +, quindi mi sembra che se diventano Gli oggetti SB comunque e il metodo append ha dei sovraccarichi potrebbe essere più pulito andare avanti e usarlo ... Quindi immagino di essere fino a 5 centesimi su questo ora, eh? lol ...

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

Prova la semplice tipografia

char c = (char) i;