Jak przekonwertować ciąg na int w Javie?


3026

Jak mogę przekonwertować Stringna intJava w Java?

Mój ciąg zawiera tylko liczby i chcę zwrócić liczbę, którą reprezentuje.

Na przykład, biorąc pod uwagę ciąg, "1234"wynikiem powinna być liczba 1234.


1
Nawiasem mówiąc, pamiętaj, że jeśli łańcuch jest pusty, wywołanie: int i = Integer.parseInt (null); zgłasza NumberFormatException, a nie NullPointerException.
Pavel Molchanov,

2
Jestem trochę zaskoczony, że to pytanie powinno być tak wysoko ocenione, gdy brakuje ważnej części specyfikacji: co powinno się stać, jeśli ciąg NIE zawiera tylko cyfr? Na przykład wiele odpowiedzi z powodzeniem parsuje „-1” i zwraca -1, ale nie wiemy, czy jest to dopuszczalne.
Michael Kay,

Odpowiedzi:


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

Jeśli spojrzysz na dokumentację Java , zauważysz, że „catch” polega na tym, że ta funkcja może rzucać a NumberFormatException, co oczywiście musisz obsługiwać:

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

(Domyślnie ten zabieg ma zniekształcony numer 0, ale możesz zrobić coś innego, jeśli chcesz).

Alternatywnie możesz użyć Intsmetody z biblioteki Guava, która w połączeniu z Javą 8 Optionalzapewnia potężny i zwięzły sposób konwersji łańcucha na int:

import com.google.common.primitives.Ints;

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

23
Oprócz przechwytywania wyjątku NumberFormatException użytkownik powinien również uważać na długość przekazywanych ciągów; jeśli są wystarczająco długie, aby przepełnić liczbę całkowitą, mogą rozważyć użycie zamiast tego opcji Long :: parseLong.
Allison

6
@Allison, szczególnie jeśli używasz na przykład pola BIGINT w polu klucza podstawowego automatycznie zwiększanego przez PostgreSQL. Znacznie bezpieczniejsze w użyciu
Letholdrus

7
Możesz sprawdzić, czy ciąg jest najpierw
liczbą

Ta metoda zgłasza również wyjątek, gdy ciąg znaków nie jest liczbą całkowitą możliwą do przetworzenia w bazie 10. Użyj przeciążonej metody do pracy w innych bazach. np. Integer.parseInt („1001”, 8); dla podstawy 8. Źródło .
lokesh

2
Ponadto, chociaż używanie Guava w połączeniu z opcją Java 8 może być potężne, prawdopodobnie jest to przesada i nie jest tak zwięzłe, jak używanie NumberUtils.toInt (String str, int defaultValue) z biblioteki commache -lang Apache :int foo = NumberUtils.toInt(myString, 0);
Kunda

681

Oto na przykład dwa sposoby:

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

Istnieje niewielka różnica między tymi metodami:

  • valueOf zwraca nową lub buforowaną instancję java.lang.Integer
  • parseIntzwraca prymitywne int.

To samo dotyczy wszystkich przypadków: Short.valueOf/ parseShort, Long.valueOf/ parseLongitd.


80
Różnice między tymi dwiema metodami można znaleźć w tym pytaniu
hertzsprung

19
valueOfmetoda jest po prostureturn valueOf(parseInt(string));
Paul Verest

@PaulVerest Nie rozumiem ... valueOfnazywa się rekurencyjnie?
idclev 463035818

1
@ user463035818 valueOf ma dwa przeciążenia - dla int i String. valueOf(String)jest implementowany przez parsowanie String do int za pomocą, parseInt(String)a następnie zawijanie int w Integer za pomocą valueOf(int). Nie rekurencji tutaj, bo valueOf(String)i valueOf(int)to dwie zupełnie różne funkcje, nawet jeśli mają taką samą nazwę.
PhilipRoman

244

Cóż, bardzo ważnym punktem do rozważenia jest to, że parser liczb całkowitych zgłasza NumberFormatException, jak stwierdzono w 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.
}

Ważne jest, aby obsłużyć ten wyjątek podczas próby uzyskania wartości całkowitych z podzielonych argumentów lub dynamicznego analizowania czegoś.


jak mogę parsować „26263Hello”? Chcę wyodrębnić 26263 w tym przypadku
idclev 463035818

1
@ user463035818 - Zobacz docs.oracle.com/javase/8/docs/api/java/util/regex/… - wzorzec wyrażenia regularnego "([0-9]+)"„przechwyci” pierwszą sekwencję jednej lub więcej cyfr od jednego do dziewięciu. Spójrz na Matcherklasę w tym pakiecie.
Mark Stewart

