type-conversion da integer - Come posso convertire una stringa in un int in Java?





15 Answers

Ad esempio, qui ci sono due modi:

Integer x = Integer.valueOf(str);
// or
int y = Integer.parseInt(str);

C'è una leggera differenza tra questi metodi:

  • valueOf restituisce valueOf nuova o memorizzata nella cache di java.lang.Integer
  • parseInt restituisce int primitivo.

Lo stesso vale per tutti i casi: Short.valueOf / parseShort , Long.valueOf / parseLong , ecc.

to c++ c#

Come posso convertire una String in un int in Java?

My String contiene solo numeri e voglio restituire il numero che rappresenta.

Ad esempio, data la stringa "1234" il risultato dovrebbe essere il numero 1234 .




Fallo manualmente:

public static int strToInt( String str ){
    int i = 0;
    int num = 0;
    boolean isNeg = false;

    //Check for negative sign; if it's there, set the isNeg flag
    if (str.charAt(0) == '-') {
        isNeg = true;
        i = 1;
    }

    //Process each character of the string;
    while( i < str.length()) {
        num *= 10;
        num += str.charAt(i++) - '0'; //Minus the ASCII code of '0' to get the value of the charAt(i++).
    }

    if (isNeg)
        num = -num;
    return num;
}



Una soluzione alternativa è usare NumberUtils di Apache Commons :

int num = NumberUtils.toInt("1234");

L'utilità Apache è piacevole perché se la stringa è un formato numerico non valido, viene sempre restituito 0. Quindi salvarti il ​​blocco catch try.

API Apache NumberUtils Versione 3.4




Ogni volta che c'è la minima possibilità che la stringa data non contenga un numero intero, devi gestire questo caso speciale. Purtroppo, i metodi standard Java Integer::parseInt e Integer::valueOf generano una NumberFormatException per segnalare questo caso speciale. Pertanto, è necessario utilizzare le eccezioni per il controllo del flusso, che è generalmente considerato uno stile di codifica errato.

Secondo me, questo caso speciale dovrebbe essere gestito restituendo un Optional<Integer> . Poiché Java non offre un tale metodo, utilizzo il seguente wrapper:

private Optional<Integer> tryParseInteger(String string) {
    try {
        return Optional.of(Integer.valueOf(string));
    } catch (NumberFormatException e) {
        return Optional.empty();
    }
}

Uso:

// prints 1234
System.out.println(tryParseInteger("1234").orElse(-1));
// prints -1
System.out.println(tryParseInteger("foobar").orElse(-1));

Mentre questo utilizza ancora eccezioni per il controllo del flusso internamente, il codice di utilizzo diventa molto pulito.




Possiamo usare il metodo parseInt(String str) della classe di wrapper Integer per convertire un valore String in un valore intero.

Per esempio:

String strValue = "12345";
Integer intValue = Integer.parseInt(strVal);

La classe Integer fornisce anche il valueOf(String str) :

String strValue = "12345";
Integer intValue = Integer.valueOf(strValue);

Possiamo anche usare toInt(String strValue) della classe di utilità NumberUtils per la conversione:

String strValue = "12345";
Integer intValue = NumberUtils.toInt(strValue);



Usa Integer.parseInt(yourString)

Ricorda le seguenti cose:

Integer.parseInt("1"); // ok

Integer.parseInt("-1"); // ok

Integer.parseInt("+1"); // ok

Integer.parseInt(" 1"); // Eccezione (spazio vuoto)

Integer.parseInt("2147483648"); // Eccezione (l'intero è limitato a un valore massimo di 2.147.483.647)

Integer.parseInt("1.1"); // Eccezione ( . O , o qualsiasi altra cosa non consentita)

Integer.parseInt(""); // Eccezione (non 0 o qualcosa)

Esiste un solo tipo di eccezione: NumberFormatException




Solo per divertimento: puoi usare Java 8 Optional per convertire una String in un Integer :

