umwandeln Wie konvertiere ich einen String in ein int in Java?




string in int umwandeln c++ (24)

Verwenden Sie Integer.parseInt(yourString)

Denken Sie 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 Höchstwert 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)

Es gibt nur einen Ausnahmetyp: NumberFormatException

Wie kann ich einen String in Java in ein int konvertieren?

Mein String enthält nur Zahlen und ich möchte die Zahl zurückgeben, die er darstellt.

Bei Angabe der Zeichenfolge "1234" das Ergebnis beispielsweise die Nummer 1234 .


Nun, ein sehr wichtiger zu berücksichtigender Punkt ist, dass der Ganzzahl-Parser NumberFormatException auslöst, wie 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.
}

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


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 zwei Methoden von commons-lang3 und großer Artikel zum Konvertieren here .


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

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

Verwenden Sie Integer.parseInt () und fügen Sie ihn in einen try...catch Block ein, um Fehler zu behandeln, nur für den Fall, dass 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);
    }
 }

Sie können dies einfach versuchen:

  • Verwenden Sie Integer.parseInt(your_string); konvertieren Sie einen String in int
  • Verwenden Sie Double.parseDouble(your_string); konvertieren Sie einen String in double

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

Dies ist ein vollständiges Programm, bei dem alle Bedingungen positiv und negativ sind, ohne die 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;
     }
    }

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

Zum Beispiel gibt es zwei Möglichkeiten:

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

Es gibt einen geringfügigen Unterschied zwischen diesen Methoden:

  • valueOf gibt eine neue oder zwischengespeicherte Instanz von java.lang.Integer
  • parseInt gibt das primitive int .

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


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

Zum Beispiel:

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

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

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

Wir können auch toInt(String strValue) der NumberUtils Utility-Klasse für die Konvertierung verwenden:

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

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

Weitere Informationen finden Sie in der Java-Dokumentation .


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 ist etwas effizienter.

  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. Für positive und 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 ein Leerzeichen erwarten, sollten Sie vor der weiteren Verarbeitung str = str.trim() .


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

  • Enthält die Zeichenfolge nur die Ziffern 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?

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

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

Das Apache-Dienstprogramm ist nett, denn wenn die Zeichenfolge ein ungültiges Zahlenformat ist, wird immer 0 zurückgegeben. Damit ersparen Sie sich den try catch-Block.

Apache NumberUtils API Version 3.4


Ich bin ein wenig ü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 - Ganzzahl (String) .

Natürlich gibt der Konstruktor den Typ Integer , 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);
}

Integer.decode

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

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 möchten, können Sie Folgendes verwenden:

  1. Unboxing:

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

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

Nur zum Spaß: Sie können die Optional 8 von Java 8 verwenden, um einen 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 - zum Beispiel, wenn Sie Nullprüfungen vermeiden möchten. Pre Java 8-Code sieht folgendermaßen aus:

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

Beachten Sie im Übrigen, dass der Aufruf:

int i = Integer.parseInt(null);

wirft NumberFormatException aus, nicht NullPointerException.


Wie NumberUtils Apache Commons NumberUtils kann das. Welche gibt 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; 

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

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.


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

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

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





type-conversion