Wie konvertiere ich einen String in Java in einen Int?

3026

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.

Unbekannter Benutzer
quelle
1
Beachten Sie übrigens, dass wenn der String null ist, der Aufruf: int i = Integer.parseInt (null); löst NumberFormatException aus, nicht NullPointerException.
Pavel Molchanov
2
Ich bin ein wenig überrascht, dass diese Frage so hoch bewertet werden sollte, wenn ein wichtiger Teil der Spezifikation fehlt: Was sollte passieren, wenn die Zeichenfolge NICHT nur Ziffern enthält? Zum Beispiel werden viele der Antworten gerne "-1" analysieren und -1 zurückgeben, aber wir wissen nicht, ob das akzeptabel ist.
Michael Kay

Antworten:

4086
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)
Rob Hruska
quelle
23
Zusätzlich zum Abfangen einer NumberFormatException sollte der Benutzer auch auf die Länge der Zeichenfolgen achten, die er übergibt. Wenn sie lang genug sind, um eine Ganzzahl zu überlaufen, sollten sie stattdessen Long :: parseLong verwenden.
Allison
6
@Allison, insbesondere wenn das BIGINT-Feld beispielsweise in einem automatisch inkrementierten PostgreSQL-Primärschlüsselfeld verwendet wird. Viel sicherer lange zu verwenden
Letholdrus
7
Sie könnten überprüfen, ob die Zeichenfolge zuerst eine Zahl ist: stackoverflow.com/questions/1102891/…
JPRLCol
Diese Methode löst auch eine Ausnahme aus, wenn die Zeichenfolge in Basis 10 keine analysierbare Ganzzahl ist. Verwenden Sie die überladene Methode, um in anderen Basen zu arbeiten. zB Integer.parseInt ("1001", 8); für Basis 8. Quelle .
Lokesh
2
Auch wenn die Verwendung von Guava in Kombination mit Java 8 optional sein kann, ist dies wahrscheinlich ein Overkill und nicht so präzise wie die Verwendung von NumberUtils.toInt (String str, int defaultValue) aus der Apache commons-lang- Bibliothek:int foo = NumberUtils.toInt(myString, 0);
Kunda
681

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.

lukastymo
quelle
80
Für die Unterschiede zwischen den beiden Methoden siehe diese Frage
Hertzsprung
19
valueOfMethode ist nurreturn valueOf(parseInt(string));
Paul Verest
@PaulVerest ich verstehe es nicht ... valueOfruft sich rekursiv auf?
idclev 463035818
1
@ user463035818 valueOf hat zwei Überladungen - für int und String. valueOf(String)wird implementiert, indem zuerst der String mit einem int in ein int analysiert parseInt(String)und dieses int dann mit using in eine Ganzzahl eingeschlossen wird valueOf(int). Keine Rekursion hier, weil valueOf(String)und valueOf(int)zwei völlig unterschiedliche Funktionen sind, auch wenn sie den gleichen Namen haben.
PhilipRoman
244

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.

Ali Akdurak
quelle
Wie kann ich "26263Hallo" analysieren? Ich möchte 26263 in diesem Fall extrahieren
idclev 463035818
1
@ user463035818 - Siehe docs.oracle.com/javase/8/docs/api/java/util/regex/… - Ein reguläres Ausdrucksmuster des "([0-9]+)"Willens "erfasst" die erste Sequenz einer oder mehrerer Ziffern eins bis neun. Schauen Sie sich die MatcherKlasse in diesem Paket an.
Mark Stewart
83

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;
}
Billz
quelle
22
Was ist, wenn die Eingabe größer als 2 ^ 32 ist? Was ist, wenn die Eingabe nicht numerische Zeichen enthält?
Yohm
87
Eines der Dinge, die ein Programmierer beim Eintritt in die Belegschaft lernen muss, wenn nicht vorher, ist, Räder nie neu zu erfinden. Dies mag eine unterhaltsame Übung sein, aber erwarten Sie nicht, dass Ihr Code die Codeüberprüfung besteht, wenn Sie dies in einer kommerziellen Umgebung tun.
Dawood ibn Kareem
43
-1 Entschuldigung, aber dies ist ein ziemlich schlechter Algorithmus mit vielen Einschränkungen, keiner Fehlerbehandlung und einigen seltsamen Anomalien (z. B. "" gibt eine Ausnahme, "-" erzeugt 0 und "+" erzeugt -5). Warum sollte jemand dies wählen Integer.parseInt(s)? - Ich sehe den Punkt darin als eine Interviewfrage, aber a) das bedeutet nicht, dass Sie es so machen würden (was der Fragesteller gefragt hat), und b) diese Antwort ist sowieso ein ziemlich schlechtes Beispiel.
SusanW
1
-1 denn was ist, wenn ich eine Basis 31 int analysieren möchte? Integer.parseInt (str, 31) ist ein Einzeiler, um dies zu tun. Leicht scherzhafter Kommentar, aber ernster Punkt darunter. Erfinde niemals Räder neu, wenn jemand anderes die Arbeit bereits erledigt hat
Nathan Adams
1
Dieser Code scheint aus einer bekannten Bibliothek für schnelle E / A in wettbewerbsorientierten Programmierwettbewerben adaptiert worden zu sein. In diesem Zusammenhang ist die Gültigkeit der Eingabedaten garantiert, und die Lösungen werden nach Geschwindigkeit bewertet. Es sollte schneller sein als Integer.parseInt weil es keine Validierung macht.
Kaya3
53

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

