Comment convertir une chaîne en int en Java?

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.

Est La 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 entier lance 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;
}

Actuellement, je fais un devoir pour le collège, 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 cela pourrait aider les 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 l'illustrerai en utilisant le nombre 12, donc String number = "12";

Une autre limitation était le fait que je impossible d'utiliser des cycles répétitifs, par conséquent, un cycle for (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 charAtl'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 la table 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 transformez-le en 12, il n'y a aucune opération mathématique que nous puissions faire.

Nous divisons ce dernier (lastdigit) par 10 de la manière 2/10 = 0.2 (d'où pourquoi doubler) comme ceci:

 lastdigit = lastdigit/10;

C'est simplement 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 les chiffres d'un nombre. Vous voyez, puisque nous ne considérons que 0-9, diviser par un multiple de 10 est comme créer une "boîte" où vous la 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
• Pas d'expressions "magiques" telles que parseInt

Une autre solution consiste à utiliser Apache Commons ' NumberUtils:

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

L'utilitaire Apache est bien car si la chaîne est un format de nombre invalide, 0 est toujours renvoyé. Donc vous sauver le bloc try catch.

Apache NumberUtils API de la Version 3.4

Integer.decode

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

Il fonctionne également pour la base 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 souhaitez obtenir int au lieu de Integer, vous pouvez utiliser:

1. Déballage:

   int val = Integer.decode("12"); 
   

2. intValue():

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

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 lancent 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 renvoyant un Optional<Integer>. Puisque Java n'offre pas une telle méthode, j'utilise ce qui suit wrapper:

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

Utilisation:

// 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.

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

• La chaîne ne contient-elle que des nombres 0-9?
• Quoi de neuf avec -/+ avant ou après la chaîne? Est-ce possible (en se référant aux numéros de comptabilité)?
• Quoi de neuf avec MAX_-/MIN_INFINITY? Que se passera-t-il si la chaîne est 9999999999999999999? La machine peut-elle traiter cette chaîne comme un int?

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

Par exemple:

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

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

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

, Nous pouvons également utiliser toInt(String strValue) de NumberUtils Classe Utilitaire pour la conversion:

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

Utiliser Integer.parseInt(yourString)

Rappelez-vous les choses suivantes:

Integer.parseInt("1"); // ok

Integer.parseInt("-1"); // ok

Integer.parseInt("+1"); // ok

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 que ce soit n'est pas autorisé)

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

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

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'autre part, j'ai fait quelques tests avec JUnit étape correctement. J'ai joint 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));
        }
    }
}

Méthodes pour le faire:

 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)

Entier.valueOf produit un objet entier, toutes les autres méthodes-primitif int.

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

, Juste pour le plaisir: Vous pouvez utiliser Java 8 Optional pour la conversion d'un String en Integer:

String str = "123";
Integer value = Optional.of(str).map(Integer::valueOf).get();
// Will return the integer value of the specified string, or it
// will throw an NPE when str is null.

value = Optional.ofNullable(str).map(Integer::valueOf).orElse(-1);
// Will do the same as the code above, except it will return -1
// when srt is null, instead of throwing an NPE.

Ici, nous combinons Integer.valueOf et Optinal. Il peut probablement y avoir des situations où cela est utile - par exemple lorsque vous voulez éviter les vérifications nulles. Le code pré Java 8 ressemblera à ceci:

Integer value = (str == null) ? -1 : Integer.parseInt(str);

Guava a tryParse (String) , qui renvoie null si 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'int:

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

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

En dehors de ces réponses ci-dessus, je voudrais ajouter plusieurs fonctions:

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

Et voici les résultats pendant que vous les exécutez:

  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
  }

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

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

• Option #1: Gérer explicitement l'exception, par exemple, afficher une boîte de dialogue de message, puis arrêter 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;
  }
  

En utilisant une constante de chaîne pour la comparaison ou toute sorte de l'informatique est toujours une bonne idée, car une constante ne renvoie jamais une valeur nulle.

Comme mentionné Apache Commons NumberUtils peut le faire. Qui renvoie 0 s'il ne peut pas convertir la chaîne en int.

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; 

Dans les concours de programmation, où vous êtes assuré que number sera toujours un entier valide, vous pouvez écrire votre propre méthode pour analyser l'entrée. Cela ignorera 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 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 nombres, puis assurez-vous de faire un str = str.trim() avant de poursuivre le traitement.

, vous pouvez essayer ceci:

• Utiliser Integer.parseInt(your_string); pour convertir un String à int
• Utiliser 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 le générateur de chaînes et le 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.

C'est parti

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

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

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

Java 8 - Entier(String).

Bien sûr, le constructeur renverra le type Integer, et l'opération de déballage convertit la valeur en int.

Il est important de mentionner
Ce constructeur appelle la méthode parseInt.

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

Une méthode est parseInt (String) renvoie une primitive int

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

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

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

Utilisez un entier.parseInt() et le mettre dans un bloc try...catch pour gérer les erreurs juste au cas où un caractère non numérique est 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);
    }
 }

C'est un programme complet avec toutes les conditions positives, négatives sans utiliser la 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;
     }
    }

Soit dit en passant, sachez que si la chaîne est null, l'appel:

int i = Integer.parseInt(null);

Lance NumberFormatException, pas NullPointerException.