Wie konvertiere ich einen String in ein int in Java?

Zum Beispiel gibt es zwei Möglichkeiten:

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

Es gibt einen kleinen Unterschied zwischen diesen Methoden: 

• valueOf gibt eine neue oder zwischengespeicherte Instanz von Java.lang.Integer zurück.
• parseInt gibt das Grundelement int zurück. 

Gleiches gilt für alle Fälle: Short.valueOf/parseShort, Long.valueOf/parseLong, usw.

Nun, ein sehr wichtiger Punkt zu berücksichtigen ist, dass der Integer-Parser NumberFormatException auslöst, wie in Javadoc angegeben. 

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

Es ist wichtig, diese Ausnahme zu behandeln, wenn Sie versuchen, ganzzahlige Werte von Split-Argumenten abzurufen oder etwas dynamisch zu analysieren.

Mach es manuell:

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

Momentan mache ich eine Aufgabe fürs College, wo ich bestimmte Ausdrücke wie die oben genannten nicht verwenden kann. Wenn ich mir die Tabelle ASCII anschaue, ist es mir gelungen. Es ist ein weitaus komplexerer Code, aber er könnte anderen helfen, die so eingeschränkt sind wie ich.

Als erstes müssen Sie die Eingabe erhalten, in diesem Fall eine Ziffernfolge. Ich werde es String number nennen, und in diesem Fall werde ich es anhand der Nummer 12 veranschaulichen, daher String number = "12";

Eine weitere Einschränkung war die Tatsache, dass ich keine Wiederholungszyklen verwenden konnte. Daher kann ein for-Zyklus (der perfekt gewesen wäre) nicht verwendet werden. Das begrenzt uns ein wenig, aber das ist das Ziel. Da ich nur zwei Ziffern benötigte (wobei die letzten beiden Ziffern genommen wurden), löste sich eine einfache charAt darauf:

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

Mit den Codes müssen wir nur die Tabelle nachschlagen und die notwendigen Anpassungen vornehmen:

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

Warum also doppelt? Nun, wegen eines wirklich "komischen" Schrittes. Momentan haben wir zwei Doppel, 1 und 2, aber wir müssen es in 12 verwandeln. Es gibt keine mathematische Operation, die wir ausführen können.

Letztere (letzte Ziffer) teilen wir in der Weise 2/10 = 0.2 (daher warum doppelt) durch 10 wie folgt:

 lastdigit = lastdigit/10;

Dies ist nur ein Spiel mit Zahlen. Wir haben die letzte Ziffer in eine Dezimalzahl umgewandelt. Aber jetzt schauen Sie sich an, was passiert:

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

Ohne sich mit der Mathematik zu beschäftigen, isolieren wir einfach die Ziffern einer Zahl. Sie sehen, da wir nur 0-9 in Betracht ziehen, ist das Teilen durch ein Vielfaches von 10 wie das Erstellen einer "Box", in der Sie sie ablegen (denken Sie daran, als Ihr Lehrer der ersten Klasse Ihnen erklärt hat, was eine Einheit und hundert waren). So:

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

Und los gehts. Sie haben eine Zeichenfolge aus Ziffern (in diesem Fall zwei Ziffern) in eine aus diesen beiden Ziffern zusammengesetzte Ganzzahl umgewandelt, unter Berücksichtigung der folgenden Einschränkungen:

• Keine sich wiederholenden Zyklen
• Keine "magischen" Ausdrücke wie parseInt

Eine alternative Lösung ist die Verwendung von Apache Commons ' NumberUtils:

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

Das Apache-Dienstprogramm ist Nizza, da immer 0 zurückgegeben wird, wenn der String ein ungültiges Zahlenformat ist. Damit ersparen Sie sich den try-catch-Block.

Apache NumberUtils API Version 3.4

Integer.decode

Sie können auch public static Integer decode(String nm) throws NumberFormatException verwenden.

Es funktioniert auch für Basis 8 und 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

Wenn Sie int anstelle von Integer erhalten möchten, können Sie Folgendes verwenden:

1. Unboxing:

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

2. intValue():

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

