Convertir manualmente una cadena a un entero en Java

Question

Estoy teniendo cadena que consiste en una secuencia de dígitos (por ejemplo, "1234"). ¿Cómo devolver el String como int sin utilizar las funciones de biblioteca de Java como 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

¿Y qué hay de malo en esto?

int i = Integer.parseInt(str); 

EDIT:

Si realmente necesidad de hacer la conversión a mano, intenta esto:

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

Lo anterior va a funcionar bien para los enteros positivos, si el número es negativo, primero tendrá que verificar un poco, pero lo dejo como ejercicio para el lector.

Answer 2

Si no se permiten las bibliotecas estándar, hay muchos enfoques para resolver este problema. Una forma de pensar sobre esto es como una función recursiva:

1. Si n es menor que 10, simplemente conviértalo en la cadena de un carácter que contiene su dígito. Por ejemplo, 3 se convierte en "3".
2. Si n es mayor que 10, entonces usa división y módulo para obtener el último dígito de ny el número formado al excluir el último dígito. Recursivamente obtenga una cadena para los primeros dígitos, luego agregue el carácter apropiado para el último dígito. Por ejemplo, si n es 137, calcularía recursivamente "13" y agregaría "7" para obtener "137".

Necesitará la lógica para casos especiales 0 y números negativos, pero de lo contrario esto se puede hacer de manera bastante simple.

Dado que sospecho que esto puede ser tarea (y sé que es un hecho que en algunas escuelas lo es), dejaré la conversión real como un ejercicio para el lector. :-)

Espero que esto ayude!

Answer 3

Utilice esta:

static int parseInt(String str) { 
    char[] ch = str.trim().toCharArray(); 
    int len = ch.length; 
    int value = 0; 
    for (int i=0, j=(len-1); i<len; i++,j--) { 
     int c = ch[i]; 
     if (c < 48 || c > 57) { 
      throw new NumberFormatException("Not a number: "+str); 
     } 
     int n = c - 48; 
     n *= Math.pow(10, j); 
     value += n; 
    } 
    return value; 
} 

Y, por cierto, se puede manejar el caso especial de los enteros negativos, de lo contrario será tirar excepción NumberFormatException.

Answer 4

Aproveche el hecho de que Java usa char e int de la misma manera. Básicamente, haz char - '0' para obtener el valor int del char.

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

    public static int myStringToInteger(String str) { 
     int sum = 0; 
     char[] array = str.toCharArray(); 
     int j = 0; 
     for(int i = str.length() - 1 ; i >= 0 ; i--){ 
      sum += Math.pow(10, j)*(array[i]-'0'); 
      j++; 
     } 
     return sum; 
    } 
} 

Answer 5

Puede hacer como esto: de la cadena, crear una matriz de caracteres para cada elemento, mantenga el índice de salvado, y multiplicar su valor ASCII por el poder del índice inverso real. Suma los factores parciales y lo obtienes.

Hay un pequeño molde para usar Math.pow (ya que devuelve un doble), pero puede evitarlo creando su propia función de encendido.

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 6

En este caso, utilice long en lugar de int. Debe verificar si hay desbordamientos.

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 7

enfoque alternativo a la respuesta ya publicado aquí. Puede atravesar la cadena desde el frente y construir el número

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 8

public int myStringToInteger(String str) throws NumberFormatException 
{ 
    int decimalRadix = 10; //10 is the radix of the decimal system 

    if (str == null) { 
     throw new NumberFormatException("null"); 
    } 

    int finalResult = 0; 
    boolean isNegative = false; 
    int index = 0, strLength = str.length(); 

    if (strLength > 0) { 
     if (str.charAt(0) == '-') { 
      isNegative = true; 
      index++; 
     } 

     while (index < strLength) { 

      if((Character.digit(str.charAt(index), decimalRadix)) != -1){ 
       finalResult *= decimalRadix; 
       finalResult += (str.charAt(index) - '0'); 
      } else throw new NumberFormatException("for input string " + str); 

      index++; 
     } 

    } else { 
     throw new NumberFormatException("Empty numeric string"); 
    } 

    if(isNegative){ 
     if(index > 1) 
      return -finalResult; 
     else 
      throw new NumberFormatException("Only got -"); 
    } 

    return finalResult; 
} 

Resultado: 1) Para la entrada de "34567", el resultado final sería: 34567 2) Para la entrada "-4567" el resultado final sería: -4567 3) Para la entrada "-", el resultado final sería: java.lang.NumberFormatException: Only got - 4) Para la entrada "12ab45", el resultado final sería: java.lang .NumberFormatException: para la cadena de entrada 12ab45

Answer 9

public static int convertToInt(String input){ 
     char[] ch=input.toCharArray(); 
     int result=0; 
     for(char c : ch){ 
      result=(result*10)+((int)c-(int)'0'); 
     } 
     return result; 
    } 

Answer 10

Tal vez de esta manera habrá un poco más rápido:

public static int convertStringToInt(String num) { 
    int result = 0; 

    for (char c: num.toCharArray()) { 
     c -= 48; 
     if (c <= 9) { 
      result = (result << 3) + (result << 1) + c; 
     } else return -1; 
    } 
    return result; 
} 

Answer 11

Uso de Java 8 se puede hacer lo siguiente: srtNum

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

1. Convertir a Char
2. para cada char (representado como 'b') -> 'b' -'0 'dará el número relativo
3. sum all en a (valor inicial es 0) (cada vez que realizamos una operación en un char do -> a = a * 1 0

Answer 12

Dada la sugerencia correcta, creo que la mayoría de las personas con educación secundaria pueden resolver esto por sí mismas. Todo el mundo sabe 134 = 100x1 + 10x3 + 1x4

La parte clave de la mayoría de la gente se pierda, es que si haces algo como esto en Java

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

que captará la representación decimal de carácter 0 en ascii chart y se multiplica por 1

En ascii table, el carácter 0 tiene una representación decimal de 48. Por lo tanto, la línea anterior imprimirá 48. De modo que si hace algo como '1' - '0' Eso es lo mismo que 49-48. Como en el gráfico ascii, los caracteres 0-9 son continuos, por lo que puede tomar cualquier carácter de 0 a 9 y restar 0 para obtener su valor entero. Una vez que tienes el valor entero para un personaje, entonces convertir toda la cadena a int es sencillo.

Aquí hay otra solución al problema

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 13

Este es el programa completo con todas las condiciones positivas y negativas sin necesidad de utilizar la biblioteca

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