it-swarm.com.ru

Как мне преобразовать строку в int в Java?

Как я могу преобразовать String в int в Java?

Моя строка содержит только цифры, и я хочу вернуть число, которое она представляет.

Например, если задана строка "1234", результатом должно быть число 1234.

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

Если вы посмотрите на документацию по Java вы заметите "уловку" в том, что эта функция может генерировать переменную NumberFormatException, с которой вам, конечно, придется обращаться:

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

(По умолчанию это неправильное число 0, но вы можете сделать что-нибудь еще, если хотите.)

Кроме того, вы можете использовать метод Ints из библиотеки Guava, который в сочетании с Optional в Java 8 обеспечивает мощный и краткий способ преобразования строки в int:

import com.google.common.primitives.Ints;

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

Например, вот два способа:

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

Существует небольшая разница между этими методами: 

  • valueOf возвращает новый или кэшированный экземпляр Java.lang.Integer
  • parseInt возвращает примитив int

То же самое для всех случаев: Short.valueOf/parseShort, Long.valueOf/parseLong и т.д.

629
smas

Что ж, очень важный момент, который следует учитывать, заключается в том, что синтаксический анализатор Integer генерирует NumberFormatException, как указано в 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.
}

Важно обработать это исключение при попытке получить целочисленные значения из разделенных аргументов или динамического анализа чего-либо.

230
Ali Akdurak

Сделайте это вручную:

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

В настоящее время я выполняю задание для колледжа, где я не могу использовать определенные выражения, такие как приведенные выше, и, просмотрев таблицу ASCII, мне удалось это сделать. Это гораздо более сложный код, но он может помочь другим, которые ограничены, как я.

Первое, что нужно сделать, - это получить ввод, в данном случае, строку цифр; Я назову это String number, и в этом случае я приведу пример, используя номер 12, поэтому String number = "12";

Другим ограничением было то, что я не мог использовать повторяющиеся циклы, поэтому цикл for (который был бы идеален) также нельзя использовать. Это немного ограничивает нас, но опять же, это цель. Поскольку мне нужны были только две цифры (последние две цифры), простая charAt разрешила это:

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

Имея коды, нам просто нужно посмотреть на таблицу и внести необходимые коррективы:

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

Теперь, почему двойной? Ну, из-за действительно "странного" шага. В настоящее время у нас есть два типа double, 1 и 2, но нам нужно превратить его в 12, мы не можем выполнить математическую операцию.

Мы делим последнее (lastdigit) на 10 в стиле 2/10 = 0.2 (следовательно, почему double) следующим образом:

 lastdigit = lastdigit/10;

Это просто игра с числами. Мы превращали последнюю цифру в десятичную. Но теперь посмотрим, что происходит:

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

Не вдаваясь в математику, мы просто выделяем единицы из цифр числа. Видите ли, поскольку мы рассматриваем только 0-9, деление на кратное 10 похоже на создание «коробки», в которой вы храните ее (вспомните, когда ваш учитель первого класса объяснил вам, что такое единица и сотня). Так:

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

И вот, пожалуйста. Вы превратили строку цифр (в данном случае две цифры) в целое число, состоящее из этих двух цифр, с учетом следующих ограничений:

  • Нет повторяющихся циклов
  • Нет "магических" выражений, таких как parseInt
42
Oak

Альтернативным решением является использование Apache Commons ' NumberUtils:

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

Утилита Apache хороша, потому что если строка имеет недопустимый формат числа, то всегда возвращается 0. Таким образом, вы сэкономите блок try catch.

Apache NumberUtils API версии 3.4

40
Ryboflavin

Integer.decode

Вы также можете использовать public static Integer decode(String nm) throws NumberFormatException.

Это также работает для базы 8 и 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

Если вы хотите получить int вместо Integer, вы можете использовать:

  1. Распаковка:

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

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

Всякий раз, когда есть малейшая вероятность того, что данная строка не содержит целое число, вы должны обработать этот особый случай. К сожалению, стандартные методы Java Integer::parseInt и Integer::valueOf выдают NumberFormatException, чтобы сигнализировать об этом особом случае. Таким образом, вы должны использовать исключения для управления потоком, что обычно считается плохим стилем кодирования.

