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

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

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)

Вот так

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

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

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

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

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

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

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

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 (число);

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

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

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

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

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

Integer.parseInt(myBuilderOrBuffer.toString());

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Мы можем использовать метод 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);

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

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

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

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

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

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

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

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

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

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

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

Apache NumberUtils API версии 3.4

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

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

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

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

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

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

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

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

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