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

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

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

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

+2853
07 апр. '11 в 18:27
источник поделиться
48 ответов
  • 1
  • 2
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, который в сочетании с Java 8 Optional обеспечивает мощный и лаконичный способ преобразования строки в тип int:

import com.google.common.primitives.Ints;

int foo = Optional.ofNullable(myString)
 .map(Ints::tryParse)
 .orElse(0)
+3917
07 апр. '11 в 18:29
источник

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

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

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

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

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

+646
07 апр. '11 в 18:36
источник
другие ответы

Связанные вопросы


Похожие вопросы

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

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

+233
30 апр. '13 в 6:54
источник

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

public static int strToInt( String str ){
    int i = 0;
    int num = 0;
    boolean isNeg = false;

    //Check for negative sign; if it 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;
}
+81
11 сент. '13 в 2:08
источник

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

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

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

Apache NumberUtils API версии 3.4

+45
27 авг. '15 в 12:07
источник

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

Мы делим последний (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 "()"

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

  • Нет повторяющихся циклов
  • Нет выражений "Magic", таких как parseInt
+44
20 мар. '14 в 23:51
источник

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, вы можете использовать:

  • Распаковка:

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

    Integer.decode("12").intValue();
    
+33
07 мар. '16 в 0:42
источник

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

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

+26
04 апр. '16 в 3:13
источник

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

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

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

 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 и большая статья о конвертации здесь.

+23
03 окт. '17 в 19:16
источник

Мы можем использовать метод 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
20 окт. '15 в 9:51
источник

У меня есть решение, но я не знаю, насколько он эффективен. Но он работает хорошо, и я думаю, вы могли бы его улучшить. С другой стороны, я сделал пару тестов с 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
23 мая '14 в 15:38
источник

Используйте 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
06 окт. '17 в 19:00
источник

Просто для удовольствия: вы можете использовать Java 8 Optional для преобразования 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. Вероятно, могут быть ситуации, когда это полезно - например, если вы хотите избежать нулевых проверок. Код Pre Java 8 будет выглядеть так:

Integer value = (str == null) ? -1 : Integer.parseInt(str);
+17
09 нояб. '16 в 11:34
источник

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

Integer fooInt = Ints.tryParse(fooString);
if (fooInt != null) {
  ...
}
+16
06 авг. '16 в 17:56
источник

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

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

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

+13
20 окт. '13 в 13:11
источник

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

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;
}
+12
01 авг. '16 в 14:44
источник

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

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

    catch (NumberFormatException ex) {
        integerValue = 0;
    }
    

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

+9
31 дек. '15 в 5: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;
+9
26 июл. '16 в 5:26
источник

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

+9
28 февр. '17 в 20:36
источник

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

  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
24 апр. '17 в 5:36
источник

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

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

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

Integer.parseInt(myBuilderOrBuffer.toString());
+7
18 авг. '16 в 7:07
источник

Просто вы можете попробовать следующее:

  • Используйте 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
14 сент. '17 в 19:45
источник
int foo=Integer.parseInt("1234");

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

+6
20 апр. '16 в 9:54
источник

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

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

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

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

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


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

public Integer(String var1) throws NumberFormatException {
    this.value = parseInt(var1, 10);
}
+6
23 апр. '18 в 20:49
источник

Вот так

String str="1234";
int number = Integer.parseInt(str);
print number;//1234
+5
20 нояб. '16 в 4:24
источник

Используйте 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
11 нояб. '17 в 1:58
источник

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

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

String number = "999";

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

int result = Ints.tryParse(number);

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

Integer result = NumberUtils.createInteger(number);

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

int result = NumberUtils.toInt(number);

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

Integer result = Integer.valueOf(number);

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

int result = Integer.parseInt(number);

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

int result = Integer.decode(number);

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

int result = Integer.parseUnsignedInt(number);
+5
12 сент. '18 в 9:07
источник

Одним из методов является 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
12 авг. '17 в 14:25
источник

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

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
01 сент. '17 в 6:53
источник
  • 1
  • 2

Посмотрите другие вопросы по меткам или Задайте вопрос