На мой взгляд, этот особый случай должен быть обработан путем возврата Optional<Integer>. Поскольку Java не предлагает такой метод, я использую следующую оболочку:

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

Использование:

// prints 1234
System.out.println(tryParseInteger("1234").orElse(-1));
// prints -1
System.out.println(tryParseInteger("foobar").orElse(-1));

Хотя это все еще использует исключения для управления потоком внутри, код использования становится очень чистым.

25
Stefan Dollase

Преобразование строки в int сложнее, чем просто преобразование числа. Вы думаете о следующих проблемах:

  • Строка содержит только цифры 0-9?
  • Что случилось с -/+ до или после строки? Возможно ли это (имеется в виду учетные номера)?
  • Что случилось с MAX _-/MIN_INFINITY? Что произойдет, если строка 99999999999999999999? Может ли машина обрабатывать эту строку как int?
23
Dennis Ahaus

Методы для этого:

 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 выдает объект Integer, все остальные методы - примитив int.

Последние 2 метода из commons-lang3 и большая статья о конвертации здесь .

22
Dmytro Shvechikov

Мы можем использовать метод parseInt(String str) класса-оболочки Integer для преобразования строкового значения в целочисленное значение.

Например:

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

Класс Integer также предоставляет метод valueOf(String str):

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

Мы также можем использовать toInt(String strValue) of NumberUtils Utility Class для преобразования:

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

Используйте Integer.parseInt(yourString)

Помните следующие вещи:

Integer.parseInt("1");/ хорошо

Integer.parseInt("-1"); // хорошо

Integer.parseInt("+1"); // хорошо

Integer.parseInt(" 1"); // Исключение (пробел)

Integer.parseInt("2147483648"); // Исключение (целое число ограничено максимальным значением из 2 147 483 647)

Integer.parseInt("1.1"); // Исключение (_ /. или , или все, что не разрешено)

Integer.parseInt(""); // Исключение (не 0 или что-то)

Существует только один тип исключения: NumberFormatException

19
Lukas Bauer

У меня есть решение, но я не знаю, насколько оно эффективно. Но это работает хорошо, и я думаю, что вы могли бы улучшить это. С другой стороны, я сделал пару тестов с JUnit , что правильно. Я прикрепил функцию и тестирование:

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

Тестирование с помощью 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));
        }
    }
}
19
fitorec

Просто для удовольствия: Вы можете использовать Optional в Java 8 для преобразования String в Integer:

String str = "123";
Integer value = Optional.of(str).map(Integer::valueOf).get();
// Will return the integer value of the specified string, or it
// will throw an NPE when str is null.

value = Optional.ofNullable(str).map(Integer::valueOf).orElse(-1);
// Will do the same as the code above, except it will return -1
// when srt is null, instead of throwing an NPE.

Здесь мы просто объединяем Integer.valueOf и Optinal. Вероятно, могут быть ситуации, когда это полезно - например, когда вы хотите избежать нулевых проверок. Код до Java 8 будет выглядеть так:

Integer value = (str == null) ? -1 : Integer.parseInt(str);
17
Anton Balaniuc

У Guava есть tryParse (String) , который возвращает null, если строка не может быть проанализирована, например:

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

Вы также можете начать с удаления всех нечисловых символов, а затем проанализировать int:

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

Но имейте в виду, что это работает только для неотрицательных чисел. 

14
Thijser

Помимо этих ответов, я хотел бы добавить несколько функций: 

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

И вот результаты, пока вы их запускаете: 

  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
  }
12
nxhoaf

В соревнованиях по программированию, где вы уверены, что число всегда будет действительным целым числом, вы можете написать свой собственный метод для анализа ввода. Это пропустит весь код, связанный с проверкой (так как он вам не нужен), и будет немного более эффективным.

  1. Для действительного положительного целого числа:

    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. Для положительных и отрицательных целых чисел:

    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. Если вы ожидаете пробел до или после этих чисел, , Затем убедитесь, что перед выполнением дальнейшей обработки сделайте str = str.trim().