String str = "123";
Integer value = Optional.of(str).map(Integer::valueOf).get();
// Will return the integer value of the specified string, or it
// will throw an NPE when str is null.

value = Optional.ofNullable(str).map(Integer::valueOf).orElse(-1);
// Will do the same as the code above, except it will return -1
// when srt is null, instead of throwing an NPE.

Qui combiniamo solo Integer.valueOf e Optinal . Probabilmente potrebbero esserci situazioni in cui ciò è utile, ad esempio quando si desidera evitare i controlli nulli. Il codice Pre Java 8 sarà simile al seguente:

Integer value = (str == null) ? -1 : Integer.parseInt(str);



Puoi anche iniziare rimuovendo tutti i caratteri non numerici e quindi analizzando l'int:

string mystr = mystr.replaceAll( "[^\\d]", "" );
int number= Integer.parseInt(mystr);

Ma sappi che funziona solo per numeri non negativi.




È possibile utilizzare il new Scanner("1244").nextInt() . Oppure chiedere se esiste anche un int: new Scanner("1244").hasNextInt()




Puoi usare questo codice anche con alcune precauzioni.

  • Opzione n. 1: gestire l'eccezione in modo esplicito, ad esempio, mostrando una finestra di dialogo e quindi interrompere l'esecuzione del flusso di lavoro corrente. Per esempio:

    try
        {
            String stringValue = "1234";
    
            // From String to Integer
            int integerValue = Integer.valueOf(stringValue);
    
            // Or
            int integerValue = Integer.ParseInt(stringValue);
    
            // Now from integer to back into string
            stringValue = String.valueOf(integerValue);
        }
    catch (NumberFormatException ex) {
        //JOptionPane.showMessageDialog(frame, "Invalid input string!");
        System.out.println("Invalid input string!");
        return;
    }
    
  • Opzione 2: reimpostare la variabile interessata se il flusso di esecuzione può continuare in caso di eccezione. Ad esempio, con alcune modifiche nel blocco catch

    catch (NumberFormatException ex) {
        integerValue = 0;
    }
    

Usare una costante di stringa per il confronto o qualsiasi tipo di calcolo è sempre una buona idea, perché una costante non restituisce mai un valore nullo.




Semplicemente puoi provare questo:

  • Utilizzare Integer.parseInt(your_string); convertire una String in int
  • Usa Double.parseDouble(your_string); convertire una String in double

Esempio

String str = "8955";
int q = Integer.parseInt(str);
System.out.println("Output>>> " + q); // Output: 8955
String str = "89.55";
double q = Double.parseDouble(str);
System.out.println("Output>>> " + q); // Output: 89.55



int foo=Integer.parseInt("1234");

Assicurarsi che non ci siano dati non numerici nella stringa.




Sono un po 'sorpreso dal fatto che nessuno abbia menzionato il costruttore Integer che prende String come parametro.
Quindi, ecco:

String myString = "1234";
int i1 = new Integer(myString);

Java 8 - Integer (String) .

Ovviamente, la funzione di costruzione restituirà il valore Integer e l'operazione di annullamento della conversione convertirà il valore in int .

È importante menzionare
Questo costruttore chiama il metodo parseInt .

public Integer(String var1) throws NumberFormatException {
    this.value = parseInt(var1, 10);
}



Usa Integer.parseInt () e inseriscilo in un blocco try...catch per gestire eventuali errori nel caso in cui venga immesso un carattere non numerico, ad esempio,

private void ConvertToInt(){
    String string = txtString.getText();
    try{
        int integerValue=Integer.parseInt(string);
        System.out.println(integerValue);
    }
    catch(Exception e){
       JOptionPane.showMessageDialog(
         "Error converting string to integer\n" + e.toString,
         "Error",
         JOptionPane.ERROR_MESSAGE);
    }
 }



A proposito, tieni presente che se la stringa è nullo, la chiamata:

int i = Integer.parseInt(null);

genera NumberFormatException, non NullPointerException.




Related