83

Zrób to ręcznie:

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

22
Co jeśli wejście jest większe niż 2 ^ 32? Co jeśli wejście zawiera znaki nienumeryczne?
yohm

87
Jedną z rzeczy, których programista musi się nauczyć przy dołączaniu do siły roboczej, jeśli nie wcześniej, to nigdy nie wymyślać na nowo kół. To może być zabawne ćwiczenie, ale nie oczekuj, że Twój kod przejdzie weryfikację kodu, jeśli robisz coś takiego w warunkach komercyjnych.
Dawood ibn Kareem

43
-1 Przepraszam, ale jest to dość słaby algorytm, z wieloma ograniczeniami, bez obsługi błędów i z pewnymi dziwnymi anomaliami (np. „” Daje wyjątek, „-” spowoduje 0, a „+” da -5). Dlaczego ktoś miałby to wybierać Integer.parseInt(s)? - Widzę sens tego pytania jako wywiadu, ale a) to nie oznacza, że ​​zrobiłbyś to w ten sposób (o to pytał pytający), i b) i tak odpowiedź jest dość złym przykładem.
SusanW,

1
-1 ponieważ co jeśli chcę przeanalizować bazę 31 int? Integer.parseInt (str, 31) to jedna linijka, aby to zrobić. Nieco żartobliwy komentarz, ale poważna uwaga poniżej. Nigdy nie wymyślaj na nowo kół, jeśli ktoś już włożył je do pracy
Nathan Adams

1
Ten kod wygląda na zaadaptowany ze znanej biblioteki do szybkiego IO w konkurencyjnych konkursach programistycznych. W tym kontekście gwarantowane są dane wejściowe, a rozwiązania są oceniane według prędkości. Powinno być szybsze niż Integer.parseInt ponieważ nie sprawdza poprawności.
kaya3

53

Alternatywnym rozwiązaniem jest użycie NumberUtils Apache Commons :

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

Narzędzie Apache jest dobre, ponieważ jeśli łańcuch ma nieprawidłowy format liczb, wówczas zawsze zwracane jest 0. W ten sposób oszczędzasz ci try catch catch.

Apache NumberUtils API Version 3.4


34
Rzadko chcesz, aby 0 było używane podczas analizowania nieprawidłowego numeru.
wnoise

4
Zero jest tym, czego java używa domyślnie, jeśli pole int na obiekcie nie jest ustawione. W związku z tym ma to sens.
Ryboflavin 19.04.16

15
@Ryboflavin Nie, nie ma. Jeden z nich jest dobrze zdefiniowanym semantycznym językiem, a drugi jest wyjątkiem
eteryczny

43

Obecnie wykonuję zadanie na studia, gdzie nie mogę używać niektórych wyrażeń, takich jak powyższe, i patrząc na tabelę ASCII, udało mi się to zrobić. Jest to o wiele bardziej złożony kod, ale może pomóc innym, którzy są ograniczeni tak jak ja.

Pierwszą rzeczą do zrobienia jest otrzymanie danych wejściowych, w tym przypadku ciągu cyfr; Zadzwonię String number, a w tym przypadku zilustruję to za pomocą liczby 12String number = "12";

Kolejnym ograniczeniem był fakt, że nie mogłem używać powtarzalnych cykli, dlatego też nie można użyć forcyklu (który byłby idealny). To nas ogranicza, ale z drugiej strony taki jest cel. Ponieważ potrzebowałem tylko dwóch cyfr (biorąc dwie ostatnie cyfry), prosty charAtto rozwiązał:

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

Mając kody, wystarczy spojrzeć na tabelę i dokonać niezbędnych zmian:

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

Dlaczego podwójny? Cóż, z powodu naprawdę „dziwnego” kroku. Obecnie mamy dwa podwójne, 1 i 2, ale musimy je zmienić na 12, nie możemy wykonać żadnej operacji matematycznej.

Dzielimy ten ostatni (lastdigit) przez 10 w sposób 2/10 = 0.2(stąd podwójny) w następujący sposób:

 lastdigit = lastdigit/10;

To tylko zabawa z liczbami. Zamienialiśmy ostatnią cyfrę na dziesiętną. Ale teraz spójrz na to, co się dzieje:

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

Nie wchodząc zbytnio w matematykę, po prostu izolujemy jednostki od cyfr liczby. Widzicie, ponieważ rozważamy tylko 0-9, dzielenie przez wielokrotność 10 jest jak tworzenie „pudełka”, w którym je przechowujesz (pomyśl o tym, kiedy twój nauczyciel pierwszej klasy wyjaśnił ci, czym była jednostka i sto). Więc:

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