9
Raman Sahasi

Как уже упоминалось, Apache Commons NumberUtils может это сделать. Который возвращает 0, если не может преобразовать строку в int.

Вы также можете определить свое собственное значение по умолчанию.

NumberUtils.toInt(String str, int defaultValue)

пример:

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
Alireza Fattahi

Вы также можете использовать этот код с некоторыми мерами предосторожности.

  • Вариант № 1: явная обработка исключения, например, показ диалогового окна сообщения, а затем остановка выполнения текущего рабочего процесса. Например:

    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;
    }
    
  • Вариант № 2: Сброс уязвимой переменной, если поток выполнения может продолжаться в случае исключения. Например, с некоторыми изменениями в блоке catch

    catch (NumberFormatException ex) {
        integerValue = 0;
    }
    

Использование строковой константы для сравнения или любого рода вычислений всегда является хорошей идеей, потому что константа никогда не возвращает нулевое значение.

9
manikant gautam

Вы можете использовать new Scanner("1244").nextInt(). Или спросите, существует ли даже int: new Scanner("1244").hasNextInt()

9
Christian Ullenboom
int foo=Integer.parseInt("1234");

Убедитесь, что в строке нет нечисловых данных.

7
iKing

Для нормальной строки вы можете использовать:

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

Для String Builder и String buffer вы можете использовать:

Integer.parseInt(myBuilderOrBuffer.toString());
7
Aditya

Просто вы можете попробовать это:

  • Используйте Integer.parseInt(your_string); для преобразования String в int
  • Используйте Double.parseDouble(your_string); для преобразования String в double

Пример

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
7
Vishal Yadav

Вот так

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

Я немного удивлен, что никто не упомянул конструктор Integer, который принимает String в качестве параметра.
Итак, вот: 

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

Java 8 - Integer (String)

Конечно, конструктор вернет тип Integer, а операция распаковки преобразует значение в int


Важно упомянуть
Этот конструктор вызывает метод parseInt

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

Используйте Integer.parseInt () и поместите его в блок try...catch для обработки любых ошибок на случай, если введен нечисловой символ, например,

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
David

Один метод parseInt (String) возвращает примитив int

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

Второй метод - valueOf (String) возвращает новый объект Integer ().

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

Это полная программа со всеми положительными и отрицательными условиями без использования библиотеки  

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;
     }
    }
4
Anup Gupta

Integer.parseInt(myString); - использование класса-обёртки

3
Phani Kumar

Может быть сделано 5 способов:

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

1) Использование Ints.tryParse:

String number = "999";
int result = Ints.tryParse(number);

2) Использование NumberUtils.createInteger:

String number = "999";
Integer result = NumberUtils.createInteger(number);

3) Использование NumberUtils.toInt:

String number = "999";
int result = NumberUtils.toInt(number);

4) Использование Integer.valueOf:

String number = "999";
Integer result = Integer.valueOf(number);

5) Использование Integer.parseInt:

String number = "999";
int result = Integer.parseInt(number);
3
Santosh Jadi

Кстати, имейте в виду, что если строка имеет значение null, вызов:

int i = Integer.parseInt(null);

генерирует NumberFormatException, а не NullPointerException.

3
Pavel Molchanov

Вы можете использовать любое из следующих действий: 

  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)
2
Rajeev Ranjan

импорт Java.util. *;

открытый класс strToint {

    public static void main(String[] args){

            String str = "123";

            byte barr[] = str.getBytes();

            System.out.println(Arrays.toString(barr));
            int result=0;
            for(int i=0;i<barr.length;i++){
                    //System.out.print(barr[i]+" ");
                    int ii = barr[i];
                    char a = (char)ii;
                    int no = Character.getNumericValue(a);
                    result=result*10+no;
                    System.out.println(result);

            }
            System.out.println("result:"+result);
    }

}

2
Abhijeet Kale

public static int parseInt (String s) генерирует NumberFormatException

вы можете использовать Integer.parseInt(), чтобы преобразовать строку в int.

