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


3026

¿Cómo puedo convertir un Stringa inten Java?

Mi cadena contiene solo números y quiero devolver el número que representa.

Por ejemplo, dada la cadena, "1234"el resultado debería ser el número 1234.


1
Por cierto, tenga en cuenta que si la cadena es nula, la llamada: int i = Integer.parseInt (null); lanza NumberFormatException, no NullPointerException.
Pavel Molchanov

2
Estoy un poco sorprendido de que esta pregunta tenga una calificación tan alta cuando falta una parte importante de la especificación: ¿qué debería suceder si la cadena NO contiene solo dígitos? Por ejemplo, muchas de las respuestas analizarán "-1" y devolverán -1, pero no sabemos si eso es aceptable.
Michael Kay

Respuestas:


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

Si observa la documentación de Java , notará que la "captura" es que esta función puede arrojar una NumberFormatException, que por supuesto debe manejar:

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

(Este tratamiento predetermina un número con formato incorrecto a 0 , pero puede hacer otra cosa si lo desea).

Alternativamente, puede usar un Intsmétodo de la biblioteca Guava, que en combinación con Java 8 Optional, es una forma poderosa y concisa de convertir una cadena en un int:

import com.google.common.primitives.Ints;

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

23
Además de detectar una excepción NumberFormatException, el usuario también debe tener cuidado con la longitud de las cadenas que están pasando; si son lo suficientemente largos como para desbordar un entero, es posible que deseen considerar usar Long :: parseLong en su lugar.
Allison

66
@Allison, especialmente si se usa el campo BIGINT en un campo de clave primaria con incremento automático de PostgreSQL, por ejemplo. Mucho más seguro de usar por mucho tiempo
Letholdrus

77
Puede verificar si la cadena es un Número primero: stackoverflow.com/questions/1102891/…
JPRLCol

Este método también arroja una excepción cuando la cadena no es un entero analizable en la base 10. Use el método sobrecargado para trabajar en otras bases. por ejemplo, Integer.parseInt ("1001", 8); para la base 8. Fuente .
Lokesh

2
Además, aunque usar Guava en combinación con Java 8's Opcional puede ser poderoso, probablemente sea excesivo y no tan conciso como usar NumberUtils.toInt (String str, int defaultValue) de la biblioteca Apache commons-lang :int foo = NumberUtils.toInt(myString, 0);
Kunda

681

Por ejemplo, aquí hay dos formas:

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

Hay una ligera diferencia entre estos métodos:

  • valueOf devuelve una instancia nueva o en caché de java.lang.Integer
  • parseIntdevuelve primitiva int.

Lo mismo es para todos los casos: Short.valueOf/ parseShort, Long.valueOf/ parseLong, etc.


80
Para conocer las diferencias entre los dos métodos, consulte esta pregunta
hertzsprung

19
valueOfmétodo es justoreturn valueOf(parseInt(string));
Paul Verest

@PaulVerest no lo entiendo ... se valueOfllama recursivamente?
idclev 463035818

1
@ user463035818 valueOf tiene dos sobrecargas: int y String. valueOf(String)se implementa analizando primero la cadena a un int usando parseInt(String)y luego envolviendo ese int en un entero usando valueOf(int). Aquí no hay recursión porque valueOf(String)y valueOf(int)son dos funciones completamente diferentes, incluso si tienen el mismo nombre.
PhilipRoman

244

Bueno, un punto muy importante a considerar es que el analizador Integer arroja 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) {
      //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.
}

Es importante manejar esta excepción al intentar obtener valores enteros de argumentos divididos o analizar algo dinámicamente.


¿Cómo puedo analizar "26263Hola"? Quiero extraer 26263 en ese caso
idclev 463035818

1
@ user463035818 - Vea docs.oracle.com/javase/8/docs/api/java/util/regex/… - un patrón de expresión regular de "([0-9]+)""capturará" la primera secuencia de uno o más dígitos del uno al nueve. Mira la Matcherclase en ese paquete.
Mark Stewart

83

Hazlo manualmente:

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

