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

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

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

3311
Unknown user 7 Апр 2011 в 22:27

30 ответов

Лучший ответ
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)
4293
Peter Mortensen 21 Авг 2020 в 15:30

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

  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
Peter Mortensen 21 Авг 2020 в 15:57

Вот так

String str = "1234";
int number = Integer.parseInt(str);
print number; // 1234
4
Peter Mortensen 21 Авг 2020 в 15:50

Один из методов - 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);
4
Peter Mortensen 2 Сен 2019 в 22:56

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

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
Peter Mortensen 2 Сен 2019 в 22:53
int foo = Integer.parseInt("1234");

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

5
Peter Mortensen 21 Авг 2020 в 15:49

Это можно сделать семью способами:

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

String number = "999";
  1. Ints.tryParse:

    int result = Ints.tryParse (число);

  2. NumberUtils.createInteger:

    Целочисленный результат = NumberUtils.createInteger (число);

  3. NumberUtils.toInt:

    int result = NumberUtils.toInt (число);

  4. Integer.valueOf:

    Целочисленный результат = Integer.valueOf (число);

  5. Integer.parseInt:

    int result = Integer.parseInt (число);

  6. Integer.decode:

    int result = Integer.decode (число);

  7. Integer.parseUnsignedInt:

    int result = Integer.parseUnsignedInt (число);

5
Santosh Jadi 11 Авг 2020 в 04:09

Используйте 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
Peter Mortensen 21 Фев 2018 в 22:33

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

Итак, вот оно:

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

Java 8 - Целое число (строка).

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


Примечание 1. Важно упомянуть : этот конструктор вызывает метод parseInt.

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

Примечание 2. Он устарел : @Deprecated(since="9") - JavaDoc.

7
djm.im 28 Авг 2020 в 10:28

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

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

Для построителя строк и буфера строк вы можете использовать:

Integer.parseInt(myBuilderOrBuffer.toString());
7
Peter Mortensen 2 Сен 2019 в 23:03

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

  • Используйте 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
6 revs, 5 users 58% 20 Июн 2020 в 09:12

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

  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() перед дальнейшей обработкой.

10
2 revs, 2 users 88% 2 Сен 2019 в 22:59

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

10
Christian Ullenboom 28 Фев 2017 в 20:36

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

  • Вариант №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;
    }
    

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

10
manikant gautam 5 Мар 2016 в 04:28

Как уже упоминалось, это может сделать 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;
12
Peter Mortensen 2 Сен 2019 в 23:08

Помимо предыдущих ответов, я хотел бы добавить несколько функций. Вот результаты, пока вы их используете:

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
}

Реализация:

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;
}
13
Peter Mortensen 2 Сен 2019 в 23:06

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

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

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

18
Abhishek Chugh 24 Ноя 2019 в 16:39

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

Integer fooInt = Ints.tryParse(fooString);
if (fooInt != null) {
  ...
}
19
Peter Mortensen 2 Сен 2019 в 23:04

У меня есть решение, но я не знаю, насколько оно эффективно. Но он работает хорошо, и я думаю, вы могли бы его улучшить. С другой стороны, я провел несколько тестов с 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));
        }
    }
}
21
Peter Mortensen 29 Ноя 2014 в 08:36

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

Например:

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

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

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

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

String strValue = "12345";
Integer intValue = NumberUtils.toInt(strValue);
22
Tom 16 Фев 2016 в 23:50

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

  • Строка содержит только цифры 0–9 ?
  • Что случилось с - / + до или после строки? Возможно ли это (по бухгалтерским цифрам)?
  • Что случилось с MAX _- / MIN_INFINITY? Что произойдет, если строка будет 99999999999999999999? Может ли машина рассматривать эту строку как int?
24
Peter Mortensen 21 Авг 2020 в 15:33

Используйте 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

24
Peter Mortensen 2 Сен 2019 в 22:50

Способы сделать это:

  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.

Последние два метода взяты из commons-lang3 и большой статьи о преобразовании здесь.

29
Peter Mortensen 21 Авг 2020 в 15:53

Всякий раз, когда есть малейшая вероятность того, что данная строка не содержит целого числа, вы должны обработать этот особый случай. К сожалению, стандартные методы 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 "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"));

Хотя он все еще использует исключения для внутреннего управления потоком, код использования становится очень чистым. Кроме того, вы можете четко различить случай, когда -1 анализируется как допустимое значение, и случай, когда недопустимая строка не может быть проанализирована.

29
Stefan Dollase 12 Апр 2020 в 17:06

В настоящее время я делаю задание для колледжа, где я не могу использовать определенные выражения, такие как приведенные выше, и, глядя на таблицу 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;

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

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

 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
Peter Mortensen 21 Авг 2020 в 15:45

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();
    
42
Elrond_EGLDer 7 Мар 2016 в 00:42

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

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

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

Apache NumberUtils API версии 3.4

59
Jonah Graham 5 Мар 2016 в 22:25

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

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;
}
89
Peter Mortensen 21 Авг 2020 в 15:31

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

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

257
Peter Mortensen 16 Фев 2016 в 23:35

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

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

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

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

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

728
nanofarad 30 Июн 2015 в 20:15