Wenn die geringste Möglichkeit besteht, dass der angegebene String keine Ganzzahl enthält, müssen Sie diesen Sonderfall behandeln. Leider geben die Java-Standardmethoden Integer::parseInt und Integer::valueOf eine NumberFormatException aus, um diesen Sonderfall zu signalisieren. Daher müssen Sie Ausnahmen für die Flusskontrolle verwenden, was im Allgemeinen als schlechter Codierstil gilt.

Meines Erachtens sollte dieser Sonderfall behandelt werden, indem ein Optional<Integer> zurückgegeben wird. Da Java keine solche Methode anbietet, verwende ich den folgenden Wrapper:

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

Verwendungszweck:

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

Während dies intern immer noch Ausnahmen für die Flusssteuerung verwendet, wird der Verwendungscode sehr sauber.

Das Konvertieren eines Strings in ein int ist komplizierter als das Konvertieren einer Zahl. Sie haben über folgende Themen nachgedacht:

• Enthält der String nur Zahlen 0-9?
• Was ist mit -/+ vor oder nach der Zeichenfolge? Ist das möglich (bezogen auf Abrechnungsnummern)?
• Was ist los mit MAX _-/MIN_INFINITY? Was passiert, wenn die Zeichenfolge 99999999999999999999 lautet? Kann die Maschine diese Zeichenfolge als int behandeln?

Methoden, um das zu tun:

 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 erzeugt ein Integer-Objekt, alle anderen Methoden - primitiv int.

Letzte 2 Methoden aus commons-lang3 und großer Artikel zum Konvertieren hier .

Wir können die parseInt(String str)-Methode der Wrapper-Klasse Integer zum Konvertieren eines String-Werts in einen Ganzzahlwert verwenden.

Zum Beispiel:

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

Die Integer-Klasse stellt auch die valueOf(String str)-Methode bereit:

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

Wir können auch toInt(String strValue) von NumberUtils Utility Class für die Konvertierung verwenden:

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

Verwenden Sie Integer.parseInt(yourString)

Erinnere dich an folgende Dinge:

Integer.parseInt("1");/ ok

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

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

Integer.parseInt(" 1"); // Ausnahme (Leerzeichen)

Integer.parseInt("2147483648"); // Ausnahme (Integer ist auf einen Maximalwert von 2.147.483.647 begrenzt)

Integer.parseInt("1.1"); // Ausnahme (_ /. Oder , oder was auch immer nicht erlaubt ist)

Integer.parseInt(""); // Ausnahme (nicht 0 oder etwas anderes)

Es gibt nur einen Ausnahmetyp: NumberFormatException

Ich habe eine Lösung, weiß aber nicht, wie effektiv sie ist. Aber es funktioniert gut und ich denke, Sie könnten es verbessern. Auf der anderen Seite habe ich ein paar Tests mit JUnit gemacht, die richtig abschneiden. Ich habe die Funktion und das Testen angehängt:

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

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

Nur zum Spaß: Sie können die Optional von Java 8 verwenden, um eine String in eine Integer zu konvertieren:

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.

Hier kombinieren wir einfach Integer.valueOf und Optinal. Möglicherweise gibt es Situationen, in denen dies nützlich ist, beispielsweise wenn Sie Nullprüfungen vermeiden möchten. Pre Java 8-Code sieht folgendermaßen aus:

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

Guava hat tryParse (String) , das null zurückgibt, wenn der String nicht analysiert werden konnte. Beispiel:

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

Sie können auch beginnen, indem Sie alle nicht numerischen Zeichen entfernen und dann das int analysieren:

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

Aber seien Sie gewarnt, dass dies nur für nicht negative Zahlen funktioniert. 

Abgesehen von diesen Antworten möchte ich noch einige Funktionen hinzufügen: 

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

Und hier sind die Ergebnisse, während Sie sie ausführen: 

  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
  }

Bei Programmierwettbewerben, bei denen Sie sicher sind, dass die Zahl immer eine gültige Ganzzahl ist, können Sie Ihre eigene Methode schreiben, um die Eingabe zu analysieren. Dadurch wird der gesamte mit der Validierung zusammenhängende Code übersprungen (da Sie keinen davon benötigen) und wird etwas effizienter sein.

1. Für gültige positive ganze Zahl:

   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. Sowohl für positive als auch für negative ganze Zahlen:

   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. Wenn Sie vor oder nach diesen Zahlen mit einem Leerzeichen rechnen, Stellen Sie sicher, dass Sie vor der weiteren Verarbeitung eine str = str.trim() ausführen.

