Jak przekonwertować ciąg na int w Javie?

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.

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)

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.

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ś.

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

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

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

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

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.

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?

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 .

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

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

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

Google Guava ma tryParse (ciąg) , który zwraca, nulljeśli ciąg nie może zostać przeanalizowany, na przykład:

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

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.

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

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;

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.

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

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.

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

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

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

Upewnij się, że w łańcuchu nie ma danych nienumerycznych.

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

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

No to ruszamy

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

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

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

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)

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