преобразовать строку 20 в примитив int.

    String n = "20";
    int r = Integer.parseInt(n);//returns a primitive int       
    System.out.println(r);

Результат-20

если строка не содержит анализируемого целого числа. это будет брошено NumberFormatException

String n = "20I";// throwns NumberFormatException
int r = Integer.parseInt(n);
System.out.println(r);

public static Integer valueOf (String s) выдает NumberFormatException

вы можете использовать Integer.valueOf(), в этом он вернет объект Integer.

String n = "20";
Integer r = Integer.valueOf(n); //returns a new Integer() object.   
System.out.println(r);

Результат-20

Рекомендации https://docs.Oracle.com/en/

1
Poorna Senani Gamage

Вот некоторые из способов преобразования String в Int:

  1. вы можете использовать Integer.parseInt():

    String test = "4568"; int new = Integer.parseInt(test);

  2. также вы можете использовать Integer.valueOf():

    String test = "4568"; int new =Integer.parseInt(test);

0
ishant kulshreshtha

Преобразуйте строку в целое число с помощью метода parseInt класса Java Integer. Метод parseInt предназначен для преобразования строки в тип int и создает переменную NumberFormatException, если строка не может быть преобразована в тип int.

Пропустив исключение, которое он может выдать, используйте это:

int i = Integer.parseInt(myString);

Если String, обозначенный переменной myString, является допустимым целым числом, таким как “1234”, “200”, “1”,, и он будет преобразован в Java int. Если по какой-либо причине произойдет сбой, изменение может вызвать NumberFormatException, поэтому код должен быть немного длиннее, чтобы учесть это.

Ex. Метод преобразования Java String в int, контроль возможных NumberFormatException

public class JavaStringToIntExample
{
  public static void main (String[] args)
  {
    // String s = "test";  // use this if you want to test the exception below
    String s = "1234";

    try
    {
      // the String to int conversion happens here
      int i = Integer.parseInt(s.trim());

      // print out the value after the conversion
      System.out.println("int i = " + i);
    }
    catch (NumberFormatException nfe)
    {
      System.out.println("NumberFormatException: " + nfe.getMessage());
    }
  }
}

Если попытка изменения не удалась - в случае, если вы можете попытаться преобразовать тест Java String в int - процесс Integer parseInt сгенерирует NumberFormatException, который вы должны обработать в блоке try/catch.

0
Nisarg

Вы можете использовать метод parseInt  

  String SrNumber="5790";
int extractNumber = Integer.parseInt(SrNumber);
System.out.println(extractNumber);//Result will be --5790
0
Sunil Dhappadhule

Пользовательский алгоритм:

public static int toInt(String value) {
  int output = 0;
  boolean isFirstCharacter = true;
  boolean isNegativeNumber = false;
  byte bytes[] = value.getBytes();
  for (int i = 0; i < bytes.length; i++) {
    char c = (char) bytes[i];
    if (!Character.isDigit(c)) {
      isNegativeNumber = (c == '-');
      if (!(isFirstCharacter && (isNegativeNumber || c == '+'))) {
        throw new NumberFormatException("For input string \"" + value + "\"");
      }
    } else {
      int number = Character.getNumericValue(c);
      output = output * 10 + number;
    }
    isFirstCharacter = false;
  }
  if (isNegativeNumber) output *= -1;
  return output;
}

другое решение: (используйте строку charAt метод вместо преобразования строки в байтовый массив):

public static int toInt(String value) {
  int output = 0;
  boolean isFirstCharacter = true;
  boolean isNegativeNumber = false;
  for (int i = 0; i < value.length(); i++) {
    char c = value.charAt(i);
    if (!Character.isDigit(c)) {
      isNegativeNumber = (c == '-');
      if (!(isFirstCharacter && (isNegativeNumber || c == '+'))) {
        throw new NumberFormatException("For input string \"" + value + "\"");
      }
    } else {
      int number = Character.getNumericValue(c);
      output = output * 10 + number;
    }
    isFirstCharacter = false;
  }
  if (isNegativeNumber) output *= -1;
  return output;
}