Wie erwähnt, kann Apache Commons NumberUtils es tun. Welche Rückgabe 0, wenn es nicht möglich ist, Zeichenfolge in int zu konvertieren.

Sie können auch Ihren eigenen Standardwert definieren.

NumberUtils.toInt(String str, int defaultValue)

beispiel:

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; 

Sie können diesen Code auch mit einigen Vorsichtsmaßnahmen verwenden.

• Option 1: Behandeln Sie die Ausnahme explizit, z. B. ein Meldungsdialogfeld, und beenden Sie die Ausführung des aktuellen Workflows. Zum Beispiel:

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

• Option 2: Setzen Sie die betroffene Variable zurück, wenn der Ausführungsablauf im Ausnahmefall fortgesetzt werden kann. Zum Beispiel mit einigen Änderungen im catch-Block

  catch (NumberFormatException ex) {
      integerValue = 0;
  }
  

Die Verwendung einer String-Konstante für Vergleiche oder Berechnungen ist immer eine gute Idee, da eine Konstante niemals einen Nullwert zurückgibt.

Sie können new Scanner("1244").nextInt() verwenden. Oder fragen Sie, ob auch ein int existiert: new Scanner("1244").hasNextInt()

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

Stellen Sie sicher, dass der String keine nicht numerischen Daten enthält.

Für normale Zeichenfolge können Sie Folgendes verwenden:

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

Für String Builder und String Buffer können Sie Folgendes verwenden:

Integer.parseInt(myBuilderOrBuffer.toString());

Sie können dies einfach versuchen:

• Verwenden Sie Integer.parseInt(your_string);, um eine String in int zu konvertieren.
• Verwenden Sie Double.parseDouble(your_string);, um eine String in double zu konvertieren.

Beispiel

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

Auf geht's

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

Ich bin etwas überrascht, dass niemand den Integer-Konstruktor, der String als Parameter verwendet, nicht erwähnt hat.
Also hier ist: 

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

Java 8 - Integer (String) . 

Natürlich gibt der Konstruktor den Typ Integer zurück und der Unboxing-Vorgang konvertiert den Wert in int. 

Es ist wichtig zu erwähnen
Dieser Konstruktor ruft die parseInt-Methode auf. 

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

Verwenden Sie Integer.parseInt () und fügen Sie ihn in einen try...catch-Block ein, um Fehler zu behandeln, falls ein nicht-numerisches Zeichen eingegeben wird

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

Eine Methode ist parseInt (String), die ein primitives int zurückgibt

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

Die zweite Methode ist valueOf (String) gibt ein neues Integer () - Objekt zurück.

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

Dies ist ein vollständiges Programm mit allen Bedingungen positiv, negativ, ohne Bibliothek zu verwenden  

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

Sie können Folgendes verwenden:

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.parseInt(myString); - Verwendung der Wrapper-Klasse

Kann auf 5 Arten durchgeführt werden:

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

1) Ints.tryParse verwenden:

String number = "999";
int result = Ints.tryParse(number);

2) NumberUtils.createInteger verwenden:

String number = "999";
Integer result = NumberUtils.createInteger(number);

3) NumberUtils.toInt verwenden:

String number = "999";
int result = NumberUtils.toInt(number);

4) Integer.valueOf verwenden:

String number = "999";
Integer result = Integer.valueOf(number);

5) Integer.parseInt verwenden:

String number = "999";
int result = Integer.parseInt(number);

Beachten Sie im Übrigen, dass der Aufruf:

int i = Integer.parseInt(null);

wirft NumberFormatException aus, nicht NullPointerException.

import Java.util. *;

öffentliche Klasse strToint {

    public static void main(String[] args){

            String str = "123";

            byte barr[] = str.getBytes();

            System.out.println(Arrays.toString(barr));
            int result=0;
            for(int i=0;i<barr.length;i++){
                    //System.out.print(barr[i]+" ");
                    int ii = barr[i];
                    char a = (char)ii;
                    int no = Character.getNumericValue(a);
                    result=result*10+no;
                    System.out.println(result);

            }
            System.out.println("result:"+result);
    }

}

public static int parseInt (String s) löst NumberFormatException aus

