Come faccio a convertire una stringa in un int in Java?

Come posso convertire un Stringin un intin Java?

La mia stringa contiene solo numeri e voglio restituire il numero che rappresenta.

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

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

Se guardi la Documentazione Java noterai che la "cattura" è che questa funzione può lanciare un NumberFormatException, che ovviamente devi gestire:

int foo;
try {
   foo = Integer.parseInt(myString);
}
catch (NumberFormatException e)
{
   foo = 0;
}

(Per impostazione predefinita, questo trattamento imposta un numero non valido 0, ma se lo desideri puoi fare qualcos'altro.)

In alternativa, puoi usare un Intsmetodo dalla libreria Guava, che in combinazione con Java 8 Optional, fornisce un modo potente e conciso per convertire una stringa in un int:

import com.google.common.primitives.Ints;

int foo = Optional.ofNullable(myString)
 .map(Ints::tryParse)
 .orElse(0)

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 un'istanza nuova o memorizzata nella cache di java.lang.Integer
• parseIntrestituisce primitivo int.

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

Bene, un punto molto importante da considerare è che il parser Integer genera NumberFormatException come indicato in Javadoc .

int foo;
String StringThatCouldBeANumberOrNot = "26263Hello"; //will throw exception
String StringThatCouldBeANumberOrNot2 = "26263"; //will not throw exception
try {
      foo = Integer.parseInt(StringThatCouldBeANumberOrNot);
} catch (NumberFormatException e) {
      //Will Throw exception!
      //do something! anything to handle the exception.
}

try {
      foo = Integer.parseInt(StringThatCouldBeANumberOrNot2);
} catch (NumberFormatException e) {
      //No problem this time, but still it is good practice to care about exceptions.
      //Never trust user input :)
      //Do something! Anything to handle the exception.
}

È importante gestire questa eccezione quando si cerca di ottenere valori interi da argomenti divisi o analizzare qualcosa in modo dinamico.

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 è quella di utilizzare NumberUtils di Apache Commons :

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

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

Apache NumberUtils API Versione 3.4

Attualmente sto svolgendo un incarico per il college, in cui non posso usare determinate espressioni, come quelle sopra, e guardando la tabella ASCII, sono riuscito a farlo. È un codice molto più complesso, ma potrebbe aiutare gli altri che sono limitati 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, quindiString number = "12";

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

 // 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 passaggio 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é raddoppiare) in questo modo:

 lastdigit = lastdigit/10;

Questo sta semplicemente giocando 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à dalle cifre di un numero. Vedi, dato che consideriamo solo 0-9, dividere per un multiplo di 10 è come creare una "scatola" in cui conservarla (ripensaci a quando il tuo insegnante di prima elementare ti ha spiegato che cosa erano un'unità e un centinaio). Così:

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

E il gioco è fatto. Hai trasformato una stringa di cifre (in questo caso, due cifre), in un numero intero composto da quelle due cifre, considerando le seguenti limitazioni:

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

Integer.decode

Puoi anche usare public static Integer decode(String nm) throws NumberFormatException .

Funziona anche con le basi 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 intinvece di Integerpuoi usare:

1. Spacchettamento:

   int val = Integer.decode("12"); 

2. intValue():

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

Ogni volta che esiste la minima possibilità che la stringa specificata non contenga un numero intero, è necessario gestire questo caso speciale. Purtroppo, i metodi Java standard Integer::parseInte Integer::valueOflanciano a NumberFormatExceptionper segnalare questo caso speciale. Pertanto, è necessario utilizzare le eccezioni per il controllo del flusso, che è generalmente considerato stile di codifica errato.

A mio avviso, questo caso speciale dovrebbe essere gestito restituendo uno spazio vuoto Optional<Integer>. Poiché Java non offre 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();
    }
}

Esempio di utilizzo:

// prints "12"
System.out.println(tryParseInteger("12").map(i -> i.toString()).orElse("invalid"));
// prints "-1"
System.out.println(tryParseInteger("-1").map(i -> i.toString()).orElse("invalid"));
// prints "invalid"
System.out.println(tryParseInteger("ab").map(i -> i.toString()).orElse("invalid"));

Mentre questo utilizza ancora eccezioni per il controllo del flusso internamente, il codice di utilizzo diventa molto pulito. Inoltre, è possibile distinguere chiaramente il caso in cui -1viene analizzato un valore valido e il caso in cui non è stato possibile analizzare una stringa non valida.

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

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

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 Integer, tutti gli altri metodi - int primitivo.

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

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

Per esempio:

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

La Integerclasse fornisce anche il valueOf(String str)metodo:

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

Possiamo anche usare toInt(String strValue)dei NumberUtils Utility Class 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 (numero 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 del genere)

Esiste un solo tipo di eccezione: NumberFormatException

Ho una soluzione, ma non so quanto sia efficace. Ma funziona bene e penso che potresti migliorarlo. D'altra parte, ho fatto un paio di test con JUnit che procedono correttamente. Ho allegato la funzione e il test:

static public Integer str2Int(String str) {
    Integer result = null;
    if (null == str || 0 == str.length()) {
        return null;
    }
    try {
        result = Integer.parseInt(str);
    } 
    catch (NumberFormatException e) {
        String negativeMode = "";
        if(str.indexOf('-') != -1)
            negativeMode = "-";
        str = str.replaceAll("-", "" );
        if (str.indexOf('.') != -1) {
            str = str.substring(0, str.indexOf('.'));
            if (str.length() == 0) {
                return (Integer)0;
            }
        }
        String strNum = str.replaceAll("[^\\d]", "" );
        if (0 == strNum.length()) {
            return null;
        }
        result = Integer.parseInt(negativeMode + strNum);
    }
    return result;
}