Примеры:

int number1 = toInt("20");
int number2 = toInt("-20");
int number3 = toInt("+20");
System.out.println("Numbers = " + number1 + ", " + number2 + ", " + number3);

try {
  toInt("20 Hadi");
} catch (NumberFormatException e) {
  System.out.println("Error: " + e.getMessage());
}
0
nabeghe

Используя метод: Integer.parseInt(String s)

String s = "123";
int n = Integer.parseInt(s);
0
karthik_varma_k

Используйте Integer.parseInt(), это поможет вам разобрать строковое значение в int.

Пример:

String str = "2017";
int i = Integer.parseInt(str);
System.out.println(i);

Результат:. .__ 2017

0
Alekya

Используйте этот метод:

public int ConvertStringToInt(String number)
{
 int num = 0;
 try
 {
   int newNumber = Integer.ParseInt(number);
   num = newNumber;
 }
 catch(Exception ex)
 {
   num = 0;
   Log.i("Console",ex.toString);
 }
   return num;
}
0
mohamad sheikhi

Попробуйте этот код с разными входами String:

String a = "10";  
String a = "10ssda";  
String a = null; 
String a = "12102";

if(null != a) {
    try {
        int x = Integer.ParseInt(a.trim()); 
        Integer y = Integer.valueOf(a.trim());
        //  It will throw a NumberFormatException in case of invalid string like ("10ssda" or "123 212") so, put this code into try catch
    } catch(NumberFormatException ex) {
        // ex.getMessage();
    }
}
0
Ram Chhabra

Я написал этот быстрый метод для анализа ввода строки в int или long. Это быстрее, чем текущий JDK 11 Integer.parseInt или Long.parseLong. Хотя вы спрашивали только int, я также включил длинный парсер. Парсер кода ниже требует, чтобы метод парсера был маленьким, чтобы он мог работать быстро. Альтернативная версия находится под тестовым кодом. Альтернативная версия довольно быстрая и не зависит от размера класса.

Этот класс проверяет наличие переполнения, и вы можете настроить код для адаптации к вашим потребностям. Пустая строка будет давать 0 с моим методом, но это намеренно. Вы можете изменить это, чтобы адаптировать ваш случай или использовать как есть. 

Это только часть класса, где нужны parseInt и parseLong. Обратите внимание, что это касается только базовых 10 чисел.

Тестовый код для синтаксического анализатора int находится ниже кода ниже. 

/*
 * Copyright 2019 Khang Hoang Nguyen
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions
 * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 * @author: Khang Hoang Nguyen - [email protected]
 **/
final class faiNumber{        
    private static final long[] longpow = {0L, 1L, 10L, 100L, 1000L, 10000L, 100000L, 1000000L, 10000000L, 100000000L, 1000000000L,
                                           10000000000L, 100000000000L, 1000000000000L, 10000000000000L, 100000000000000L,
                                           1000000000000000L, 10000000000000000L, 100000000000000000L, 1000000000000000000L,
                                           };

    private static final int[] intpow = { 0, 1, 10, 100, 1000, 10000,
                                          100000, 1000000, 10000000, 100000000, 1000000000 
                                        };

    /**
     * parseLong(String str) parse a String into Long. 
     * All errors throw by this method is NumberFormatException.
     * Better errors can be made to tailor to each use case.
     **/
    public static long parseLong(final String str) { 
        final int length = str.length();
        if ( length == 0 ) return 0L;        

        char c1 = str.charAt(0); int start;

        if ( c1 == '-' || c1 == '+' ){
            if ( length == 1 ) throw new NumberFormatException( String.format("Not a valid long value. Input '%s'.", str) );
            start = 1;
        } else {
            start = 0;
        }
        /*
         * Note: if length > 19, possible scenario is to run through the string 
         * to check whether the string contains only valid digits.
         * If the check had only valid digits then a negative sign meant underflow, else, overflow.
         */
        if ( length - start > 19 ) throw new NumberFormatException( String.format("Not a valid long value. Input '%s'.", str) );

        long c; 
        long out = 0L;

        for ( ; start < length; start++){
            c = (str.charAt(start) ^ '0');
            if ( c > 9L ) throw new NumberFormatException( String.format("Not a valid long value. Input '%s'.", str) );
            out += c * longpow[length - start];
        }

        if ( c1 == '-' ){
            out = ~out + 1L;
            // if out > 0 number underflow(supposed to be negative).
            if ( out > 0L ) throw new NumberFormatException( String.format("Not a valid long value. Input '%s'.", str) );
            return out;
        }
        // if out < 0 number overflow(supposed to be positive).
        if ( out < 0L ) throw new NumberFormatException( String.format("Not a valid long value. Input '%s'.", str) );
        return out;
    }