Ryboflavin
quelle
34
Sie möchten selten, dass 0 verwendet wird, wenn eine ungültige Zahl analysiert wird.
wnoise
4
Java wird standardmäßig auf Null gesetzt, wenn kein int-Feld für ein Objekt festgelegt ist. Insofern macht es also Sinn.
Ryboflavin
15
@ Ryboflavin Nein, das tut es nicht. Eine davon ist eine genau definierte Sprachsemantik, und die andere ist eine Ausnahme
ätherisch am
43

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
Eiche
quelle
8
Die Verwendung von Typ double zum Parsen einer Ganzzahl ist nicht nur in Bezug auf die Leistung eine schlechte Idee. Werte wie 0,2 sind periodische Zahlen in der Gleitkommadarstellung und können nicht genau dargestellt werden. Versuchen Sie System.out.println (0.1 + 0.2), um den Punkt zu sehen - das Ergebnis wird nicht 0.3 sein! Halten Sie sich besser an den Bibliothekscode, wo immer Sie können, in diesem Fall Integer.parseInt ().
ChrisB
10
Es ist nicht klar, welche Art von Problem diese Antwort zu lösen versucht, erstens, warum jemand jemals diese von Ihnen beschriebene Einschränkung haben sollte, zweitens, warum Sie sich eine ASCII-Tabelle ansehen müssen, da Sie sie einfach '0'für den Charakter verwenden können 48und niemals müssen sich mit seinem tatsächlichen numerischen Wert beschäftigen. Drittens macht der gesamte Umweg mit doubleWerten überhaupt keinen Sinn, da Sie durch zehn teilen, nur um danach mit zehn zu multiplizieren. Das Ergebnis ist einfach so, semilastdigit * 10 + lastdigitwie es in der Grundschule gelernt wurde, als das Dezimalsystem eingeführt wurde…
Holger
2
@Holger Diese Einschränkung wurde mir persönlich gegeben, als ich mit dem Programmieren anfing und auch, wenn ich ähnliche Interaktionen in einem Test schreiben musste (Stift / Papier). Es ist ungewöhnlich, aber es ist eine Methode, die leicht zu verstehen ist, und obwohl sie bei weitem nicht die effizienteste ist, funktioniert sie für kleine Projekte anständig genug. SO.SE soll allen helfen, nicht nur wenigen. Ich habe eine alternative Methode für diejenigen bereitgestellt, die zunächst lernen, wie man einen Pseudoalgorithmus erstellt und ihn in einen Algorithmus umwandelt, anstatt vorgefertigte Java-Ausdrücke zu verwenden. Obwohl ich vergessen habe, dass '0' cool ist
Oak
2
Dies ist keine gute Antwort. Die Frage lautet: "Wie konvertiere ich einen String in Java in einen Int?" nicht: "Wie löse ich dieses Hausaufgabenproblem mit willkürlichen Einschränkungen?" Es ist StackOverflow, nicht HomeworkOverflow.
DavidS
1
Sie haben den Grund für die Verwendung dieses neuartigen Ansatzes sehr deutlich gemacht, so dass dies an sich kein Problem darstellt. Sie betonen jedoch, dass Ihr Ansatz "keine sich wiederholenden Zyklen" verwendet , Ihr spezifisches Beispiel dieses Problem jedoch vollständig umgeht, indem die Lösung (für eine zweistellige Zahl) hart codiert wird, um nur semilastdigitund zu verwenden lastdigit. Wie würden Sie Ihre Lösung codieren, um "sich wiederholende Zyklen" zu vermeiden, wenn ich Ihnen eine gültige numerische Zeichenfolge beliebiger Länge (dh einen beliebigen Wert zwischen "-2147483648" und "2147483647") zur Verfügung
stellen
38

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();
ROMANIA_engineer
quelle
Schließlich! Jemand, der sich tatsächlich die Mühe macht, die Ergebnisse / Ausgaben der Conversions zu veröffentlichen! Können Sie auch einige mit "-" Zeichen hinzufügen?
not2qubit
29

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 .

