Come posso convertire una stringa in un int in Java?




java da string a integer (20)

Integer.decode

È anche possibile utilizzare public static Integer decode(String nm) throws NumberFormatException .

Funziona anche per la base 8 e 16:

// base 10
Integer.parseInt("12");     // 12 - int
Integer.valueOf("12");      // 12 - Integer
Integer.decode("12");       // 12 - Integer
// base 8
// 10 (0,1,...,7,10,11,12)
Integer.parseInt("12", 8);  // 10 - int
Integer.valueOf("12", 8);   // 10 - Integer
Integer.decode("012");      // 10 - Integer
// base 16
// 18 (0,1,...,F,10,11,12)
Integer.parseInt("12",16);  // 18 - int
Integer.valueOf("12",16);   // 18 - Integer
Integer.decode("#12");      // 18 - Integer
Integer.decode("0x12");     // 18 - Integer
Integer.decode("0X12");     // 18 - Integer
// base 2
Integer.parseInt("11",2);   // 3 - int
Integer.valueOf("11",2);    // 3 - Integer

Se vuoi ottenere int invece di Integer puoi usare:

  1. unboxing:

    int val = Integer.decode("12"); 
    
  2. intValue() :

    Integer.decode("12").intValue();
    

https://code.i-harness.com

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 .


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


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.


Attualmente sto facendo un incarico per il college, dove non posso usare certe espressioni, come quelle sopra, e guardando la tabella ASCII, sono riuscito a farlo. È un codice molto più complesso, ma potrebbe aiutare gli altri a essere ristretti come me.

La prima cosa da fare è ricevere l'input, in questo caso, una stringa di cifre; Lo chiamerò String number , e in questo caso, lo esemplificerò usando il numero 12, quindi String number = "12";

Un altro limite era il fatto che non potevo usare cicli ripetitivi, quindi un ciclo for (che sarebbe stato perfetto) non può essere usato neanche. Questo ci limita un po ', ma poi di nuovo, questo è l'obiettivo. Poiché avevo solo bisogno di due cifre (prendendo le ultime due cifre), un semplice charAt risolto:

 // Obtaining the integer values of the char 1 and 2 in ASCII
 int semilastdigitASCII = number.charAt(number.length()-2);
 int lastdigitASCII = number.charAt(number.length()-1);

Avendo i codici, dobbiamo solo cercare il tavolo e apportare le modifiche necessarie:

 double semilastdigit = semilastdigitASCII - 48;  //A quick look, and -48 is the key
 double lastdigit = lastdigitASCII - 48;

Ora, perché raddoppiare? Bene, a causa di un passo davvero "strano". Attualmente abbiamo due doppi, 1 e 2, ma dobbiamo trasformarlo in 12, non ci sono operazioni matematiche che possiamo fare.

Dividiamo quest'ultimo (lastdigit) per 10 nel modo 2/10 = 0.2 (quindi perché doppio) in questo modo:

 lastdigit = lastdigit/10;

Questo è semplicemente giocare con i numeri. Stavamo trasformando l'ultima cifra in un decimale. Ma ora, guarda cosa succede:

 double jointdigits = semilastdigit + lastdigit; // 1.0 + 0.2 = 1.2

Senza entrare troppo in matematica, stiamo semplicemente isolando le unità di un numero. Vedete, dal momento che consideriamo solo 0-9, dividendo per un multiplo di 10 è come creare una "scatola" in cui archiviarla (ripensateci quando il vostro insegnante di prima elementare vi spiegò che unità erano e cento). Così:

 int finalnumber = (int) (jointdigits*10); // Be sure to use parentheses "()"

E tu ci vai. Hai trasformato una stringa di cifre (in questo caso, due cifre) in un numero intero composto da queste due cifre, considerando le seguenti limitazioni:

  • Nessun ciclo ripetitivo
  • Nessuna espressione "magica" come parseInt

Come menzionato Apache Commons NumberUtils può farlo. Che restituisce 0 se non può convertire string in int.