Test con JUnit:

@Test
public void testStr2Int() {
    assertEquals("is numeric", (Integer)(-5), Helper.str2Int("-5"));
    assertEquals("is numeric", (Integer)50, Helper.str2Int("50.00"));
    assertEquals("is numeric", (Integer)20, Helper.str2Int("$ 20.90"));
    assertEquals("is numeric", (Integer)5, Helper.str2Int(" 5.321"));
    assertEquals("is numeric", (Integer)1000, Helper.str2Int("1,000.50"));
    assertEquals("is numeric", (Integer)0, Helper.str2Int("0.50"));
    assertEquals("is numeric", (Integer)0, Helper.str2Int(".50"));
    assertEquals("is numeric", (Integer)0, Helper.str2Int("-.10"));
    assertEquals("is numeric", (Integer)Integer.MAX_VALUE, Helper.str2Int(""+Integer.MAX_VALUE));
    assertEquals("is numeric", (Integer)Integer.MIN_VALUE, Helper.str2Int(""+Integer.MIN_VALUE));
    assertEquals("Not
     is numeric", null, Helper.str2Int("czv.,xcvsa"));
    /**
     * Dynamic test
     */
    for(Integer num = 0; num < 1000; num++) {
        for(int spaces = 1; spaces < 6; spaces++) {
            String numStr = String.format("%0"+spaces+"d", num);
            Integer numNeg = num * -1;
            assertEquals(numStr + ": is numeric", num, Helper.str2Int(numStr));
            assertEquals(numNeg + ": is numeric", numNeg, Helper.str2Int("- " + numStr));
        }
    }
}

Google Guava ha tryParse (String) , che restituisce nullse la stringa non può essere analizzata, ad esempio:

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

Puoi anche iniziare rimuovendo tutti i caratteri non numerici e quindi analizzando il numero intero:

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

Ma attenzione che questo funziona solo per numeri non negativi.

Oltre alle risposte precedenti, vorrei aggiungere diverse funzioni. Questi sono i risultati mentre li usi:

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
}

Implementazione:

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

Come accennato, Apache Commons ' NumberUtilspuò farlo. Restituisce 0se non riesce a convertire una stringa in un 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;

Puoi usare questo codice anche, con alcune precauzioni.

• Opzione n. 1: gestire esplicitamente l'eccezione, ad esempio mostrando una finestra di dialogo del messaggio 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 n. 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;
  }

L'uso di una costante di stringa per il confronto o qualsiasi tipo di elaborazione è sempre una buona idea, poiché una costante non restituisce mai un valore nullo.

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

Nelle competizioni di programmazione, dove hai la certezza che quel numero sarà sempre un numero intero valido, puoi scrivere il tuo metodo per analizzare l'input. Ciò salterà tutto il codice relativo alla convalida (poiché 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 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 prima o dopo questi numeri, assicurati di farlo str = str.trim()prima di elaborarlo ulteriormente.

Semplicemente puoi provare questo:

• Utilizzare Integer.parseInt(your_string);per convertire un Stringinint
• Utilizzare Double.parseDouble(your_string);per convertire un Stringindouble

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

Per una stringa normale puoi usare:

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

Per un generatore di stringhe e un buffer di stringhe puoi usare:

Integer.parseInt(myBuilderOrBuffer.toString());

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

Assicurarsi che non vi siano dati non numerici nella stringa.

Sono un po 'sorpreso che nessuno abbia menzionato il costruttore Integer che prende String come parametro.

Quindi, eccolo qui:

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

Java 8 - Numero intero (stringa) .

Naturalmente, il costruttore restituirà il tipo Integere un'operazione di unboxing converte il valore in int.

È importante menzionare : questo costruttore chiama il parseIntmetodo.

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

Usa Integer.parseInt () e inseriscilo in un try...catchblocco per gestire eventuali errori nel caso in cui venga inserito 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);
    }
 }

Eccoci qui

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

Può essere fatto in sette modi:

import com.google.common.primitives.Ints;
import org.apache.commons.lang.math.NumberUtils;

String number = "999";

1) Utilizzando Ints.tryParse:

int result = Ints.tryParse(number);

2) Utilizzando NumberUtils.createInteger:

Integer result = NumberUtils.createInteger(number);

3) Utilizzando NumberUtils.toInt:

int result = NumberUtils.toInt(number);

4) Utilizzando Integer.valueOf:

Integer result = Integer.valueOf(number);

5) Utilizzando Integer.parseInt:

int result = Integer.parseInt(number);

6) Utilizzando Integer.decode:

int result = Integer.decode(number);

7) Utilizzando Integer.parseUnsignedInt:

int result = Integer.parseUnsignedInt(number);

Un metodo è parseInt (String). Restituisce un int primitivo:

String number = "10";
int result = Integer.parseInt(number);
System.out.println(result);

Il secondo metodo è valueOf (String) e restituisce un nuovo oggetto Integer ():

String number = "10";
Integer result = Integer.valueOf(number);
System.out.println(result);

È possibile utilizzare uno dei seguenti:

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)

Questo è un programma completo con tutte le condizioni positive e negative senza usare una 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;
    }
}