Comment convertir une chaîne en int en Java?

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.

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)

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.

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.

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

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

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

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

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.

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?

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 .

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

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

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

Google Guava a tryParse (String) , qui retourne nullsi la chaîne n'a pas pu être analysée, par exemple:

Integer fooInt = Ints.tryParse(fooString);
if (fooInt != null) {
  ...
}

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.

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

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;

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.

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

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.

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

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

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

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

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

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

Et c'est parti

String str="1234";
int number = Integer.parseInt(str);
print number;//1234

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

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

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)

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