Як перетворити String в int на Java?

Як я можу перетворити Stringв intв Java?

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

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

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

Якщо ви подивитесь на документацію Java, ви помітите, що "улов" полягає в тому, що ця функція може кинути "a" 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 завжди повертається. Таким чином, ви заощадите блок спробу лову.

API Apache NumberUtils версії 3.4

В даний час я виконую завдання для коледжу, де я не можу використовувати певні вирази, наприклад, наведені вище, і, переглянувши таблицю ASCII, мені вдалося це зробити. Це набагато складніший код, але він може допомогти іншим, хто обмежений, як я.

Перше, що потрібно зробити - це отримати вхід, в цьому випадку рядок цифр; Я зателефоную String number, і в цьому випадку я прикладом цього стану, використовуючи число 12String 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 "()"

І ось ти йдеш. Ви перетворили рядок цифр (у цьому випадку дві цифри) у ціле число, що складається з цих двох цифр, враховуючи такі обмеження:

• Немає повторюваних циклів
• Ніяких "магічних" виразів, таких як 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? Що станеться, якщо рядок буде 9999999999999999999999? Чи може машина ставитися до цього рядка як до 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");// Виняток (Ціле число обмежене максимальним значенням 2147 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 (NumberFormatException ex) {
      integerValue = 0;
  }

Використання константних рядків для порівняння або будь-якого виду обчислень завжди є хорошою ідеєю, оскільки константа ніколи не повертає нульове значення.

Можна використовувати new Scanner("1244").nextInt(). Або запитайте, чи існує інт: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");

Для конструктора рядків і буфера String ви можете використовувати:

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