22
¿Qué pasa si la entrada es mayor que 2 ^ 32? ¿Qué pasa si la entrada contiene caracteres no numéricos?
yohm

87
Una de las cosas que un programador debe aprender al unirse a la fuerza laboral, si no antes, es nunca reinventar las ruedas. Este puede ser un ejercicio divertido, pero no espere que su código pase la revisión del código si hace este tipo de cosas en un entorno comercial.
Dawood ibn Kareem el

43
-1 Lo sentimos, pero este es un algoritmo bastante pobre, con muchas limitaciones, sin manejo de errores y algunas anomalías extrañas (por ejemplo, "" da una excepción, "-" producirá 0 y "+" produce -5). ¿Por qué alguien elegiría esto Integer.parseInt(s)? - Veo el punto de que esta es una pregunta de entrevista, pero a) eso no implica que lo harías de esta manera (que es lo que preguntó el interlocutor), yb) esta respuesta es un mal ejemplo de todos modos.
SusanW

1
-1 porque ¿qué pasa si quiero analizar una base 31 int? Integer.parseInt (str, 31) es una línea para hacer eso. Comentario ligeramente gracioso, pero un punto serio debajo. Nunca reinventes las ruedas cuando otra persona ya ha puesto el trabajo
Nathan Adams

1
Parece que este código fue adaptado de una biblioteca conocida para IO rápido en concursos de programación competitivos. En ese contexto, se garantiza que los datos de entrada serán válidos, y las soluciones se califican según la velocidad. Debería ser más rápido que Integer.parseInt porque no tiene validación.
kaya3

53

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

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

La utilidad Apache es buena porque si la cadena tiene un formato de número no válido, siempre se devuelve 0. Por lo tanto, le ahorra el bloque try catch.

Apache NumberUtils API Versión 3.4


34
Rara vez desea que se use 0 cuando se analiza un número no válido.
wnoise

44
Cero es lo que Java usa como predeterminado si no se establece un campo int en un objeto. Entonces, en ese sentido, tiene sentido.
Ryboflavin

15
@Ryboflavin No, no lo hace. Uno de ellos es un lenguaje semántico bien definido, y el otro es una excepción
etéreo el

43

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

Lo primero que debe hacer es recibir la entrada, en este caso, una cadena de dígitos; Lo llamaréString number , en este caso, lo ejemplificaré usando el número 12, por lo tantoString number = "12";

Otra limitación era el hecho de que no podía usar ciclos repetitivos, por lo tanto, un forciclo (que hubiera sido perfecto) tampoco puede usarse. Esto nos limita un poco, pero de nuevo, ese es el objetivo. Como solo necesitaba dos dígitos (tomando los últimos dos dígitos), un simple lo charAtresolvió:

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

Con 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, debido a un paso realmente "extraño". Actualmente tenemos dos dobles, 1 y 2, pero necesitamos convertirlo en 12, no hay ninguna operación matemática que podamos hacer.

Estamos dividiendo el último (último dígito) por 10 de la manera 2/10 = 0.2(de ahí por qué doble) así:

 lastdigit = lastdigit/10;

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

 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á, dado que solo consideramos 0-9, dividir entre un múltiplo de 10 es como crear una "caja" donde la almacena (piense en cuándo su maestra de primer grado le explicó qué eran una unidad y cien). Entonces:

 int finalnumber = (int) (jointdigits*10); // Be sure to use parentheses "()"

Y ahi tienes. Convirtió una Cadena de dígitos (en este caso, dos dígitos) en un número entero compuesto por esos dos dígitos, considerando las siguientes limitaciones:

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

8
Usar type double para analizar un número entero no solo es una mala idea en cuanto al rendimiento. Los valores como 0.2 son números periódicos en representación de punto flotante y no se pueden representar con precisión. Pruebe System.out.println (0.1 + 0.2) para ver el punto: ¡el resultado no será 0.3! Es mejor seguir con el código de la biblioteca siempre que sea posible, en este caso Integer.parseInt ().
ChrisB

