Ручное преобразование строки в целое число в Java

Question

У меня есть строка, состоящая из последовательности цифр (например, "1234").Как вернуть String как int без использования библиотечных функций Java, таких как Integer.parseInt?

public class StringToInteger {
  public static void main(String [] args){
    int i = myStringToInteger("123");
    System.out.println("String decoded to number " + i);
  }

  public int myStringToInteger(String str){
      /* ... */
  }
}

Answer 1

А что с этим не так?

int i = Integer.parseInt(str);

РЕДАКТИРОВАТЬ:

Если вам действительно необходимо выполнить преобразование вручную,попробуйте это:

public static int myStringToInteger(String str) {
    int answer = 0, factor = 1;
    for (int i = str.length()-1; i >= 0; i--) {
        answer += (str.charAt(i) - '0') * factor;
        factor *= 10;
    }
    return answer;
}

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

Answer 2

Если стандартные библиотеки запрещены, существует много подходов к решению этой проблемы.Один из способов думать об этом - использовать рекурсивную функцию:

1. Если n меньше 10, просто преобразуйте его в односимвольную строку, содержащую ее цифру.Например, 3 становится «3».
2. Если n больше 10, тогда используйте деление и модуль, чтобы получить последнюю цифру n и число, образованное путем исключения последней цифры.Рекурсивно получить строку для первых цифр, а затем добавить соответствующий символ для последней цифры.Например, если n равно 137, вы рекурсивно вычислите «13» и нажмете «7», чтобы получить «137».

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

Поскольку я подозреваю, что это может быть домашнее задание (и знаю, что в некоторых школах это так), я оставлю фактическое обращение в качестве упражнения для читателя.,: -)

Надеюсь, это поможет!

Answer 3

Используйте long вместо int в этом случае.Вам необходимо проверить наличие переполнений.

public static int StringtoNumber(String s) throws Exception{
    if (s == null || s.length() == 0)
        return 0;
    while(s.charAt(0) == ' '){
        s = s.substring(1);
    }
    boolean isNegative = s.charAt(0) == '-';
    if (s.charAt(0) == '-' || (s.charAt(0) == '+')){
        s = s.substring(1);
    }

    long result = 0l;
    for (int i = 0; i < s.length(); i++){
        int value = s.charAt(i) - '0';
        if (value >= 0 && value <= 9){
            if (!isNegative && 10 * result + value > Integer.MAX_VALUE ){
                throw new Exception();
            }else if (isNegative && -1 * 10 * result - value < Integer.MIN_VALUE){
                throw new Exception();
            }
            result = 10 * result + value;
        }else if (s.charAt(i) != ' '){
            return (int)result;
        }
    }
    return isNegative ? -1 * (int)result : (int)result;
}

Answer 4

Альтернативный подход к ответу уже выложен здесь.Вы можете пройти строку вперед и построить число

 public static void stringtoint(String s){      
    boolean isNegative=false;
    int number =0;      
    if (s.charAt(0)=='-') {
        isNegative=true;            
    }else{
        number = number* 10 + s.charAt(0)-'0';
    }

    for (int i = 1; i < s.length(); i++) {

        number = number*10 + s.charAt(i)-'0';           
    }
    if(isNegative){
        number = 0-number;
    }
    System.out.println(number);
}

Answer 5

Учитывая правильный намек, я думаю, что большинство людей со средним образованием могут решить это самостоятельно.Каждый знает, 134 = 100x1 + 10x3 + 1x4

Ключевая часть, которую пропускает большинство людей, заключается в том, что если вы сделаете что-то подобное в Java

 System.out.println('0'*1);//48

, он выберет десятичное представление символа 0 в диаграмме ASCII и умножьте ее на 1.

В таблице ASCII символ 0 имеет десятичное представление 48. Таким образом, в приведенной выше строке будет напечатано 48.Так что, если вы делаете что-то вроде «1» - «0», это то же самое, что и 49-48.Поскольку в диаграмме ascii символы 0-9 являются непрерывными, поэтому вы можете взять любой символ от 0 до 9 и вычесть 0, чтобы получить его целочисленное значение.Как только у вас есть целочисленное значение для символа, тогда преобразование всей строки в int является прямым.

Вот еще одно решение проблемы

String a = "-12512";
char[] chars = a.toCharArray();
boolean isNegative = (chars[0] == '-');
if (isNegative) {
    chars[0] = '0';
}

int multiplier = 1;
int total = 0;

for (int i = chars.length - 1; i >= 0; i--) {
    total = total + ((chars[i] - '0') * multiplier);
    multiplier = multiplier * 10;
}

if (isNegative) {
    total = total * -1;
}

Answer 6

Используя Java 8, вы можете делать следующее:

public static int convert(String strNum)
{
   int result =strNum.chars().reduce(0, (a, b)->10*a +b-'0');
}

1. Конвертировать srtNum в char
2. для каждого символа (представленного как 'b') -> 'b' -'0 'даст относительное число
3. сумма всего в (начальное значение 0) (каждый раз, когда мы выполняем операцию на символе -> a = a * 10

Answer 7

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

Существует только небольшое приведение для использования Math.pow (так как он возвращает удвоение), но вы можете избежать этого, создав собственную функцию власти.

public static int StringToInt(String str){
    int res = 0;
    char [] chars = str.toCharArray();
    System.out.println(str.length());
    for (int i = str.length()-1, j=0; i>=0; i--, j++){
        int temp = chars[j]-48;
        int power = (int) Math.pow(10, i);
        res += temp*power;
        System.out.println(res);
    }
    return res;
}

Answer 8

Works for Positive and Negative String Using TDD

//Solution

public int convert(String string) {
    int number = 0;
    boolean isNegative = false;
    int i = 0;
    if (string.charAt(0) == '-') {
        isNegative = true;
        i++;
    }

    for (int j = i; j < string.length(); j++) {
        int value = string.charAt(j) - '0';
        number *= 10;
        number += value;
    }
    if (isNegative) {
        number = -number;
    }

    return number;
}

// Тестовые случаи

public class StringtoIntTest {
private StringtoInt stringtoInt;


@Before
public void setUp() throws Exception {
stringtoInt = new StringtoInt();
}

@Test
public void testStringtoInt() {
    int excepted = stringtoInt.convert("123456");
    assertEquals(123456,excepted);
}

@Test
public void testStringtoIntWithNegative() {
    int excepted = stringtoInt.convert("-123456");
    assertEquals(-123456,excepted);
}

}

Answer 9

public class ConvertInteger {

public static int convertToInt(String numString){
    int answer = 0, factor = 1;

    for (int i = numString.length()-1; i >= 0; i--) {
        answer += (numString.charAt(i) - '0') *factor;
        factor *=10;
    }
    return answer;
}

public static void main(String[] args) {

    System.out.println(convertToInt("789"));
}

}

Answer 10

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

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("error!!!");
  } 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;
 }
}