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




преобразование типов java (20)

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

https://code.i-harness.com

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

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

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


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

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

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

API Apache NumberUtils версии 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;

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

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

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

  • Нет повторяющихся циклов
  • Нет выражений «Magic», таких как parseInt

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

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


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

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


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


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

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

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


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

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

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

Integer.parseInt(myBuilderOrBuffer.toString());

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

Как уже упоминалось, 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. 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 и большая статья о конвертации here .


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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

Дополнительную информацию см. В документации по Java .





type-conversion