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




integer to (25)

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 .


Answers

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

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

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.


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

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

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

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

Assicurarsi che non ci siano dati non numerici nella stringa.


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 .


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

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

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?

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


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


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

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

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

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) restituisce un nuovo oggetto Integer ().

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

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 tenta di ottenere valori interi da argomenti divisi o l'analisi dinamica di qualcosa.


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.


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

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.


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

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.


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
  }

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

int i = Integer.parseInt(null);

genera NumberFormatException, non NullPointerException.


La migliore risposta che abbia mai sentito sull'uso degli alias di tipo fornito in C # viene da Jeffrey Richter nel suo libro CLR Via C # . Ecco i suoi 3 motivi:

  • Ho visto un certo numero di sviluppatori confusi, non sapendo se usare string o String nel loro codice. Perché in C # la stringa (una parola chiave) viene mappata esattamente su System.String (un tipo FCL), non vi è alcuna differenza e può essere utilizzato.
  • In C #, mappe lunghe a System.Int64 , ma in un linguaggio di programmazione diverso, long poteva mappare su Int16 o Int32 . In effetti, C ++ / CLI in realtà tratta come un Int32 . Qualcuno che legge il codice sorgente in una lingua potrebbe facilmente interpretare erroneamente l'intenzione del codice se fosse abituato a programmare in un linguaggio di programmazione diverso. In effetti, la maggior parte delle lingue non verrà trattata a lungo come una parola chiave e non verrà compilato il codice che la utilizza.
  • La FCL ha molti metodi che hanno nomi di tipi come parte dei loro nomi di metodi. Ad esempio, il tipo BinaryReader offre metodi come ReadBoolean , ReadInt32 , ReadSingle e così via e il tipo System.Convert offre metodi come ToBoolean , ToInt32 , ToSingle e così via. Sebbene sia legale scrivere il seguente codice, la linea con float mi sembra molto innaturale, e non è ovvio che la linea sia corretta:
BinaryReader br = new BinaryReader(...);
float val  = br.ReadSingle(); // OK, but feels unnatural
Single val = br.ReadSingle(); // OK and feels good

Così il gioco è fatto. Penso che questi siano davvero ottimi punti. Tuttavia, non mi trovo a usare il consiglio di Jeffrey nel mio codice. Forse sono troppo bloccato nel mio mondo C # ma finisco per cercare di rendere il mio codice simile al codice quadro.





java string int type-conversion