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

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

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

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

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)

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

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

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

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

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

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

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

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

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

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

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

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

Apache NumberUtils API версии 3.4

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

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

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

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

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

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

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

Мы можем использовать 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 Utility класса для преобразования:

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

Использование 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

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

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

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

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

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

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

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

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

Как уже упоминалось, 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;

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

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

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

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

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

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

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

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

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

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

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

Integer.parseInt(myBuilderOrBuffer.toString());

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

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

Я немного удивлен, что никто не упомянул конструктор 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);
}

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

Вот так

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

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

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

Одним из методов является 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);

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

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)

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

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