Come posso convertire una stringa in un int in Java?



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.

Question

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 .




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




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



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



Convertire una stringa in un int è più complicato della semplice conversione di un numero. Hai pensato ai seguenti problemi:

  • La stringa contiene solo numeri 0-9 ?
  • Che succede con - / + prima o dopo la stringa? È possibile (facendo riferimento ai numeri contabili)?
  • Che cosa succede con MAX _- / MIN_INFINITY? Cosa succederà se la stringa è 99999999999999999999? La macchina può trattare questa stringa come int?



Per la stringa normale puoi usare:

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

Per il generatore di stringhe e il buffer delle stringhe è possibile utilizzare:

Integer.parseInt(myBuilderOrBuffer.toString());



Possiamo usare il metodo parseInt(String str) della classe 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);



Utilizzare questa riga per analizzare un valore stringa su int:

 String x = "11111111";
 int y = Integer.parseInt(x);
 System.out.println(y);



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




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.




Questo è un programma completo con tutte le condizioni positive, negative senza usare la libreria

import java.util.Scanner;


    public class StringToInt {
     public static void main(String args[]) {
      String inputString;
      Scanner s = new Scanner(System.in);
      inputString = s.nextLine();

      if (!inputString.matches("([+-]?([0-9]*[.])?[0-9]+)")) {
       System.out.println("Not a Number");
      } else {
       Double result2 = getNumber(inputString);
       System.out.println("result = " + result2);
      }

     }
     public static Double getNumber(String number) {
      Double result = 0.0;
      Double beforeDecimal = 0.0;
      Double afterDecimal = 0.0;
      Double afterDecimalCount = 0.0;
      int signBit = 1;
      boolean flag = false;

      int count = number.length();
      if (number.charAt(0) == '-') {
       signBit = -1;
       flag = true;
      } else if (number.charAt(0) == '+') {
       flag = true;
      }
      for (int i = 0; i < count; i++) {
       if (flag && i == 0) {
        continue;

       }
       if (afterDecimalCount == 0.0) {
        if (number.charAt(i) - '.' == 0) {
         afterDecimalCount++;
        } else {
         beforeDecimal = beforeDecimal * 10 + (number.charAt(i) - '0');
        }

       } else {
        afterDecimal = afterDecimal * 10 + number.charAt(i) - ('0');
        afterDecimalCount = afterDecimalCount * 10;
       }
      }
      if (afterDecimalCount != 0.0) {
       afterDecimal = afterDecimal / afterDecimalCount;
       result = beforeDecimal + afterDecimal;
      } else {
       result = beforeDecimal;
      }

      return result * signBit;
     }
    }



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



Eccoci qui

String str="1234";
int number = Integer.parseInt(str);
print number;//1234



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.




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






Links