Comment convertir un String en int en Java

Transformer un texte comme "42" en nombre 42 est l'une des tâches les plus courantes en Java — elle apparaît chaque fois que vous lisez des arguments de ligne de commande, analysez une valeur de configuration ou traitez une saisie de formulaire. Le JDK vous offre quelques outils en une ligne dans la classe Integer, ainsi qu'un mode d'échec clair lorsque le texte n'est pas un nombre valide. Ce chapitre présente les approches idiomatiques et la manière de gérer les cas d'erreur.

`Integer.parseInt` — le `int` primitif dont vous avez généralement besoin

Integer.parseInt(String) est le principal outil. Il lit le texte et renvoie un int primitif :

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

Un + ou - en tête est autorisé, mais rien d'autre : les espaces environnants, les points décimaux, les underscores ou les lettres provoquent tous une erreur. Si vous pouvez avoir des espaces, supprimez-les d'abord avec s.trim() (ou s.strip() avec Java 11+). Il existe aussi une surcharge qui prend un radix, donc Integer.parseInt("ff", 16) lit l'hexadécimal et renvoie 255.

`Integer.valueOf` — quand vous avez besoin d'un objet `Integer`

Integer.valueOf(String) effectue le même traitement mais renvoie un Integer (le wrapper encapsulé) plutôt qu'un int primitif. Utilisez-le lorsque la valeur va directement dans une collection comme List<Integer> ou partout où une référence d'objet est requise. En bonus, valueOf met en cache les instances encapsulées pour les petites valeurs (−128 à 127), ce qui peut être légèrement moins coûteux que parseInt suivi d'un autoboxing.

Approche	Retourne	Utilisez quand
`Integer.parseInt(s)`	`int` primitif	vous voulez effectuer des calculs immédiatement
`Integer.valueOf(s)`	objet `Integer`	vous avez besoin d'un wrapper pour une collection ou des génériques
`Integer.parseInt(s, radix)`	`int` primitif	le texte est en base 2, 8, 16, etc.

Gestion des entrées invalides avec `NumberFormatException`

Les deux méthodes lancent une NumberFormatException non vérifiée lorsque le string n'est pas un entier analysable — "12x", "3.14", "" ou null échouent tous. Comme elle est non vérifiée, le compilateur ne vous force pas à la capturer, il vous appartient donc de protéger les entrées que vous ne contrôlez pas :

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

Lorsque l'analyse est « susceptible d'échouer parfois » et que vous ne voulez pas d'exceptions dans votre flux de contrôle, encapsulez-la dans un helper qui renvoie un OptionalInt au lieu de lancer une exception. Cela transforme un try/catch en un propre contrôle isPresent() au site d'appel. Voir Java Optional pour le schéma général, et Java try-catch pour les mécanismes de capture de l'exception.

Un exemple concret : chaque approche côte à côte

Ce programme exécute chaque technique de conversion ainsi que les deux cas d'échec, afin que vous puissiez voir exactement ce que chacun renvoie ou affiche :

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

Ce qu'il faut retenir de l'exécution :

Integer.parseInt("42") affiche 42 en tant que int primitif, et Integer.valueOf("42") affiche le même 42 — la différence réside dans le type, un objet vs. un primitif, pas dans la valeur.
La surcharge avec radix transforme "ff" en 255, prouvant que le deuxième argument contrôle la base ; sans radix, la valeur par défaut est 10.
"12x" est rejeté avec une NumberFormatException dont le message est For input string: "12x" — l'exception nomme le texte exact qui a échoué, ce qui le rend utile dans les journaux.
Passer null lance une NumberFormatException (message Cannot parse null string), et non NullPointerException — ainsi un seul catch pour NumberFormatException couvre à la fois les entrées malformées et les entrées null.
Le helper tryParse supprime les espaces de " 7 " pour obtenir 7 et renvoie absent pour "nope", sans jamais lancer d'exception — c'est le schéma à utiliser lorsque les entrées invalides sont normales plutôt qu'exceptionnelles.

Pratique

Que se passe-t-il quand vous appelez Integer.parseInt('3.14') en Java ?

Cela lance une NumberFormatException car '3.14' n'est pas un entier valideCela renvoie 3, en tronquant silencieusement la partie décimaleCela renvoie 3.14 en tant que doubleCela renvoie 0 car l'analyse a échoué

Sujets connexes

Comment convertir un int en String en Java — la direction inverse.
Les exceptions Java — informations générales sur NumberFormatException et la famille des exceptions non vérifiées.
Les types de données Java — la différence entre le primitif int et le wrapper Integer.

Integer.parseInt — le int primitif dont vous avez généralement besoin

Integer.valueOf — quand vous avez besoin d'un objet Integer

Gestion des entrées invalides avec NumberFormatException