I proszę bardzo. Przekształciłeś ciąg cyfr (w tym przypadku dwie cyfry) w liczbę całkowitą złożoną z tych dwóch cyfr, biorąc pod uwagę następujące ograniczenia:

  • Brak powtarzalnych cykli
  • Brak wyrażeń „magicznych”, takich jak parsowanie

8
Użycie typu double do parsowania liczby całkowitej jest nie tylko złym pomysłem pod względem wydajności. Wartości takie jak 0,2 są liczbami okresowymi w reprezentacji zmiennoprzecinkowej i nie można ich dokładnie przedstawić. Spróbuj System.out.println (0,1 + 0,2), aby zobaczyć punkt - wynik nie będzie 0,3! Lepiej trzymaj się kodu biblioteki, gdziekolwiek możesz, w tym przypadku Integer.parseInt ().
ChrisB,

10
Nie jest jasne, jakiego rodzaju problem próbuje rozwiązać ta odpowiedź, po pierwsze, dlaczego ktokolwiek powinien mieć takie ograniczenie, które opisujesz, po drugie, dlaczego musisz spojrzeć na tabelę ASCII, której możesz po prostu użyć '0'dla postaci zamiast 48i nigdy nie musisz przeszkadza jej faktyczna wartość liczbowa. Po trzecie, cały objazd z doublewartościami nie ma żadnego sensu, ponieważ dzielisz przez dziesięć, aby po prostu pomnożyć przez dziesięć. Rezultat jest po prostu taki, semilastdigit * 10 + lastdigitjak w szkole podstawowej, kiedy wprowadzono system dziesiętny…
Holger

2
@ Holger Osobiście otrzymałem to ograniczenie, kiedy zaczynałem programowanie, a także kiedy musiałem pisać (długopis / papier) podobne interakcje w teście. Jest to rzadkie, ale jest to metoda, która jest łatwa do zrozumienia i choć nie jest najskuteczniejsza z odległości, jest to metoda, która działa wystarczająco przyzwoicie w przypadku małych projektów. SO.SE ma pomóc każdemu, nie tylko nielicznym. Podałem alternatywną metodę dla tych, którzy zaczynają od nauki tworzenia pseudo-algorytmu i przekształcania go w algorytm zamiast korzystania z gotowych wyrażeń Java. Chociaż zapomniałem, że „0” jest fajne
Oak

2
To nie jest dobra odpowiedź. Pytanie brzmi: „Jak przekonwertować ciąg znaków na int w Javie?” nie „Jak rozwiązać ten problem z zadaniami domowymi z arbitralnymi ograniczeniami?” To StackOverflow, a nie HomeworkOverflow.
DavidS

1
Wyjaśniłeś powód zastosowania tego nowatorskiego podejścia bardzo jasno, więc samo w sobie nie stanowi problemu. Podkreślasz jednak, że twoje podejście wykorzystuje „bez powtarzających się cykli” , ale twój konkretny przykład omija ten problem całkowicie przez zakodowanie na stałe rozwiązania (dla liczby dwucyfrowej), aby użyć tylko semilastdigiti lastdigit. Jak kodowałbyś swoje rozwiązanie, aby uniknąć „powtarzających się cykli”, gdybym podał ci prawidłowy ciąg liczbowy o dowolnej długości (tj. Dowolna wartość między „-2147483648” a „2147483647”?)
skomisa

38

Integer.decode

Możesz także użyć public static Integer decode(String nm) throws NumberFormatException.

Działa również dla bazy 8 i 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

Jeśli chcesz intzamiast tego Integermożesz użyć:

  1. Rozpakowanie:

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

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

Wreszcie! Ktoś, kto faktycznie zadaje sobie trud opublikowania wyników / wyników konwersji! Czy możesz dodać także znaki „-”?
not2qubit

29

Ilekroć istnieje najmniejsza możliwość, że dany Ciąg nie zawiera liczby całkowitej, musisz poradzić sobie z tym szczególnym przypadkiem. Niestety, standardowe metody Java Integer::parseInti Integer::valueOfwrzuć a, NumberFormatExceptionaby zasygnalizować ten szczególny przypadek. Dlatego musisz użyć wyjątków do kontroli przepływu, co jest ogólnie uważane za zły styl kodowania.

Moim zdaniem ten szczególny przypadek powinien zostać rozwiązany poprzez zwrócenie pustego Optional<Integer>. Ponieważ Java nie oferuje takiej metody, używam następującego opakowania:

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

Przykładowe użycie:

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

