Wie konvertiere ich einen String in Java in einen Int?

Wie kann ich eine Stringin eine intin Java konvertieren ?

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

Bei gegebener Zeichenfolge sollte "1234"das Ergebnis beispielsweise die Zahl sein 1234.

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

Wenn Sie sich die Java-Dokumentation ansehen, werden Sie feststellen, dass diese Funktion einen "Haken" auslösen kann NumberFormatException, mit dem Sie natürlich umgehen müssen:

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

(Bei dieser Behandlung wird standardmäßig eine fehlerhafte Nummer verwendet 0, aber Sie können auch etwas anderes tun, wenn Sie möchten.)

Alternativ können Sie eine IntsMethode aus der Guava-Bibliothek verwenden, die in Kombination mit Java 8 Optionaleine leistungsstarke und präzise Möglichkeit bietet, eine Zeichenfolge in eine int zu konvertieren:

import com.google.common.primitives.Ints;

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

Hier sind zum Beispiel 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 zurück java.lang.Integer
• parseIntgibt primitiv zurück int.

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

Ein sehr wichtiger Punkt 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 aus geteilten 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;
}

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 hat, wird immer 0 zurückgegeben. Dadurch sparen Sie den try catch-Block.

Apache NumberUtils API Version 3.4

Momentan mache ich eine Aufgabe für das College, wo ich bestimmte Ausdrücke wie die oben genannten nicht verwenden kann, und indem ich mir die ASCII-Tabelle anschaue, habe ich es geschafft. Es ist ein weitaus komplexerer Code, aber er könnte anderen helfen, die wie ich eingeschränkt sind.

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

Eine weitere Einschränkung war die Tatsache, dass ich keine sich wiederholenden Zyklen verwenden konnte, daher kann auch ein forZyklus (der perfekt gewesen wäre) nicht verwendet werden. Das schränkt uns ein bisschen ein, aber das ist das Ziel. Da ich nur zwei Ziffern brauchte (die letzten beiden Ziffern), charAtlöste es ein einfaches :

 // 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 in die Tabelle schauen und die notwendigen Anpassungen vornehmen:

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

Warum also verdoppeln? Nun, wegen eines wirklich "seltsamen" Schritts. Derzeit haben wir zwei Doppel, 1 und 2, aber wir müssen daraus 12 machen, es gibt keine mathematische Operation, die wir ausführen können.

Wir teilen letzteres (letzte Ziffer) durch 10 2/10 = 0.2(also warum doppelt) wie folgt :

 lastdigit = lastdigit/10;

Dies spielt nur mit Zahlen. Wir haben die letzte Ziffer in eine Dezimalzahl umgewandelt. Aber jetzt schauen Sie, was passiert:

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

Ohne zu sehr in die Mathematik einzusteigen, isolieren wir einfach die Ziffern einer Zahl. Sie sehen, da wir nur 0-9 betrachten, ist das Teilen durch ein Vielfaches von 10 wie das Erstellen einer "Box", in der Sie es speichern (denken Sie daran, als Ihr Lehrer in der ersten Klasse Ihnen erklärte, was eine Einheit und hundert waren). Damit:

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

Und los geht's. Sie haben eine Ziffernfolge (in diesem Fall zwei Ziffern) in eine Ganzzahl umgewandelt, die aus diesen beiden Ziffern besteht, wobei die folgenden Einschränkungen berücksichtigt wurden:

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

Integer.decode

Sie können auch verwenden 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 intstattdessen erhalten möchten, Integerkönnen Sie verwenden:

1. Unboxing:

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

2. intValue()::

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

Immer wenn die geringste Möglichkeit besteht, dass der angegebene String keine Ganzzahl enthält, müssen Sie diesen Sonderfall behandeln. Leider signalisieren die Standard-Java-Methoden Integer::parseIntund Integer::valueOfwerfen ein NumberFormatException, um diesen Sonderfall zu signalisieren. Daher müssen Sie Ausnahmen für die Flusskontrolle verwenden, was im Allgemeinen als schlechter Codierungsstil angesehen wird.

Meiner Meinung nach sollte dieser Sonderfall durch Rückgabe eines leeren behandelt werden Optional<Integer>. Da Java eine solche Methode nicht 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();
    }
}

Anwendungsbeispiel:

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

Während dies intern immer noch Ausnahmen für die Flusskontrolle verwendet, wird der Verwendungscode sehr sauber. Außerdem können Sie den Fall, in dem -1ein gültiger Wert analysiert wird, und den Fall, in dem eine ungültige Zeichenfolge nicht analysiert werden konnte , klar unterscheiden .

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