    /**
     * parseInt(String str) parse a string into an int.
     * return 0 if string is empty. 
     **/
    public static int parseInt(final String str) { 
        final int length = str.length();
        if ( length == 0 ) return 0;        

        char c1 = str.charAt(0); int start; 

        if ( c1 == '-' || c1 == '+' ){
            if ( length == 1 ) throw new NumberFormatException( String.format("Not a valid integer value. Input '%s'.", str) );
            start = 1;
        } else {
            start = 0;
        }

        int out = 0; int c;
        int runlen = length - start;

        if ( runlen > 9 ) {
            if ( runlen > 10 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );

            c = (str.charAt(start) ^ '0');   // <- Any number from 0 - 255 ^ 48 will yield greater than 9 except 48 - 57
            if ( c > 9 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
            if ( c > 2 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
            out += c * intpow[length - start++];
        }

        for ( ; start < length; start++){
            c = (str.charAt(start) ^ '0');
            if ( c > 9 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
            out += c * intpow[length - start];
        }

        if ( c1 == '-' ){
            out = ~out + 1;
            if ( out > 0 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
            return out;
        }

        if ( out < 0 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
        return out;
    }
}

Раздел тестового кода. Это должно занять около 200 секунд или около того.

// Int Number Parser Test;
long start = System.currentTimeMillis();    
System.out.println("INT PARSER TEST");
for (int i = Integer.MIN_VALUE; i != Integer.MAX_VALUE; i++){
   if( faiNumber.parseInt(""+i) != i ) System.out.println("Wrong");
   if ( i == 0 ) System.out.println("HalfWay Done");
}

if( faiNumber.parseInt(""+Integer.MAX_VALUE) != Integer.MAX_VALUE ) System.out.println("Wrong");
long end = System.currentTimeMillis();
long result = (end - start);
System.out.println(result);        
// INT PARSER END */

Альтернативный метод, который также очень быстрый. Обратите внимание, что массив int pow не используется, но математическая оптимизация умножается на 10 путем сдвига битов.

public static int parseInt(final String str) { 
    final int length = str.length();
    if ( length == 0 ) return 0;        

    char c1 = str.charAt(0); int start; 

    if ( c1 == '-' || c1 == '+' ){
        if ( length == 1 ) throw new NumberFormatException( String.format("Not a valid integer value. Input '%s'.", str) );
        start = 1;
    } else {
        start = 0;
    }

    int out = 0; int c;
    while( start < length && str.charAt(start) == '0' ) start++; // <-- This to disregard leading 0, can be removed if you know exactly your source does not have leading zeroes.
    int runlen = length - start;

    if ( runlen > 9 ) {
        if ( runlen > 10 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );

        c = (str.charAt(start++) ^ '0');   // <- Any number from 0 - 255 ^ 48 will yield greater than 9 except 48 - 57
        if ( c > 9 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
        if ( c > 2 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
        out = (out << 1) + (out << 3) + c; // <- alternatively this can just be out = c or c above can just be out;
    }

    for ( ; start < length; start++){
        c = (str.charAt(start) ^ '0');
        if ( c > 9 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
        out = (out << 1) + (out << 3) + c; 
    }

    if ( c1 == '-' ){
        out = ~out + 1;
        if ( out > 0 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
        return out;
    }

    if ( out < 0 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
    return out;
}
0
Kevin Ng