Stefan Dollase
quelle
24

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?
Dennis Ahaus
quelle
1
Ja - und es gibt einen bösen Randfall um -2 ^ 31. Wenn Sie versuchen, 2 ^ 31 zu negieren, könnten Sie auf Schwierigkeiten
stoßen
24

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 .

Dmytro Shvechikov
quelle
22

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);
Giridhar Kumar
quelle
22

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

Lukas Bauer
quelle
Gibt der int-Maximalwert hier auch eine NumberFormatException aus?
Der Coding Wombat
Nein, der Maximalwert ist noch in Ordnung
Lukas Bauer
19

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));
        }
    }
}
fitorec
quelle
Sie können es einfacher machen:(int) Double.parseDouble(input.replaceAll("[^0-9\\.\\-]", ""));
Dávid Horváth
18

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) {
  ...
}
Vitalii Fedorenko
quelle
17

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.

Thijser
quelle
18
Dies führt dazu -42, dass analysiert wird als 42.
10
Ja, dies funktioniert nur für nicht negative Zahlen, die zunächst korrekt sind und daher diesen Ersetzungsschritt nicht benötigen. In jedem anderen Fall wird dieser Versuch, das Problem automatisch zu beheben, die Situation verschlimmern (wie fast jeder Versuch, etwas automatisch zu beheben). Wenn ich vorbeikomme "4+2", bekomme ich 42ohne Hinweis darauf, dass das, was ich versucht habe, falsch war. Der Benutzer hat den Eindruck, dass die Eingabe grundlegender Ausdrücke 4+2eine gültige Eingabe war, die Anwendung jedoch mit einem falschen Wert fortgesetzt wird. Außerdem ist der Typ Stringnicht string...
Holger
Oder ändern Sie die erste Zeile in -> string mystr = mystr.replaceAll ("[^ \\ d \\ -]", "");
Apm
13

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;
}
nxhoaf
quelle
10

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;
Alireza Fattahi
quelle
9

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.

manikant gautam
quelle
4
Die JOptionPane.showMessageDialog()Antwort auf die Vanille-Java-Frage einzugeben, macht keinen Sinn.
John Hascall
2
Integer.valueOf(String);gibt keinen Typ zurück int.
php_coder_3809625
9

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

Christian Ullenboom
quelle
9

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 .

Raman Sahasi
quelle
7

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
Vishal Yadav
quelle
Diese Antwort scheint nichts anderes hinzuzufügen als die Antworten, die Integer.parseInt empfehlen, das einige Jahre zuvor veröffentlicht wurde (das Konvertieren von String in Double wäre eine andere Frage ).
Bernhard Barker
7

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());
Aditya
quelle
6
int foo=Integer.parseInt("1234");

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

iKing
quelle
5
Dies entspricht genau der ausgewählten Antwort.
Steve Smith
5
Die Website hat keinen Wert darin, eine Antwort zu wiederholen, die jemand anderes FÜNF JAHRE vor Ihnen gepostet hat.
Dawood ibn Kareem
Dies ist bereits in der akzeptierten Antwort enthalten (veröffentlicht ca. 5 Jahre zuvor).
Peter Mortensen
6

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);
}
djm.im
quelle
5

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);
    }
 }
David
quelle
5

Auf geht's

String str="1234";
int number = Integer.parseInt(str);
print number;//1234
Shiva
quelle
Dies ist bereits in der akzeptierten Antwort enthalten (veröffentlicht ca. 5 Jahre zuvor).
Peter Mortensen
5

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);
Santosh Jadi
quelle
NumberUtils behandelt auch null und leere Szenarien.
Sundararaj Govindasamy
5

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);
Pankaj Mandale
quelle
Wird dies nicht in früheren Antworten behandelt?
Peter Mortensen
4

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)
Rajeev Ranjan
quelle
4

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;
    }
}
Anup Gupta
quelle
2
Das Rad muss nicht neu erfunden werden Integer.parseInt. Verwenden Sie es einfach .
Dorian Gray
@TobiasWeimer ja, wir können, aber dies ist ohne Verwendung der Bibliothek
Anup Gupta
@TobiasWeimer, einige Leute brauchen dies, um auf Library zu verzichten.
Anup Gupta
5
Nein, niemand braucht es, da es sich um eine Funktion im JDK handelt, nicht um ein Plugin eines Drittanbieters.
Dorian Gray