Mimo że nadal korzysta się wewnętrznie z wyjątków do kontroli przepływu, kod użycia staje się bardzo czysty. Ponadto można wyraźnie rozróżnić przypadek, w którym -1jest analizowany jako poprawna wartość, oraz przypadek, w którym nie można przeanalizować niepoprawnego ciągu znaków.


24

Konwersja ciągu na liczbę int jest bardziej skomplikowana niż zwykła konwersja liczby. Zastanawiasz się nad następującymi kwestiami:

  • Czy ciąg zawiera tylko cyfry 0–9 ?
  • Co jest z - / + przed lub po ciągu? Czy to możliwe (w odniesieniu do numerów księgowych)?
  • Co słychać w MAX _- / MIN_INFINITY? Co się stanie, jeśli ciąg znaków to 9999999999999999999999? Czy maszyna może traktować ten ciąg jako int?

1
Tak - i jest nieprzyjemna skrzynka około -2 ^ 31. Jeśli spróbujesz zanegować 2 ^ 31, możesz napotkać trudności ......
SusanW

24

Metody, aby to zrobić:

 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 tworzy obiekt Integer, wszystkie inne metody - pierwotne int.

Ostatnie 2 metody z commons-lang3 i duży artykuł na temat konwersji tutaj .


22

Możemy użyć parseInt(String str)metody Integerklasy opakowania do konwersji wartości String na wartość całkowitą.

Na przykład:

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

IntegerKlasa zapewnia również valueOf(String str)metodę:

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

Możemy również skorzystać toInt(String strValue)z NumberUtils Utility klasy do konwersji:

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

22

Zastosowanie Integer.parseInt(yourString).

Pamiętaj o następujących rzeczach:

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

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

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

Integer.parseInt(" 1"); // Wyjątek (puste miejsce)

Integer.parseInt("2147483648");// Wyjątek (liczba całkowita jest ograniczona do maksymalnej wartości 2 147 483 647)

Integer.parseInt("1.1");// Wyjątek ( . Lub , lub cokolwiek nie jest dozwolone)

Integer.parseInt(""); // Wyjątek (nie 0 czy coś)

Istnieje tylko jeden rodzaj wyjątku: NumberFormatException


Czy int maksymalna wartość tutaj daje również NumberFormatException?
The Coding Wombat

Nie, maksymalna wartość jest nadal w porządku
Lukas Bauer

19

Mam rozwiązanie, ale nie wiem, jak skuteczne jest. Ale działa dobrze i myślę, że można to poprawić. Z drugiej strony wykonałem kilka testów z JUnit, które krok poprawnie. Dołączyłem funkcję i testowanie:

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

Testowanie za pomocą 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));
        }
    }
}

Możesz to zrobić prościej:(int) Double.parseDouble(input.replaceAll("[^0-9\\.\\-]", ""));
Dávid Horváth,


17

Możesz także rozpocząć od usunięcia wszystkich znaków nienumerycznych, a następnie przeanalizowania liczby całkowitej:

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

Ale ostrzegam, że działa to tylko dla liczb nieujemnych.


18
Spowoduje to, że -42zostanie przeanalizowany jako 42.

10
Tak, działa to tylko dla liczb nieujemnych, które są poprawne na początku, a zatem nie wymagają tego kroku zastępowania. W każdym innym przypadku ta próba automatycznego naprawienia pogorszy sytuację (jak prawie każda próba automatycznej naprawy). Jeśli przejdę "4+2", 42w rezultacie uzyskam bez żadnej wskazówki, że to, co próbowałem zrobić, było błędne. Użytkownik będzie miał wrażenie, że wprowadzenie podstawowych wyrażeń, takich jak 4+2prawidłowe wprowadzanie, ale aplikacja kontynuuje z nieprawidłową wartością. Poza tym typem Stringnie jest string
Holger

Lub zmień pierwszy wiersz na -> string mystr = mystr.replaceAll ("[^ \\ d \\ -]", "");
apm

13

Oprócz poprzednich odpowiedzi chciałbym dodać kilka funkcji. Oto wyniki podczas ich używania:

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
}

Realizacja:

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

10

Jak wspomniano, Apache Commons NumberUtilsmoże to zrobić. Zwraca, 0jeśli nie może przekonwertować ciągu na wartość int.

Możesz także zdefiniować własną wartość domyślną:

NumberUtils.toInt(String str, int defaultValue)

Przykład:

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;

9