sie können den Benutzer Integer.parseInt() verwenden, um einen String in int zu konvertieren.

wandelt einen String 20 in ein primitives int um.

    String n = "20";
    int r = Integer.parseInt(n);//returns a primitive int       
    System.out.println(r);

Ausgabe-20

wenn die Zeichenfolge keine parsbare Ganzzahl enthält. es wird geworfen NumberFormatException

String n = "20I";// throwns NumberFormatException
int r = Integer.parseInt(n);
System.out.println(r);

public static Integer valueOf (String s) löst NumberFormatException aus

sie können Integer.valueOf() verwenden. In diesem Fall wird ein Integer-Objekt zurückgegeben.

String n = "20";
Integer r = Integer.valueOf(n); //returns a new Integer() object.   
System.out.println(r);

Ausgabe-20

Referenzen https://docs.Oracle.com/de/

Es gibt folgende Möglichkeiten, String in Int zu konvertieren:

1. sie können Integer.parseInt() verwenden:

   String test = "4568"; int new = Integer.parseInt(test);

2. sie können auch Integer.valueOf() verwenden:

   String test = "4568"; int new =Integer.parseInt(test);

Konvertieren Sie einen String mit der Methode parseInt der Java Integer-Klasse in eine Ganzzahl. Die parseInt-Methode konvertiert den String in ein int und wirft eine NumberFormatException, wenn der String nicht in einen int-Typ konvertiert werden kann.

Verwenden Sie zum Übersehen der Ausnahme, die es werfen kann:

int i = Integer.parseInt(myString);

Wenn der durch die Variable gekennzeichnete String myString eine gültige ganze Zahl wie “1234”, “200”, “1”, ist, wird er in ein Java-int konvertiert. Wenn dies aus irgendeinem Grund fehlschlägt, kann die Änderung eine NumberFormatException auslösen, daher sollte der Code etwas länger sein, um dies zu berücksichtigen.

Ex. Java String in int Konvertierungsmethode, Steuerung für eine mögliche NumberFormatException

public class JavaStringToIntExample
{
  public static void main (String[] args)
  {
    // String s = "test";  // use this if you want to test the exception below
    String s = "1234";

    try
    {
      // the String to int conversion happens here
      int i = Integer.parseInt(s.trim());

      // print out the value after the conversion
      System.out.println("int i = " + i);
    }
    catch (NumberFormatException nfe)
    {
      System.out.println("NumberFormatException: " + nfe.getMessage());
    }
  }
}

Wenn der Änderungsversuch fehlschlägt - falls Sie versuchen können, den Java-String-Test in ein int zu konvertieren -, wird der Prozess Integer parseInt eine NumberFormatException werfen, die Sie in einem try/catch-Block behandeln müssen.

Sie können die parseInt-Methode verwenden  

  String SrNumber="5790";
int extractNumber = Integer.parseInt(SrNumber);
System.out.println(extractNumber);//Result will be --5790

Benutzerdefinierter Algorithmus:

public static int toInt(String value) {
  int output = 0;
  boolean isFirstCharacter = true;
  boolean isNegativeNumber = false;
  byte bytes[] = value.getBytes();
  for (int i = 0; i < bytes.length; i++) {
    char c = (char) bytes[i];
    if (!Character.isDigit(c)) {
      isNegativeNumber = (c == '-');
      if (!(isFirstCharacter && (isNegativeNumber || c == '+'))) {
        throw new NumberFormatException("For input string \"" + value + "\"");
      }
    } else {
      int number = Character.getNumericValue(c);
      output = output * 10 + number;
    }
    isFirstCharacter = false;
  }
  if (isNegativeNumber) output *= -1;
  return output;
}

eine andere Lösung: (Verwenden Sie die Zeichenfolge charAt -Methode, anstatt die Zeichenfolge in ein Byte-Array zu konvertieren):

public static int toInt(String value) {
  int output = 0;
  boolean isFirstCharacter = true;
  boolean isNegativeNumber = false;
  for (int i = 0; i < value.length(); i++) {
    char c = value.charAt(i);
    if (!Character.isDigit(c)) {
      isNegativeNumber = (c == '-');
      if (!(isFirstCharacter && (isNegativeNumber || c == '+'))) {
        throw new NumberFormatException("For input string \"" + value + "\"");
      }
    } else {
      int number = Character.getNumericValue(c);
      output = output * 10 + number;
    }
    isFirstCharacter = false;
  }
  if (isNegativeNumber) output *= -1;
  return output;
}