• Enthält die Zeichenfolge nur die Nummern 0-9 ?
• Was ist los mit - / + vor oder nach dem String? Ist das möglich (unter Bezugnahme auf Buchungsnummern)?
• Was ist los mit MAX _- / MIN_INFINITY? Was passiert, wenn die Zeichenfolge 99999999999999999999 lautet? Kann die Maschine diesen String als int behandeln?

Methoden dazu:

 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 - primitive int.

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

Wir können die parseInt(String str)Methode der IntegerWrapper-Klasse verwenden, um einen String-Wert in einen Integer-Wert zu konvertieren.

Zum Beispiel:

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

Die IntegerKlasse bietet auch die folgende valueOf(String str)Methode:

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

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

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

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 Maximalwert von 2.147.483.647 begrenzt)

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

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

Es gibt nur eine Art von Ausnahme: NumberFormatException

Ich habe eine Lösung, aber ich weiß nicht, wie effektiv sie ist. Aber es funktioniert gut und ich denke, Sie könnten es verbessern. Andererseits habe ich mit JUnit einige Tests durchgeführt, die richtig waren. 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));
        }
    }
}

Google Guava verfügt über tryParse (String) , das zurückgibt, nullwenn 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 die Ganzzahl analysieren:

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

Beachten Sie jedoch, dass dies nur für nicht negative Zahlen funktioniert.

Neben den vorherigen Antworten möchte ich einige Funktionen hinzufügen. Dies sind Ergebnisse, während Sie sie verwenden:

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
}

Implementierung:

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

Wie bereits erwähnt, kann Apache Commons NumberUtilsdies tun. Es wird zurückgegeben, 0wenn eine Zeichenfolge nicht in eine int konvertiert werden kann.

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;

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

• Option 1: Behandeln Sie die Ausnahme explizit, indem Sie beispielsweise einen Nachrichtendialog anzeigen, 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ührungsfluss im Falle einer Ausnahme fortgesetzt werden kann. Zum Beispiel mit einigen Änderungen im catch-Block

  catch (NumberFormatException ex) {
      integerValue = 0;
  }

Die Verwendung einer Zeichenfolgenkonstante zum Vergleich oder für jede Art von Berechnung ist immer eine gute Idee, da eine Konstante niemals einen Nullwert zurückgibt.

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

Bei Programmierwettbewerben, bei denen Sie sicher sind, dass die Zahl immer eine gültige Ganzzahl ist, können Sie Ihre eigene Methode zum Analysieren von Eingaben schreiben. Dies überspringt den gesamten validierungsbezogenen Code (da Sie nichts davon benötigen) und ist etwas effizienter.

1. Für eine 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, stellen Sie sicher, dass Sie str = str.trim()vor der weiteren Verarbeitung ein Leerzeichen eingeben .

Einfach können Sie dies versuchen:

• Verwenden Sie Integer.parseInt(your_string);diese Option , um ein Stringin zu konvertierenint
• Verwenden Sie Double.parseDouble(your_string);diese Option , um ein Stringin zu konvertierendouble

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

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

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

Für einen String-Builder und einen String-Puffer können Sie Folgendes verwenden:

Integer.parseInt(myBuilderOrBuffer.toString());

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

Stellen Sie sicher, dass die Zeichenfolge keine nicht numerischen Daten enthält.

Ich bin ein bisschen überrascht, dass niemand den Integer-Konstruktor erwähnt hat, der String als Parameter verwendet.

Hier ist es also:

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

Java 8 - Integer (String) .

Natürlich gibt der Konstruktor den Typ zurück Integerund eine Unboxing-Operation konvertiert den Wert in int.

Es ist wichtig zu erwähnen : Dieser Konstruktor ruft die parseIntMethode auf.

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

Verwenden Sie Integer.parseInt () und fügen Sie es in einen try...catchBlock ein, um Fehler zu behandeln, falls ein nicht numerisches Zeichen eingegeben wird, z.

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

Auf geht's

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

Es gibt sieben Möglichkeiten:

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

String number = "999";

1) Verwenden von Ints.tryParse:

int result = Ints.tryParse(number);

2) Verwenden von NumberUtils.createInteger:

Integer result = NumberUtils.createInteger(number);

3) Verwenden von NumberUtils.toInt:

int result = NumberUtils.toInt(number);

4) Verwenden von Integer.valueOf:

Integer result = Integer.valueOf(number);

5) Verwenden von Integer.parseInt:

int result = Integer.parseInt(number);

6) Verwenden von Integer.decode:

int result = Integer.decode(number);

7) Verwenden von Integer.parseUnsignedInt:

int result = Integer.parseUnsignedInt(number);

Eine Methode ist parseInt (String). Es gibt ein primitives int zurück:

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

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

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

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)

Dies ist ein vollständiges Programm mit allen positiven und negativen Bedingungen ohne Verwendung einer Bibliothek

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