Comment convertir une chaîne en int en Java?


3026

Comment puis-je convertir un Stringen un inten Java?

Ma chaîne ne contient que des nombres et je veux retourner le nombre qu'elle représente.

Par exemple, étant donné la chaîne, "1234"le résultat devrait être le nombre 1234.


1
Soit dit en passant, sachez que si la chaîne est nulle, l'appel: int i = Integer.parseInt (null); lève NumberFormatException, pas NullPointerException.
Pavel Molchanov

2
Je suis un peu surpris que cette question soit si bien notée lorsqu'une partie importante de la spécification est manquante: que devrait-il se passer si la chaîne NE contient PAS uniquement des chiffres? Par exemple, la plupart des réponses analyseront avec bonheur "-1" et renverront -1, mais nous ne savons pas si cela est acceptable.
Michael Kay

Réponses:


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

Si vous regardez la documentation Java, vous remarquerez que le "catch" est que cette fonction peut lancer un NumberFormatException, que vous devez bien sûr gérer:

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

(Ce traitement utilise par défaut un numéro mal formé 0, mais vous pouvez faire autre chose si vous le souhaitez.)

Alternativement, vous pouvez utiliser une Intsméthode de la bibliothèque Guava, qui en combinaison avec Java 8 Optional, permet une conversion puissante et concise d'une chaîne en un entier:

import com.google.common.primitives.Ints;

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

23
En plus d'attraper une NumberFormatException, l'utilisateur doit également faire attention à la longueur des chaînes qu'ils passent; s'ils sont assez longs pour déborder un entier, ils pourraient envisager d'utiliser Long :: parseLong à la place.
Allison

6
@Allison surtout si vous utilisez le champ BIGINT dans un champ de clé primaire incrémentée automatiquement PostgreSQL par exemple. Beaucoup plus sûr à utiliser longtemps
Letholdrus

7
Vous pouvez vérifier si la chaîne est un nombre en premier: stackoverflow.com/questions/1102891/…
JPRLCol

Cette méthode lève également une exception lorsque la chaîne n'est pas un entier analysable dans la base 10. Utilisez une méthode surchargée pour travailler dans d'autres bases. par exemple Integer.parseInt ("1001", 8); pour la base 8. Source .
lokesh du

2
De plus, bien que l'utilisation de Guava en combinaison avec l'option facultative de Java 8 puisse être puissante, c'est probablement une exagération et pas aussi concis que l'utilisation de NumberUtils.toInt (String str, int defaultValue) de la bibliothèque Apache commons-lang :int foo = NumberUtils.toInt(myString, 0);
Kunda

681

Par exemple, voici deux façons:

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

Il existe une légère différence entre ces méthodes:

  • valueOf renvoie une instance nouvelle ou mise en cache de java.lang.Integer
  • parseIntrenvoie primitif int.

Il en va de même pour tous les cas: Short.valueOf/ parseShort, Long.valueOf/ parseLong, etc.


80
Pour les différences entre les deux méthodes, voir cette question
hertzsprung

19
valueOfméthode est justereturn valueOf(parseInt(string));
Paul Verest

@PaulVerest je ne comprends pas ... valueOfs'appelle récursivement?
idclev 463035818

1
@ user463035818 valueOf a deux surcharges - pour int et String. valueOf(String)est implémenté en analysant d'abord la chaîne parseInt(String)dans un entier à l' aide , puis en encapsulant cet entier dans un entier à l'aide de valueOf(int). Pas de récursion ici car valueOf(String)et ce valueOf(int)sont deux fonctions complètement différentes, même si elles ont le même nom.
PhilipRoman

244

Eh bien, un point très important à considérer est que l'analyseur Integer lève NumberFormatException comme indiqué dans 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.
}

Il est important de gérer cette exception lorsque vous essayez d'obtenir des valeurs entières à partir d'arguments fractionnés ou d'analyser dynamiquement quelque chose.


comment puis-je analyser "26263Hello"? Je veux extraire 26263 dans ce cas
idclev 463035818

1
@ user463035818 - Voir docs.oracle.com/javase/8/docs/api/java/util/regex/… - un modèle d' expressions régulier "([0-9]+)""capturera" la première séquence d'un ou plusieurs chiffres de un à neuf. Regardez la Matcherclasse dans ce package.
Mark Stewart

83

