Cómo convertir un String a int en Java

Convertir texto como "42" en el número 42 es una de las tareas más comunes en Java — aparece cada vez que lees argumentos de línea de comandos, analizas un valor de configuración o procesas entrada de formulario. El JDK te ofrece un par de herramientas de una sola línea para ello en la clase Integer, además de un modo de fallo claro cuando el texto no es un número válido. Este capítulo muestra los enfoques idiomáticos y cómo manejar los casos incorrectos.

`Integer.parseInt` — el `int` primitivo que normalmente necesitas

Integer.parseInt(String) es la herramienta principal. Lee el texto y devuelve un int primitivo:

int count = Integer.parseInt("42");   // 42
int neg   = Integer.parseInt("-7");   // -7

Se permite un + o - inicial, pero nada más: espacios alrededor, puntos decimales, guiones bajos o letras provocan un fallo. Si puede haber espacios en blanco, recórtalos primero con s.trim() (o s.strip() en Java 11+). También existe una sobrecarga que acepta un radix, de modo que Integer.parseInt("ff", 16) lee hexadecimal y devuelve 255.

`Integer.valueOf` — cuando necesitas un objeto `Integer`

Integer.valueOf(String) realiza el mismo análisis, pero devuelve un Integer (el envoltorio en caja) en lugar de un int primitivo. Úsalo cuando el valor va directamente a una colección como List<Integer> o en cualquier lugar donde se requiera una referencia a objeto. Como ventaja adicional, valueOf almacena en caché las instancias en caja para valores pequeños (−128 a 127), por lo que puede ser marginalmente más barato que parseInt seguido de autoboxing.

Enfoque	Devuelve	Cuándo usarlo
`Integer.parseInt(s)`	`int` primitivo	cuando quieres hacer aritmética de inmediato
`Integer.valueOf(s)`	objeto `Integer`	cuando necesitas un envoltorio para una colección o genéricos
`Integer.parseInt(s, radix)`	`int` primitivo	el texto está en base 2, 8, 16, etc.

Manejo de entrada inválida con `NumberFormatException`

Ambos métodos lanzan una NumberFormatException sin comprobar cuando el string no es un entero analizable — "12x", "3.14", "" o null fallan todos. Como es sin comprobar, el compilador no te obligará a capturarla, por lo que depende de ti proteger las entradas que no controlas:

String raw = userInput();
try {
  int value = Integer.parseInt(raw.trim());
  // ... use value
} catch (NumberFormatException e) {
  System.out.println("Not a whole number: " + raw);
}

Cuando el análisis "se espera que falle a veces" y no quieres excepciones en tu flujo de control, envuélvelo en un ayudante que devuelva un OptionalInt en lugar de lanzar. Eso convierte un try/catch en una comprobación limpia de isPresent() en el sitio de llamada. Consulta Java Optional para el patrón más amplio, y Java try-catch para la mecánica de captura de la excepción.

Un ejemplo completo: todos los enfoques uno al lado del otro

Este programa ejecuta cada técnica de conversión y los dos casos de fallo, para que puedas ver exactamente qué devuelve o imprime cada uno:

java— editable, runs on the server

import java.util.OptionalInt;

public class StringToIntDemo {
  public static void main(String[] args) {
    // 1. The everyday tool: Integer.parseInt returns a primitive int.
    int n = Integer.parseInt("42");
    System.out.println("parseInt(\"42\")        = " + n);

// 2. Integer.valueOf returns an Integer object (and caches small values).
    Integer boxed = Integer.valueOf("42");
    System.out.println("valueOf(\"42\")         = " + boxed);

// 3. A second argument parses other radixes. "ff" in base 16 is 255.
    int hex = Integer.parseInt("ff", 16);
    System.out.println("parseInt(\"ff\", 16)    = " + hex);

// 4. Bad input is rejected loudly with NumberFormatException.
    try {
      Integer.parseInt("12x");
    } catch (NumberFormatException e) {
      System.out.println("parseInt(\"12x\") threw: " + e.getMessage());
    }

// 5. A null is also a NumberFormatException, not a NullPointerException.
    try {
      Integer.parseInt(null);
    } catch (NumberFormatException e) {
      System.out.println("parseInt(null) threw : " + e.getMessage());
    }

// 6. A safe, branch-free wrapper that never throws.
    OptionalInt parsed = tryParse("  7 ");
    System.out.println("tryParse(\"  7 \")      = " + (parsed.isPresent() ? parsed.getAsInt() : "absent"));
    OptionalInt bad = tryParse("nope");
    System.out.println("tryParse(\"nope\")      = " + (bad.isPresent() ? bad.getAsInt() : "absent"));
  }

static OptionalInt tryParse(String s) {
    if (s == null) return OptionalInt.empty();
    try {
      return OptionalInt.of(Integer.parseInt(s.trim()));
    } catch (NumberFormatException e) {
      return OptionalInt.empty();
    }
  }
}

Lo que se puede extraer de la ejecución:

Integer.parseInt("42") imprime 42 como un int primitivo, e Integer.valueOf("42") imprime el mismo 42 — la diferencia es el tipo, un objeto frente a un primitivo, no el valor.
La sobrecarga de radix convierte "ff" en 255, lo que demuestra que el segundo argumento controla la base; sin radix, el predeterminado es 10.
"12x" es rechazado con NumberFormatException cuyo mensaje es For input string: "12x" — la excepción nombra el texto exacto que falló, lo que la hace útil en los registros.
Pasar null lanza NumberFormatException (mensaje Cannot parse null string), no NullPointerException — por lo que una única captura de NumberFormatException cubre tanto la entrada mal formada como la nula.
El ayudante tryParse recorta " 7 " a 7 y devuelve absent para "nope", sin lanzar nunca — ese es el patrón a usar cuando la entrada inválida es normal en lugar de excepcional.

Práctica

¿Qué sucede cuando llamas a Integer.parseInt('3.14') en Java?

Lanza una NumberFormatException porque '3.14' no es un entero válidoDevuelve 3, truncando silenciosamente la parte decimalDevuelve 3.14 como un doubleDevuelve 0 porque el análisis falló

Temas relacionados

Cómo convertir un int a String en Java — la dirección inversa.
Excepciones en Java — contexto sobre NumberFormatException y la familia de excepciones sin comprobar.
Tipos de datos en Java — la diferencia entre el primitivo int y el envoltorio Integer.

Integer.parseInt — el int primitivo que normalmente necesitas

Integer.valueOf — cuando necesitas un objeto Integer

Manejo de entrada inválida con NumberFormatException