Beispiele:

int number1 = toInt("20");
int number2 = toInt("-20");
int number3 = toInt("+20");
System.out.println("Numbers = " + number1 + ", " + number2 + ", " + number3);

try {
  toInt("20 Hadi");
} catch (NumberFormatException e) {
  System.out.println("Error: " + e.getMessage());
}

Using method: Integer.parseInt(String s)

String s = "123";
int n = Integer.parseInt(s);

Verwenden Sie Integer.parseInt(). Dies hilft Ihnen, Ihren String-Wert in int zu analysieren.

Beispiel:

String str = "2017";
int i = Integer.parseInt(str);
System.out.println(i);

ausgabe: 2017

Verwenden Sie diese Methode:

public int ConvertStringToInt(String number)
{
 int num = 0;
 try
 {
   int newNumber = Integer.ParseInt(number);
   num = newNumber;
 }
 catch(Exception ex)
 {
   num = 0;
   Log.i("Console",ex.toString);
 }
   return num;
}

Probieren Sie diesen Code mit verschiedenen Eingaben von String aus:

String a = "10";  
String a = "10ssda";  
String a = null; 
String a = "12102";

if(null != a) {
    try {
        int x = Integer.ParseInt(a.trim()); 
        Integer y = Integer.valueOf(a.trim());
        //  It will throw a NumberFormatException in case of invalid string like ("10ssda" or "123 212") so, put this code into try catch
    } catch(NumberFormatException ex) {
        // ex.getMessage();
    }
}

Ich habe diese schnelle Methode geschrieben, um eine Zeichenfolge in int oder long zu analysieren. Es ist schneller als das aktuelle JDK 11 Integer.parseInt oder Long.parseLong. Obwohl Sie nur nach int gefragt haben, habe ich auch den langen Parser mit einbezogen. Der nachstehende Codeparser erfordert, dass die Methode des Parsers klein sein muss, damit er schnell ausgeführt werden kann. Eine alternative Version befindet sich unterhalb des Testcodes. Die alternative Version ist ziemlich schnell und hängt nicht von der Größe der Klasse ab.

Wenn Sie diese Klasse auf Überlauf prüfen, können Sie den Code an Ihre Anforderungen anpassen. Eine leere Zeichenfolge ergibt bei meiner Methode 0, aber das ist beabsichtigt. Sie können dies ändern, um Ihren Fall anzupassen oder unverändert zu verwenden. 

Dies ist nur der Teil der Klasse, in dem parseInt und parseLong benötigt werden. Beachten Sie, dass dies nur Zahlen der Basis 10 betrifft.

Der Testcode für den int-Parser befindet sich unterhalb des folgenden Codes. 

/*
 * Copyright 2019 Khang Hoang Nguyen
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions
 * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 * @author: Khang Hoang Nguyen - [email protected]
 **/
final class faiNumber{        
    private static final long[] longpow = {0L, 1L, 10L, 100L, 1000L, 10000L, 100000L, 1000000L, 10000000L, 100000000L, 1000000000L,
                                           10000000000L, 100000000000L, 1000000000000L, 10000000000000L, 100000000000000L,
                                           1000000000000000L, 10000000000000000L, 100000000000000000L, 1000000000000000000L,
                                           };

    private static final int[] intpow = { 0, 1, 10, 100, 1000, 10000,
                                          100000, 1000000, 10000000, 100000000, 1000000000 
                                        };