Faites-le manuellement:

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
Que faire si l'entrée est supérieure à 2 ^ 32? Que faire si l'entrée contient des caractères non numériques?
yohm

87
L'une des choses qu'un programmeur doit apprendre à intégrer le marché du travail, sinon avant, est de ne jamais réinventer les roues. Cela peut être un exercice amusant, mais ne vous attendez pas à ce que votre code passe l'examen du code si vous faites ce genre de chose dans un cadre commercial.
Dawood ibn Kareem

43
-1 Désolé, mais c'est un algorithme assez médiocre, avec beaucoup de limitations, pas de gestion des erreurs et quelques anomalies étranges (par exemple, "" donne une exception, "-" produira 0 et "+" produira -5). Pourquoi quelqu'un choisirait-il cela Integer.parseInt(s)? - Je vois l'intérêt que ce soit une question d'entrevue, mais a) cela ne signifie pas que vous le feriez de cette façon (c'est ce que l'interrogateur a demandé), et b) cette réponse est de toute façon un très mauvais exemple.
SusanW

1
-1 parce que si je veux analyser une base 31 int? Integer.parseInt (str, 31) est une doublure pour le faire. Commentaire légèrement facétieux, mais point grave en dessous. Ne réinventez jamais les roues lorsque quelqu'un d'autre a déjà mis le travail
Nathan Adams

1
Ce code semble avoir été adapté d'une bibliothèque bien connue pour des E / S rapides dans des concours de programmation compétitifs. Dans ce contexte, les données d'entrée sont garanties d'être valides et les solutions sont classées en fonction de la vitesse. Cela devrait être plus rapide que Integer.parseInt parce qu'il ne fait aucune validation.
kaya3

53

Une autre solution consiste à utiliser NumberUtils d' Apache Commons :

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

L'utilitaire Apache est agréable car si la chaîne est un format numérique non valide, 0 est toujours renvoyé. Vous économisez donc le bloc try catch.

API Apache NumberUtils version 3.4


34
Vous souhaitez rarement que 0 soit utilisé lorsqu'un numéro non valide est analysé.
wnoise

4
Zéro est ce que java utilise par défaut si un champ int sur un objet n'est pas défini. À cet égard, cela a donc du sens.
Ryboflavin

15
@ Ryboflavin Non, ce n'est pas le cas. L'un d'eux est une sémantique de langage bien définie, et l'autre est une exception
éthérée

43

Actuellement, je fais un devoir pour l'université, où je ne peux pas utiliser certaines expressions, telles que celles ci-dessus, et en regardant la table ASCII, j'ai réussi à le faire. C'est un code beaucoup plus complexe, mais il pourrait en aider d'autres qui sont restreints comme moi.

La première chose à faire est de recevoir en entrée, dans ce cas, une chaîne de chiffres; Je vais l'appeler String number, et dans ce cas, je vais l'illustrer en utilisant le numéro 12, doncString number = "12";

Une autre limitation était le fait que je ne pouvais pas utiliser de cycles répétitifs, par conséquent, un forcycle (qui aurait été parfait) ne peut pas être utilisé non plus. Cela nous limite un peu, mais là encore, c'est le but. Comme je n'avais besoin que de deux chiffres (en prenant les deux derniers chiffres), un simple charAtproblème l'a résolu:

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

Ayant les codes, il suffit de regarder le tableau et de faire les ajustements nécessaires:

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

Maintenant, pourquoi doubler? Eh bien, à cause d'une étape vraiment "bizarre". Actuellement, nous avons deux doubles, 1 et 2, mais nous devons le transformer en 12, il n'y a aucune opération mathématique que nous pouvons faire.