10
No está claro qué tipo de problema intenta resolver esta respuesta, primero, por qué alguien debería tener esa restricción que usted describe, segundo, por qué debe mirar una tabla ASCII, ya que puede usarla '0'para el personaje en lugar de 48y nunca tener que molestarse con su valor numérico real. En tercer lugar, todo el desvío con doublevalores no tiene ningún sentido ya que está dividiendo entre diez, solo para multiplicar por diez después. El resultado es simplemente semilastdigit * 10 + lastdigitcomo se aprendió en la escuela primaria, cuando se introdujo el sistema decimal ...
Holger

2
@Holger Me dieron personalmente esa restricción cuando comencé a programar, y también cuando tuve que escribir (lápiz / papel) interacciones similares en una prueba. Es poco común, pero es un método que se entiende fácilmente y, aunque no es el más eficiente por millas, es un método que funciona lo suficientemente decentemente para proyectos pequeños. SO.SE está destinado a ayudar a todos, no solo a unos pocos. Proporcioné un método alternativo, para aquellos que comienzan aprendiendo cómo crear un pseudo-algoritmo y convertirlo en un algoritmo en lugar de usar expresiones java prefabricadas. Aunque olvidé que '0' es genial
Oak

2
Esta no es una buena respuesta. La pregunta es "¿Cómo convierto una cadena en un int en Java?" no, "¿Cómo resuelvo este problema de tarea con restricciones arbitrarias?" Es StackOverflow, no HomeworkOverflow.
DavidS

1
Usted dejó muy claro el motivo para utilizar este enfoque novedoso, por lo que en sí mismo no es una preocupación. Sin embargo, hace hincapié en que su enfoque utiliza "ciclos no repetitivos" , pero su ejemplo específico evita ese problema por completo al codificar la solución (para un número de dos dígitos) para usar solo semilastdigity lastdigit. ¿Cómo codificaría su solución para evitar "ciclos repetitivos" si le proporcionara una cadena numérica válida de longitud arbitraria (es decir, cualquier valor entre "-2147483648" y "2147483647"?)
skomisa

38

Integer.decode

También puedes usar public static Integer decode(String nm) throws NumberFormatException .

También funciona para la base 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 desea obtener en intlugar de Integerpuede usar:

  1. Unboxing:

    int val = Integer.decode("12"); 
  2. intValue():

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

¡Finalmente! ¡Alguien que realmente se molesta en publicar los resultados / resultados de las conversiones! ¿Puedes agregar algunos con signos "-"?
not2qubit

29

Siempre que exista la más mínima posibilidad de que la Cadena dada no contenga un Entero, debe manejar este caso especial. Lamentablemente, los métodos estándar de Java Integer::parseInty Integer::valueOfarrojar un NumberFormatExceptionpara señalar este caso especial. Por lo tanto, debe usar excepciones para el control de flujo, que generalmente se considera un estilo de codificación incorrecto.

En mi opinión, este caso especial debe manejarse devolviendo un vacío Optional<Integer>. Como Java no ofrece dicho método, utilizo el siguiente contenedor:

private Optional<Integer> tryParseInteger(String string) {
    try {
        return Optional.of(Integer.valueOf(string));
    } catch (NumberFormatException e) {
        return Optional.empty();
    }
}

Ejemplo de uso:

// 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"));

Si bien esto todavía usa excepciones para el control de flujo internamente, el código de uso se vuelve muy limpio. Además, puede distinguir claramente el caso en que -1se analiza como un valor válido y el caso en que no se puede analizar una Cadena no válida.


24

Convertir una cadena en un int es más complicado que simplemente convertir un número. Has pensado en los siguientes problemas:

  • ¿La cadena solo contiene números del 0 al 9 ?
  • ¿Qué pasa con - / + antes o después de la cadena? ¿Es eso posible (refiriéndose a los números de contabilidad)?
  • ¿Qué pasa con MAX _- / MIN_INFINITY? ¿Qué sucederá si la cadena es 99999999999999999999? ¿Puede la máquina tratar esta cadena como un int?

1
Sí, y hay un caso extremo desagradable alrededor de -2 ^ 31. Si intentas negar 2 ^ 31, podrías encontrarte con dificultades ......
SusanW