    /**
     * parseLong(String str) parse a String into Long. 
     * All errors throw by this method is NumberFormatException.
     * Better errors can be made to tailor to each use case.
     **/
    public static long parseLong(final String str) { 
        final int length = str.length();
        if ( length == 0 ) return 0L;        

        char c1 = str.charAt(0); int start;

        if ( c1 == '-' || c1 == '+' ){
            if ( length == 1 ) throw new NumberFormatException( String.format("Not a valid long value. Input '%s'.", str) );
            start = 1;
        } else {
            start = 0;
        }
        /*
         * Note: if length > 19, possible scenario is to run through the string 
         * to check whether the string contains only valid digits.
         * If the check had only valid digits then a negative sign meant underflow, else, overflow.
         */
        if ( length - start > 19 ) throw new NumberFormatException( String.format("Not a valid long value. Input '%s'.", str) );

        long c; 
        long out = 0L;

        for ( ; start < length; start++){
            c = (str.charAt(start) ^ '0');
            if ( c > 9L ) throw new NumberFormatException( String.format("Not a valid long value. Input '%s'.", str) );
            out += c * longpow[length - start];
        }

        if ( c1 == '-' ){
            out = ~out + 1L;
            // if out > 0 number underflow(supposed to be negative).
            if ( out > 0L ) throw new NumberFormatException( String.format("Not a valid long value. Input '%s'.", str) );
            return out;
        }
        // if out < 0 number overflow(supposed to be positive).
        if ( out < 0L ) throw new NumberFormatException( String.format("Not a valid long value. Input '%s'.", str) );
        return out;
    }

    /**
     * parseInt(String str) parse a string into an int.
     * return 0 if string is empty. 
     **/
    public static int parseInt(final String str) { 
        final int length = str.length();
        if ( length == 0 ) return 0;        

        char c1 = str.charAt(0); int start; 

        if ( c1 == '-' || c1 == '+' ){
            if ( length == 1 ) throw new NumberFormatException( String.format("Not a valid integer value. Input '%s'.", str) );
            start = 1;
        } else {
            start = 0;
        }

        int out = 0; int c;
        int runlen = length - start;

        if ( runlen > 9 ) {
            if ( runlen > 10 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );

            c = (str.charAt(start) ^ '0');   // <- Any number from 0 - 255 ^ 48 will yield greater than 9 except 48 - 57
            if ( c > 9 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
            if ( c > 2 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
            out += c * intpow[length - start++];
        }

        for ( ; start < length; start++){
            c = (str.charAt(start) ^ '0');
            if ( c > 9 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
            out += c * intpow[length - start];
        }

        if ( c1 == '-' ){
            out = ~out + 1;
            if ( out > 0 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
            return out;
        }

        if ( out < 0 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
        return out;
    }
}

Testcode-Abschnitt. Dies sollte etwa 200 Sekunden dauern.

// Int Number Parser Test;
long start = System.currentTimeMillis();    
System.out.println("INT PARSER TEST");
for (int i = Integer.MIN_VALUE; i != Integer.MAX_VALUE; i++){
   if( faiNumber.parseInt(""+i) != i ) System.out.println("Wrong");
   if ( i == 0 ) System.out.println("HalfWay Done");
}

if( faiNumber.parseInt(""+Integer.MAX_VALUE) != Integer.MAX_VALUE ) System.out.println("Wrong");
long end = System.currentTimeMillis();
long result = (end - start);
System.out.println(result);        
// INT PARSER END */

Eine alternative Methode, die auch sehr schnell ist. Beachten Sie, dass ein Array von int pow nicht verwendet wird, sondern eine mathematische Optimierung der Multiplikation mit 10 durch Bitverschiebung.

public static int parseInt(final String str) { 
    final int length = str.length();
    if ( length == 0 ) return 0;        

    char c1 = str.charAt(0); int start; 

    if ( c1 == '-' || c1 == '+' ){
        if ( length == 1 ) throw new NumberFormatException( String.format("Not a valid integer value. Input '%s'.", str) );
        start = 1;
    } else {
        start = 0;
    }

    int out = 0; int c;
    while( start < length && str.charAt(start) == '0' ) start++; // <-- This to disregard leading 0, can be removed if you know exactly your source does not have leading zeroes.
    int runlen = length - start;

    if ( runlen > 9 ) {
        if ( runlen > 10 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );

        c = (str.charAt(start++) ^ '0');   // <- Any number from 0 - 255 ^ 48 will yield greater than 9 except 48 - 57
        if ( c > 9 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
        if ( c > 2 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
        out = (out << 1) + (out << 3) + c; // <- alternatively this can just be out = c or c above can just be out;
    }

    for ( ; start < length; start++){
        c = (str.charAt(start) ^ '0');
        if ( c > 9 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
        out = (out << 1) + (out << 3) + c; 
    }

    if ( c1 == '-' ){
        out = ~out + 1;
        if ( out > 0 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
        return out;
    }

    if ( out < 0 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
    return out;
}