Nous divisons ce dernier (dernier chiffre) par 10 à la mode 2/10 = 0.2(d'où le double) comme ceci:

 lastdigit = lastdigit/10;

Cela ne fait que jouer avec les chiffres. Nous transformions le dernier chiffre en décimal. Mais maintenant, regardez ce qui se passe:

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

Sans trop entrer dans les mathématiques, nous isolons simplement les unités des chiffres d'un nombre. Vous voyez, puisque nous ne considérons que 0-9, diviser par un multiple de 10, c'est comme créer une "boîte" où vous le stockez (pensez à quand votre professeur de première année vous a expliqué ce qu'était une unité et une centaine). Donc:

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

Et voilà. Vous avez transformé une chaîne de chiffres (dans ce cas, deux chiffres) en un entier composé de ces deux chiffres, compte tenu des limitations suivantes:

  • Pas de cycles répétitifs
  • Aucune expression "magique" telle que parseInt

8
L'utilisation de type double pour analyser un entier n'est pas seulement une mauvaise idée en termes de performances. Des valeurs telles que 0,2 sont des nombres périodiques en représentation à virgule flottante et ne peuvent pas être représentées avec précision. Essayez System.out.println (0,1 + 0,2) pour voir le point - le résultat ne sera pas 0,3! Mieux vaut rester avec le code de la bibliothèque partout où vous le pouvez, dans ce cas Integer.parseInt ().
ChrisB

10
Le type de problème que cette réponse essaie de résoudre n'est pas clair, premièrement, pourquoi quelqu'un devrait-il jamais avoir cette restriction que vous décrivez, deuxièmement, pourquoi vous devez regarder une table ASCII comme vous pouvez simplement l'utiliser '0'pour le caractère au lieu de 48et ne jamais avoir à dérange avec sa valeur numérique réelle. Troisièmement, tout le détour avec des doublevaleurs n'a aucun sens car vous divisez par dix, juste pour multiplier par dix par la suite. Le résultat est tout simplement semilastdigit * 10 + lastdigitcelui appris à l'école primaire, lorsque le système décimal a été introduit…
Holger

2
@Holger m'a personnellement donné cette restriction lors du premier démarrage de la programmation, et aussi lorsque j'ai dû écrire (stylo / papier) des interactions similaires dans un test. C'est rare, mais c'est une méthode qui est facile à comprendre et bien qu'elle ne soit pas la plus efficace de plusieurs kilomètres, c'est une méthode qui fonctionne assez décemment pour les petits projets. SO.SE est destiné à aider tout le monde, pas seulement quelques-uns. J'ai fourni une méthode alternative, pour ceux qui débutent en apprenant à créer un pseudo-algorithme et à le transformer en algorithme plutôt qu'en utilisant des expressions java prédéfinies. Bien que j'aie oublié que «0» est cool
Oak

2
Ce n'est pas une bonne réponse. La question est "Comment convertir une chaîne en un int en Java?" pas, "Comment puis-je résoudre ce problème de devoirs avec des restrictions arbitraires?" C'est StackOverflow, pas HomeworkOverflow.
DavidS

1
Vous avez expliqué très clairement la raison d'utiliser cette nouvelle approche, de sorte que ce n'est pas en soi un problème. Cependant, vous insistez sur le fait que votre approche n'utilise "aucun cycle répétitif" , mais votre exemple spécifique contourne complètement ce problème en codant en dur la solution (pour un nombre à deux chiffres) à utiliser uniquement semilastdigitet lastdigit. Comment coderiez-vous votre solution pour éviter les «cycles répétitifs» si je vous fournissais une chaîne numérique valide de longueur arbitraire (c.-à-d. N'importe quelle valeur entre «-2147483648» et «2147483647»?)
skomisa

38

Integer.decode

Vous pouvez également utiliser public static Integer decode(String nm) throws NumberFormatException.

Il fonctionne également pour les bases 8 et 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 vous voulez obtenir intau lieu de Integervous pouvez utiliser:

  1. Déballage:

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

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

Finalement! Quelqu'un qui prend la peine de publier les résultats / sorties des conversions! Pouvez-vous également en ajouter avec les signes "-"?
not2qubit

29

Chaque fois qu'il existe la moindre possibilité que la chaîne donnée ne contienne pas un entier, vous devez gérer ce cas spécial. Malheureusement, les méthodes Java standard Integer::parseIntet Integer::valueOfjeter un NumberFormatExceptionpour signaler ce cas particulier. Ainsi, vous devez utiliser des exceptions pour le contrôle de flux, qui est généralement considéré comme un mauvais style de codage.

À mon avis, ce cas spécial devrait être traité en renvoyant un vide Optional<Integer>. Étant donné que Java n'offre pas une telle méthode, j'utilise l'encapsuleur suivant:

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

Exemple d'utilisation:

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

Bien que cela utilise toujours des exceptions pour le contrôle de flux en interne, le code d'utilisation devient très propre. En outre, vous pouvez clairement distinguer le cas où -1est analysé en tant que valeur valide et le cas où une chaîne non valide n'a pas pu être analysée.


24

La conversion d'une chaîne en entier est plus compliquée que la simple conversion d'un nombre. Vous avez réfléchi aux problèmes suivants:

  • La chaîne contient-elle uniquement les chiffres 0-9 ?
  • Quoi de neuf avec - / + avant ou après la chaîne? Est-ce possible (en référence aux numéros comptables)?
  • Quoi de neuf avec MAX _- / MIN_INFINITY? Que se passera-t-il si la chaîne est 99999999999999999999? La machine peut-elle traiter cette chaîne comme un entier?

1
Oui - et il y a un cas de bord méchant autour de -2 ^ 31. Si vous essayez de nier 2 ^ 31, vous pourriez rencontrer des difficultés ......
SusanW

24

Méthodes pour y parvenir:

 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 produit un objet Integer, toutes les autres méthodes - primitive int.

2 dernières méthodes de commons-lang3 et grand article sur la conversion ici .


22

Nous pouvons utiliser la parseInt(String str)méthode de la Integerclasse wrapper pour convertir une valeur String en une valeur entière.

Par exemple:

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

La Integerclasse fournit également la valueOf(String str)méthode:

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

Nous pouvons également utiliser toInt(String strValue)des NumberUtils classe utilitaire pour la conversion:

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

22

Utilisez Integer.parseInt(yourString).

N'oubliez pas les choses suivantes:

Integer.parseInt("1"); // D'accord

Integer.parseInt("-1"); // D'accord

Integer.parseInt("+1"); // D'accord

Integer.parseInt(" 1"); // Exception (espace vide)

Integer.parseInt("2147483648");// Exception (l'entier est limité à une valeur maximale de 2 147 483 647)

Integer.parseInt("1.1");// Exception ( . Ou , ou tout ce qui n'est pas autorisé)

Integer.parseInt(""); // Exception (pas 0 ou quelque chose)

Il n'y a qu'un seul type d'exception: NumberFormatException


La valeur maximale int ici donne-t-elle également une exception NumberFormatException?
The Coding Wombat

Non, la valeur maximale est toujours correcte
Lukas Bauer

19

J'ai une solution, mais je ne sais pas à quel point elle est efficace. Mais cela fonctionne bien et je pense que vous pourriez l'améliorer. D'un autre côté, j'ai fait quelques tests avec JUnit qui fonctionnent correctement. J'ai attaché la fonction et les tests:

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

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

Vous pouvez le faire plus simplement:(int) Double.parseDouble(input.replaceAll("[^0-9\\.\\-]", ""));
Dávid Horváth


17

Vous pouvez également commencer par supprimer tous les caractères non numériques, puis analyser l’entier:

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

Mais sachez que cela ne fonctionne que pour les nombres non négatifs.


18
Cela entraînera -42d'être analysé comme 42.

10
Oui, cela ne fonctionne que pour les nombres non négatifs qui sont corrects au départ et n'ont donc pas besoin de cette étape de remplacement. Pour tous les autres cas, cette tentative de correction automatique aggravera les choses (comme presque toutes les tentatives de réparation automatique de quelque chose). Si je passe "4+2", j'obtiendrai 42sans aucun indice que ce que j'ai essayé de faire était erroné. L'utilisateur aura l'impression que la saisie d'expressions de base comme 4+2était une entrée valide, mais l'application continue avec une valeur incorrecte. A part ça, le type est String, pas string
Holger

Ou changez la première ligne en -> string mystr = mystr.replaceAll ("[^ \\ d \\ -]", "");
apm

13

Outre les réponses précédentes, je voudrais ajouter plusieurs fonctions. Voici les résultats pendant que vous les utilisez:

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
}