24

Métodos para hacer eso:

 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 produce el objeto Integer, todos los demás métodos: primitivo int.

Últimos 2 métodos de commons-lang3 y gran artículo sobre la conversión aquí .


22

Podemos usar el parseInt(String str)método deInteger clase contenedora para convertir un valor de cadena en un valor entero.

Por ejemplo:

String strValue = "12345";
Integer intValue = Integer.parseInt(strVal);

La Integerclase también proporciona el valueOf(String str)método:

String strValue = "12345";
Integer intValue = Integer.valueOf(strValue);

También podemos utilizar toInt(String strValue)de NumberUtils clase de utilidad para la conversión:

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

22

Uso Integer.parseInt(yourString).

Recuerda las siguientes cosas:

Integer.parseInt("1"); // Okay

Integer.parseInt("-1"); // Okay

Integer.parseInt("+1"); // Okay

Integer.parseInt(" 1"); // Excepción (espacio en blanco)

Integer.parseInt("2147483648");// Excepción (el número entero está limitado a un valor máximo de 2,147,483,647)

Integer.parseInt("1.1");// Excepción ( . O , o lo que no esté permitido)

Integer.parseInt(""); // Excepción (no 0 o algo)

Solo hay un tipo de excepción: NumberFormatException


¿El valor máximo int aquí también da una NumberFormatException?
The Coding Wombat

No, el valor máximo todavía está bien
Lukas Bauer

19

Tengo una solución, pero no sé qué tan efectiva es. Pero funciona bien, y creo que podría mejorarlo. Por otro lado, hice un par de pruebas con JUnit que paso correctamente. Adjunté la función y las pruebas:

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

Prueba con 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));
        }
    }
}

Puedes hacerlo más simple:(int) Double.parseDouble(input.replaceAll("[^0-9\\.\\-]", ""));
Dávid Horváth


17

También puede comenzar eliminando todos los caracteres no numéricos y luego analizando el entero:

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

Pero tenga en cuenta que esto solo funciona para números no negativos.


18
Esto hará -42que se analice como 42.

10
Sí, esto solo funciona para números no negativos que son correctos para comenzar y, por lo tanto, no necesitan este paso de reemplazo. Para cualquier otro caso, este intento de arreglarlo automáticamente empeorará las cosas (ya que casi todos los intentos de arreglar algo automáticamente). Si paso "4+2", obtendré 42como resultado sin ninguna pista de que lo que intenté hacer fue equivocado. El usuario tendrá la impresión de que ingresar expresiones básicas como 4+2era una entrada válida, pero la aplicación continúa con un valor incorrecto. Además de eso, el tipo es String, no string...
Holger

O cambie la primera línea a -> string mystr = mystr.replaceAll ("[^ \\ d \\ -]", "");
apm

13

Además de las respuestas anteriores, me gustaría agregar varias funciones. Estos son resultados mientras los usa:

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
}

Implementación:

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

10

Como se mencionó, Apache Commons ' NumberUtilspuede hacerlo. Vuelve0 si no puede convertir una cadena en un int.

También puede definir su propio valor predeterminado:

NumberUtils.toInt(String str, int defaultValue)

Ejemplo:

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;

9

También puede usar este código, con algunas precauciones.

  • Opción n. ° 1: Maneje la excepción explícitamente, por ejemplo, mostrando un diálogo de mensaje y luego detenga la ejecución del flujo de trabajo actual. Por ejemplo:

    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;
    }
  • Opción n. ° 2: restablezca la variable afectada si el flujo de ejecución puede continuar en caso de una excepción. Por ejemplo, con algunas modificaciones en el bloque catch

    catch (NumberFormatException ex) {
        integerValue = 0;
    }

Usar una constante de cadena para comparar o cualquier tipo de computación es siempre una buena idea, porque una constante nunca devuelve un valor nulo.


44
Poner JOptionPane.showMessageDialog()la respuesta a la pregunta vainilla de Java no tiene sentido.
John Hascall

2
Integer.valueOf(String);no devuelve tipo int.
php_coder_3809625

9

