¿Cómo convierto una cadena a un int en Java?

¿Cómo convierto una String a un int en Java?

Mi cadena contiene solamante números y quiero volver al numero que la representa.

Por ejemplo al darle a la cadena el número "1234" el resultado deberia ser 1234.

  • java
  • string
  • int
  • type-conversion
7 Repuestas

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

Si miras a Documentos java notarás el "catch" que esta función puede lanzar NumberFormatException, el cual, por supuesto debes manejar:

int foo;
try {
   foo = Integer.parseInt(myString);
}
catch (NumberFormatException e)
{
   foo = 0;
}

(Este tratamiento establece por defecto un número con formato incorrecto a 0, pero puede hacer otra cosa si lo deseas.)

Alternativamente puedes usar un método Ints desde la biblioteca Guava, la cual combinada con Java 8's Optional hacen una poderosa y concisa forma de convertir una cadena en un int:

import com.google.common.primitives.Ints;

int foo = Optional.ofNullable(myString)
 .map(Ints::tryParse)
 .orElse(0)

Por ejemplo, aqui hay dos formas:

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

Hay una pequeña diferencia entre estos métodos:

  • valueOf regresa a una nueva o instancia de cache de java.lang.Integer
  • parseInt devuelve el int primitivo.

Es lo mismo para todos los casos. Short.valueOf/parseShort, Long.valueOf/parseLong, etc.

Bueno, un punto muy importante a considerar que el analizador de entero lanza la excepción numberFormatException como se indica en Javadoc.

int foo;
String StringThatCouldBeANumberOrNot = "26263Hello"; //will throw exception
String StringThatCouldBeANumberOrNot2 = "26263"; //will not throw exception
try {
      foo = Integer.parseInt(StringThatCouldBeANumberOrNot);
} catch (NumberFormatException e) {
      //Lanzara la excepción.
      //¡Haz algo! cualquier cosa para manejar la excepcion.
}

try {
      foo = Integer.parseInt(StringThatCouldBeANumberOrNot2);
} catch (NumberFormatException e) {
      // no hay problema esta vez, pero aun es una buena práctica cuidar las excepciones.
      //Nunca confiar en la entrada de un usuario :)
      //Haz algo! Cualquier cosa para manejar la excepcion.
}

Es importante manejar esta excepción cuando tratas de conseguir valores enteros de argumentos divididos o analizar dinámicamente algo.

Hazlo manualmente:

public static int strToInt( String str ){
    int i = 0;
    int num = 0;
    boolean isNeg = false;

    //Comprueba si hay un sigo negativo, si lo hay, establece bandera isNeg
    if (str.charAt(0) == '-') {
        isNeg = true;
        i = 1;
    }

    //Procesa cada caracter de la cadena;
    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;
}

Una solución alternativa es usar Apache Commons' NumberUtils:

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

La utilidad Apache es buena porque si la cadena es un formato de número invalido entonces 0 es siempre devuelto. Por lo tanto te ahora el intento de atrapar un bloque.

Apache NumberUtils API Version 3.4

Actualmente estoy haciendo una tarea para la universidad, donde no puedo usar ciertas expresiones como las de arriba, y pude hacerlas al mirar la tabla ASCII. Es un código mucho más complejo, pero podría ayudar a otros que están restringidos como lo estaba yo.

Lo primero que hay que hacer es recibir la entrada, en este caso String number. La llamaré cadena de números, y en este caso voy a ejemplificarla usando el número 12, por lo tanto String number = "12";

Otra limitación fue el hecho que no pude usar los ciclos respectivos por eso que el ciclo (el cual habría sido perfecto) tampoco puede ser usado. Esto nos limita un poco, pero entonces de nuevo, ese el es objetivo. Ya que solo necesitaba dos dígitos (tomando los dos últimos dígitos) un simple charAt lo resolvería.

 //Obtención de los valores enteros de los caracteres 1 y 2 en ASCII.
 int semilastdigitASCII = number.charAt(number.length()-2);
 int lastdigitASCII = number.charAt(number.length()-1);

Teniendo los códigos, solo necesitamos mirar la tabla y hacer los ajustes necesarios.

 double semilastdigit = semilastdigitASCII - 48;  //A quick look, and -48 is the key
 double lastdigit = lastdigitASCII - 48;

Ahora, por qué doble? Bueno, porque es realmente un paso "extraño". Actualmente tenemos dos dobles, 1 y 2, pero necesitamos convertirlos en 12, no hay ninguna operación matemática que podamos hacer.

Estamos dividiendo el último (último dígito) por 10 en la moda 2/10 = 0.2 (de ahí el doble) de esta manera:

lastdigit = lastdigit/10;

Esto simplemente es jugar con números. Estábamos convirtiendo el último dígito en un decimal. Pero ahora, mira lo que pasa:

double jointdigits = semilastdigit + lastdigit; // 1.0 + 0.2 = 1.2

Sin entrar demasiado en las matemáticas, simplemente estamos aislando las unidades de los dígitos de un número. Verás, ya que solo consideramos 0-9, dividido por un múltiplo de 10 es como crear una "caja" donde lo almacenas (recuerda cuando tu maestro de primer grado te explicó qué eran una unidad y una centena) Por eso:

int finalnumber = (int) (jointdigits*10); // Asegúrate de usar paréntesis "()"

Aquí vamos. Cambiaste la cadena de dígitos (en este caso, dos dígitos), en un número entero compuesto por esos dos dígitos, teniendo en cuenta las siguientes limitaciones:

  • Sin ciclos repetitivos
  • No hay expresiones "mágicas" como parseInt
Oak

Integer.decode

También puedes usar

La decodificación de enteros estática public static Integer throws NumberFormatException.

También funciona para base de 8 y 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

Si quieres conseguir int en vez de Integer puedes usar:

  1. Unboxing:

    int val = Integer.decode("12");

  2. intValue():

    Integer.decode("12").intValue();