La mise en oeuvre:

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

Comme mentionné, Apache Commons NumberUtilspeut le faire. Il retourne 0s'il ne peut pas convertir une chaîne en entier.

Vous pouvez également définir votre propre valeur par défaut:

NumberUtils.toInt(String str, int defaultValue)

Exemple:

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

Vous pouvez également utiliser ce code, avec quelques précautions.

  • Option n ° 1: gérez l'exception de manière explicite, par exemple, en affichant une boîte de dialogue de message, puis arrêtez l'exécution du flux de travail en cours. Par exemple:

    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;
    }
  • Option # 2: Réinitialisez la variable affectée si le flux d'exécution peut continuer en cas d'exception. Par exemple, avec quelques modifications dans le bloc catch

    catch (NumberFormatException ex) {
        integerValue = 0;
    }

L'utilisation d'une constante de chaîne pour la comparaison ou tout autre type de calcul est toujours une bonne idée, car une constante ne renvoie jamais une valeur nulle.


4
Mettre JOptionPane.showMessageDialog()la réponse à la question Java vanille n'a aucun sens.
John Hascall

2
Integer.valueOf(String);ne renvoie pas de type int.
php_coder_3809625

9

Vous pouvez utiliser new Scanner("1244").nextInt(). Ou demandez si même un int existe:new Scanner("1244").hasNextInt()