Puedes usar new Scanner("1244").nextInt(). O pregunte si incluso existe un int:new Scanner("1244").hasNextInt()


9

En las competiciones de programación, donde tiene la seguridad de que el número siempre será un número entero válido, puede escribir su propio método para analizar la entrada. Esto omitirá todo el código relacionado con la validación (ya que no necesita nada de eso) y será un poco más eficiente.

  1. Para entero positivo válido:

    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. Para enteros positivos y negativos:

    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. Si espera un espacio en blanco antes o después de estos números, asegúrese de hacerlo str = str.trim()antes de seguir procesando.


7

Simplemente puedes probar esto:

  • Use Integer.parseInt(your_string);para convertir unStringaint
  • Use Double.parseDouble(your_string);para convertir un Stringadouble

Ejemplo

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

Esta respuesta no parece agregar nada más allá de las respuestas que recomiendan Integer.parseInt publicado unos años antes (convertir String a doble sería una pregunta diferente ).
Bernhard Barker

7

Para una cadena normal puede usar:

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

Para un generador de cadenas y un búfer de cadenas puede usar:

Integer.parseInt(myBuilderOrBuffer.toString());

6
int foo=Integer.parseInt("1234");

Asegúrese de que no haya datos no numéricos en la cadena.


55
Esto es exactamente lo mismo que la respuesta de selección.
Steve Smith

55
El sitio no tiene ningún valor al repetir una respuesta que otra persona publicó CINCO AÑOS antes que usted.
Dawood ibn Kareem

Esto ya está cubierto en la respuesta aceptada (publicada unos 5 años antes).
Peter Mortensen

6

Estoy un poco sorprendido de que nadie haya mencionado el constructor Integer que toma String como parámetro.

Asi que aqui esta:

String myString = "1234";
int i1 = new Integer(myString);

Java 8 - Entero (Cadena) .

Por supuesto, el constructor devolverá el tipo Integer, y una operación de unboxing convierte el valor a int.


Es importante mencionar : este constructor llama al parseIntmétodo.

public Integer(String var1) throws NumberFormatException {
    this.value = parseInt(var1, 10);
}

5

Use Integer.parseInt () y colóquelo dentro de un try...catchbloque para manejar cualquier error en caso de que se ingrese un carácter no numérico, por ejemplo,

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


5

Se puede hacer de siete maneras:

import com.google.common.primitives.Ints;
import org.apache.commons.lang.math.NumberUtils;

String number = "999";

1) Usando Ints.tryParse:

int result = Ints.tryParse(number);

2) Usando NumberUtils.createInteger:

Integer result = NumberUtils.createInteger(number);

3) Usando NumberUtils.toInt:

int result = NumberUtils.toInt(number);

4) Usando Integer.valueOf:

Integer result = Integer.valueOf(number);

5) Usando Integer.parseInt:

int result = Integer.parseInt(number);

6) Usando Integer.decode:

int result = Integer.decode(number);

7) Usando Integer.parseUnsignedInt:

int result = Integer.parseUnsignedInt(number);

NumberUtils también maneja escenarios nulos y vacíos.
Sundararaj Govindasamy

5

Un método es parseInt (String). Devuelve un int primitivo:

String number = "10";
int result = Integer.parseInt(number);
System.out.println(result);

El segundo método es valueOf (String), y devuelve un nuevo objeto Integer ():

String number = "10";
Integer result = Integer.valueOf(number);
System.out.println(result);

¿No está esto cubierto en respuestas anteriores?
Peter Mortensen

4

Puede usar cualquiera de los siguientes:

  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)

4

Este es un programa completo con todas las condiciones positivas y negativas sin usar una 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("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;
    }
}

2
No hay necesidad de reinventar la rueda, solo utilícela Integer.parseInt.
Dorian Gray

@TobiasWeimer sí, podemos hacerlo, pero esto es sin usar la biblioteca
Anup Gupta

@TobiasWeimer, algunas personas necesitan hacer esto sin usar Library.
Anup Gupta

55
No, nadie lo necesita porque es una función dentro del JDK, no un complemento de terceros.
Dorian Gray
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.