java - bedeutung - string in int umwandeln c++




Wie konvertiere ich einen String in ein int in Java? (20)

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

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 .


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
  }

Beachten Sie im Übrigen, dass der Aufruf:

int i = Integer.parseInt(null);

wirft NumberFormatException aus, nicht NullPointerException.


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


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

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


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

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

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

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

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 .


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.


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

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

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

  • Option 1: Behandeln Sie die Ausnahme explizit, z. B. ein Meldungsdialogfeld, und stoppen Sie dann 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 Modifikationen im catch-Block

    catch (NumberFormatException ex) {
        integerValue = 0;
    }
    

Die Verwendung einer String-Konstante zum Vergleich oder für andere Berechnungsarten ist immer eine gute Idee, da eine Konstante niemals einen Nullwert zurückgibt.


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


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

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; 

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

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

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

Weitere Informationen finden Sie in der Java-Dokumentation .





type-conversion