9

Dans les compétitions de programmation, où vous êtes assuré que le nombre sera toujours un entier valide, vous pouvez écrire votre propre méthode pour analyser les entrées. Cela sautera tout le code lié à la validation (puisque vous n'en avez pas besoin) et sera un peu plus efficace.

  1. Pour un entier positif valide:

    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. Pour les nombres entiers positifs et négatifs:

    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 vous attendez un espace avant ou après ces chiffres, assurez-vous de faire un str = str.trim()avant de poursuivre le traitement.


7

Vous pouvez simplement essayer ceci:

  • Utilisez Integer.parseInt(your_string);pour convertir un Stringàint
  • Utilisez Double.parseDouble(your_string);pour convertir un Stringàdouble

Exemple

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

Cette réponse ne semble rien ajouter au-delà des réponses recommandant Integer.parseInt publiées quelques années plus tôt (la conversion de String en double serait une question différente ).
Bernhard Barker

7

Pour une chaîne normale, vous pouvez utiliser:

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

Pour un générateur de chaînes et un tampon de chaînes, vous pouvez utiliser:

Integer.parseInt(myBuilderOrBuffer.toString());

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

Assurez-vous qu'il n'y a pas de données non numériques dans la chaîne.


5
C'est exactement la même chose que la réponse choisie.
Steve Smith

5
Il n'y a aucune valeur pour le site, en répétant une réponse que quelqu'un d'autre a posté CINQ ANS avant vous.
Dawood ibn Kareem

Ceci est déjà couvert dans la réponse acceptée (publiée environ 5 ans auparavant).
Peter Mortensen

6

Je suis un peu surpris que personne n'ait mentionné le constructeur Integer qui prend String comme paramètre.

Voici donc:

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

Java 8 - Entier (chaîne) .

Bien sûr, le constructeur renverra le type Integeret une opération de décompression convertit la valeur en int.


Il est important de mentionner : ce constructeur appelle la parseIntméthode.

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

5

Utilisez Integer.parseInt () et placez-le dans un try...catchbloc pour gérer les erreurs au cas où un caractère non numérique serait entré, par exemple,

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

Cela peut se faire de sept manières:

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

String number = "999";

1) en utilisant Ints.tryParse:

int result = Ints.tryParse(number);

2) Utilisation NumberUtils.createInteger:

Integer result = NumberUtils.createInteger(number);

3) Utilisation NumberUtils.toInt:

int result = NumberUtils.toInt(number);

4) Utilisation Integer.valueOf:

Integer result = Integer.valueOf(number);

5) Utilisation Integer.parseInt:

int result = Integer.parseInt(number);

6) en utilisant Integer.decode:

int result = Integer.decode(number);

7) Utilisation Integer.parseUnsignedInt:

int result = Integer.parseUnsignedInt(number);

NumberUtils gère également les scénarios nuls et vides.
Sundararaj Govindasamy

5

Une méthode est parseInt (String). Il renvoie un primitif int:

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

La deuxième méthode est valueOf (String) et renvoie un nouvel objet Integer ():

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

N'est-ce pas couvert dans les réponses précédentes?
Peter Mortensen

4

Vous pouvez utiliser l'un des éléments suivants:

  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

Ceci est un programme complet avec toutes les conditions positives et négatives sans utiliser de bibliothèque

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
Il n'est pas nécessaire de réinventer la roue, il suffit de l'utiliser Integer.parseInt.
Dorian Gray

@TobiasWeimer oui, nous pouvons le faire mais c'est sans utiliser de bibliothèque
Anup Gupta

@TobiasWeimer, certaines personnes ont besoin de cette méthode pour se passer de la bibliothèque.
Anup Gupta

5
Non, personne n'en a besoin car c'est une fonction à l'intérieur du JDK, pas un plugin tiers.
Dorian Gray
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.