Question Comment puis-je convertir une chaîne en un int en Java?


Comment puis-je convertir un String à un int en Java?

Ma chaîne contient seulement des nombres, et je veux retourner le nombre qu'il représente.

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


2514
2018-04-07 18:27


origine


Réponses:


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

Voir le Documentation Java pour plus d'informations.


3554
2018-04-07 18:29



Par exemple, voici deux façons:

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

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

  • valueOf renvoie une instance nouvelle ou mise en cache de java.lang.Integer
  • parseInt renvoie la primitive int.

La même chose est pour tous les cas: Short.valueOf/parseShort, Long.valueOf/parseLong, etc.


588
2018-04-07 18:36



Eh bien, un point très important à considérer est que l'analyseur Integer renvoie 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 divisés ou d'analyser dynamiquement quelque chose.


215
2018-04-30 06:54



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

72
2017-09-11 02:08



Actuellement, je fais une mission pour le collège, où je ne peux pas utiliser certaines expressions, comme 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 aider d'autres qui sont restreints comme je l'étais.

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

Une autre limitation était le fait que je ne pouvais pas utiliser des cycles répétitifs, par conséquent, un for cycle (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 charAtré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);

Avoir les codes, nous avons juste besoin de regarder la table, et 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 (lastdigit) par 10 à la mode 2/10 = 0.2 (d'où pourquoi double) comme ceci:

 lastdigit = lastdigit/10;

C'est simplement jouer avec des chiffres. Nous transformions le dernier chiffre en une décimale. Mais maintenant, regardez ce qui se passe:

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

Sans trop entrer dans le calcul, nous isolons simplement les unités les chiffres d'un nombre. Vous voyez, puisque nous considérons seulement 0-9, diviser par un multiple de 10 est comme créer une "boîte" où vous le stockez (repensez à quand votre enseignant de première année vous a expliqué ce qu'une unité et une centaine étaient). Alors:

 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

38
2018-03-20 23:51



Une solution alternative est d'utiliser Apache Commons ' NumberUtils:

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

L'utilitaire Apache est sympa parce que si la chaîne est un format de nombre invalide alors 0 est toujours retourné. D'où vous sauver le bloc try catch.

API Apache NumberUtils Version 3.4


33
2017-08-27 12:07



Integer.decode

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

Cela 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 int au lieu de Integer vous pouvez utiliser:

  1. Déballage:

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

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

27
2018-03-07 00:42



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

À mon avis, ce cas particulier devrait être traité en retournant un Optional<Integer>. Puisque Java n'offre pas une telle méthode, j'utilise le wrapper suivant:

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

Usage:

// prints 1234
System.out.println(tryParseInteger("1234").orElse(-1));
// prints -1
System.out.println(tryParseInteger("foobar").orElse(-1));

Bien que cela utilise toujours des exceptions pour le contrôle de flux en interne, le code d'utilisation devient très propre.


20
2018-04-04 03:13



Convertir une chaîne en un int est plus compliqué que de simplement convertir un nombre. Vous avez réfléchi aux problèmes suivants:

  • Est-ce que la chaîne contient uniquement des nombres 0-9?
  • Qu'est ce qu'il y a avec - / + avant ou après la chaîne? Est-ce possible (en se référant aux numéros de comptabilité)?
  • Qu'est ce qu'il y a 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 int?

19
2017-10-20 13:18



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

Par exemple:

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

le Integer classe fournit également la valueOf(String str) méthode:

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

Nous pouvons également utiliser toInt(String strValue) de Classe d'utilitaire NumberUtils pour la conversion:

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

18
2017-10-20 09:51



J'ai une solution, mais je ne sais pas à quel point c'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 quelle étape correctement. J'ai attaché la fonction et testé:

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

16
2018-05-23 15:38