Puoi anche definire il tuo valore predefinito.

NumberUtils.toInt(String str, int defaultValue)

esempio:

NumberUtils.toInt("3244", 1) = 3244
NumberUtils.toInt("", 1)     = 1
NumberUtils.toInt(null, 5)   = 5
NumberUtils.toInt("Hi", 6)   = 6
NumberUtils.toInt(" 32 ", 1) = 1 //space in numbers are not allowed
NumberUtils.toInt(StringUtils.trimToEmpty( "  32 ",1)) = 32; 

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?

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

Guava ha tryParse(String) , che restituisce null se non è possibile analizzare la stringa, ad esempio:

Integer fooInt = Ints.tryParse(fooString);
if (fooInt != null) {
  ...
}

Metodi per farlo:

 1. Integer.parseInt(s)
 2. Integer.parseInt(s, radix)
 3. Integer.parseInt(s, beginIndex, endIndex, radix)
 4. Integer.parseUnsignedInt(s)
 5. Integer.parseUnsignedInt(s, radix)
 6. Integer.parseUnsignedInt(s, beginIndex, endIndex, radix)
 7. Integer.valueOf(s)
 8. Integer.valueOf(s, radix)
 9. Integer.decode(s)
 10. NumberUtils.toInt(s)
 11. NumberUtils.toInt(s, defaultValue)

Integer.valueOf produce oggetto intero, tutti gli altri metodi - int primitivo.

Ultimi 2 metodi da commons-lang3 e un grande articolo sulla conversione here .


Nella programmazione delle competizioni, dove si è certi che il numero sarà sempre un numero intero valido, sarà possibile scrivere il proprio metodo per analizzare l'input. Questo salterà tutti i codici relativi alla validazione (dato che non ne hai bisogno) e sarà un po 'più efficiente.

  1. Per intero positivo valido:

    private static int parseInt(String str) {
        int i, n = 0;
    
        for (i = 0; i < str.length(); i++) {
            n *= 10;
            n += str.charAt(i) - 48;
        }
        return n;
    }
    
  2. Per i numeri interi sia positivi che negativi:

    private static int parseInt(String str) {
        int i=0, n=0, sign=1;
        if(str.charAt(0) == '-') {
            i=1;
            sign=-1;
        }
        for(; i<str.length(); i++) {
            n*=10;
            n+=str.charAt(i)-48;
        }
        return sign*n;
    }
    

  3. Se ti aspetti uno spazio bianco prima o dopo questi numeri, assicurati di fare uno str = str.trim() prima di procedere ulteriormente.


Oltre a queste risposte sopra, vorrei aggiungere diverse funzioni:

    public static int parseIntOrDefault(String value, int defaultValue) {
    int result = defaultValue;
    try {
      result = Integer.parseInt(value);
    } catch (Exception e) {

    }
    return result;
  }

  public static int parseIntOrDefault(String value, int beginIndex, int defaultValue) {
    int result = defaultValue;
    try {
      String stringValue = value.substring(beginIndex);
      result = Integer.parseInt(stringValue);
    } catch (Exception e) {

    }
    return result;
  }

  public static int parseIntOrDefault(String value, int beginIndex, int endIndex, int defaultValue) {
    int result = defaultValue;
    try {
      String stringValue = value.substring(beginIndex, endIndex);
      result = Integer.parseInt(stringValue);
    } catch (Exception e) {

    }
    return result;
  }

E qui ci sono risultati mentre li esegui:

  public static void main(String[] args) {
    System.out.println(parseIntOrDefault("123", 0)); // 123
    System.out.println(parseIntOrDefault("aaa", 0)); // 0
    System.out.println(parseIntOrDefault("aaa456", 3, 0)); // 456
    System.out.println(parseIntOrDefault("aaa789bbb", 3, 6, 0)); // 789
  }

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

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.


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.


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

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

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


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


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

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

Vedere la documentazione Java per ulteriori informazioni.





type-conversion