Możesz użyć tego kodu również z pewnymi środkami ostrożności.

  • Opcja nr 1: jawnie obsłuż wyjątek, na przykład wyświetlając okno dialogowe komunikatu, a następnie zatrzymaj wykonywanie bieżącego przepływu pracy. Na przykład:

    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;
    }
  • Opcja # 2: Zresetuj zmienną, której dotyczy problem, jeśli przepływ wykonania może być kontynuowany w przypadku wyjątku. Na przykład z pewnymi modyfikacjami w bloku catch

    catch (NumberFormatException ex) {
        integerValue = 0;
    }

Użycie stałej łańcuchowej do porównania lub innego rodzaju obliczeń jest zawsze dobrym pomysłem, ponieważ stała nigdy nie zwraca wartości zerowej.


4
Podanie JOptionPane.showMessageDialog()odpowiedzi na waniliowe pytanie Java nie ma sensu.
John Hascall,

2
Integer.valueOf(String);nie zwraca typu int.
php_coder_3809625

9

Możesz użyć new Scanner("1244").nextInt(). Lub zapytaj, czy istnieje nawet int:new Scanner("1244").hasNextInt()


9

W konkursach programistycznych, w których masz pewność, że liczba będzie zawsze prawidłową liczbą całkowitą, możesz napisać własną metodę do analizy danych wejściowych. Spowoduje to pominięcie całego kodu związanego z walidacją (ponieważ tego nie potrzebujesz) i będzie nieco bardziej wydajne.

  1. Dla prawidłowej dodatniej liczby całkowitej:

    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. Dla liczb całkowitych dodatnich i ujemnych:

    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. Jeśli spodziewasz się spacji przed tymi liczbami lub po nich, pamiętaj, aby zrobić to str = str.trim()przed dalszym przetwarzaniem.


7

Po prostu możesz spróbować:

  • Użyj, Integer.parseInt(your_string);aby przekonwertować Stringnaint
  • Użyj, Double.parseDouble(your_string);aby przekonwertować Stringnadouble

Przykład

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

Ta odpowiedź nie wydaje się dodawać niczego poza odpowiedziami zalecającymi Integer.parseInt opublikowaną kilka lat wcześniej (konwersja String na double byłaby innym pytaniem ).
Bernhard Barker,

7

Do normalnego ciągu możesz użyć:

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

W przypadku konstruktora ciągów i bufora ciągów można użyć:

Integer.parseInt(myBuilderOrBuffer.toString());


6

Jestem trochę zaskoczony, że nikt nie wspomniał o konstruktorze liczb całkowitych, który przyjmuje parametr String jako parametr.

Oto on:

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

Java 8 - liczba całkowita (ciąg) .

Oczywiście konstruktor zwróci typ Integer, a operacja rozpakowania konwertuje wartość na int.


Należy wspomnieć : ten konstruktor wywołuje parseIntmetodę.

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

5

Użyj Integer.parseInt () i umieść go w try...catchbloku, aby obsłużyć wszelkie błędy na wypadek wprowadzenia znaku nienumerycznego, na przykład

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


5

Można to zrobić na siedem sposobów:

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

String number = "999";

1) Używając Ints.tryParse:

int result = Ints.tryParse(number);

2) Używając NumberUtils.createInteger:

Integer result = NumberUtils.createInteger(number);

3) Używając NumberUtils.toInt:

int result = NumberUtils.toInt(number);

4) Używając Integer.valueOf:

Integer result = Integer.valueOf(number);

5) Używając Integer.parseInt:

int result = Integer.parseInt(number);

6) Używanie Integer.decode:

int result = Integer.decode(number);

7) Używanie Integer.parseUnsignedInt:

int result = Integer.parseUnsignedInt(number);

NumberUtils obsługuje również scenariusze zerowe i puste.
Sundararaj Govindasamy

5

Jedną z metod jest parseInt (String). Zwraca prymitywną int:

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

Druga metoda to valueOf (String) i zwraca nowy obiekt Integer ():

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

Czy nie uwzględniono tego w poprzednich odpowiedziach?
Peter Mortensen

4

Możesz użyć dowolnego z poniższych:

  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)

4

Jest to kompletny program ze wszystkimi dodatnimi i ujemnymi warunkami bez korzystania z biblioteki

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

2
Nie trzeba wymyślać koła od nowa, wystarczy użyć Integer.parseInt.
Dorian Gray

@TobiasWeimer tak, możemy to zrobić, ale odbywa się to bez korzystania z biblioteki
Anup Gupta

@TobiasWeimer, niektórzy ludzie potrzebują tego, jak to zrobić bez korzystania z biblioteki.
Anup Gupta,

5
Nie, nikt tego nie potrzebuje, ponieważ jest to funkcja wewnątrz JDK, a nie wtyczka innej firmy.
Dorian Gray
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.