Comment convertir une chaîne en int en Java?

Question

Comment convertir une String en int en Java?

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

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

Answer 1

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

Si vous regardez la Documentation Java vous remarquerez que le "piège" est que cette fonction peut générer une NumberFormatException, que vous devez bien sûr gérer:

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

(Ce traitement attribue par défaut à 0 un nombre mal formé, mais vous pouvez faire autre chose si vous le souhaitez.)

Vous pouvez également utiliser une méthode Ints de la bibliothèque Guava, qui, combinée à Optional de Java 8, constitue un moyen puissant et concis de convertir une chaîne en chaîne de caractères int:

import com.google.common.primitives.Ints;

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

Answer 2

Par exemple, voici deux manières:

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 valable pour tous les cas: Short.valueOf/parseShort, Long.valueOf/parseLong, etc.

Answer 3

Un point très important à prendre en compte est que l’analyseur Integer lève une exception 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.

Answer 4

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

Answer 5

Actuellement, je suis en train de faire un travail pour l'université, où je ne peux pas utiliser certaines expressions, telles que celles ci-dessus, et en consultant le tableau ASCII, j'ai réussi à le faire. C'est un code beaucoup plus complexe, mais il pourrait aider d'autres personnes restreintes comme moi.

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 limite était le fait que je ne pouvais pas utiliser de cycles répétitifs. Par conséquent, un cycle for (qui aurait été parfait) ne pouvait pas être utilisé non plus. Cela nous limite un peu, mais là encore, c'est l'objectif. Comme je n'avais besoin que de deux chiffres (en prenant les deux derniers), un simple charAt 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);

Avec les codes, il suffit de regarder la table et d’apporter 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'un pas vraiment "bizarre". Nous avons actuellement deux doubles, 1 et 2, mais nous devons le transformer en 12, nous ne pouvons effectuer aucune opération mathématique.

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

 lastdigit = lastdigit/10;

C'est simplement jouer avec des nombres. Nous étions en train de transformer le dernier chiffre en un nombre décimal. Mais maintenant, regardez ce qui se passe:

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

Sans entrer trop dans les calculs, 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 revient à créer une "boîte" dans laquelle vous le stockez (rappelez-vous quand votre professeur de première année vous a expliqué ce qu'était une unité et cent). 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, en tenant compte des limitations suivantes:

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

Answer 6

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 numérique non valide, 0 est toujours renvoyé Par conséquent, vous économisez le bloc catch try.

API Apache NumberUtils version 3.4

Answer 7

Integer.decode

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

Cela fonctionne aussi 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();
   

Answer 8

Chaque fois qu'il y a la moindre possibilité que la chaîne donnée ne contienne pas un entier, vous devez gérer ce cas particulier. Malheureusement, les méthodes Java standard Integer::parseInt et Integer::valueOf jettent une NumberFormatException pour 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 style de code incorrect.

À mon avis, ce cas particulier devrait être traité en renvoyant un Optional<Integer>. Comme 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 encore des exceptions pour le contrôle de flux en interne, le code d'utilisation devient très propre.

Answer 9

Convertir une chaîne en un entier est plus compliqué que de convertir un nombre. Vous avez pensé aux points suivants:

• La chaîne ne contient-elle que des nombres 0-9?
• Qu'est-ce qui se passe 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 99999999999999999999? La machine peut-elle traiter cette chaîne comme un int?

Answer 10

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)

Integer.valueOf produit un objet Integer, toutes les autres méthodes - primitive int.

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

Answer 11

Nous pouvons utiliser la méthode parseInt(String str) de la classe wrapper Integer pour convertir une valeur String en 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 Utility, classe pour la conversion:

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

Answer 12

Utilisez Integer.parseInt(yourString)

N'oubliez pas 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 (le nombre entier est limité à 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 existe un seul type d'exception: NumberFormatException

Answer 13

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

Answer 14

Juste pour le plaisir: vous pouvez utiliser la variable Optional de Java 8 pour convertir une String en une 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 simplement Integer.valueOf et Optinal. Cela peut être utile dans certaines situations, par exemple lorsque vous souhaitez éviter les contrôles nuls. Le code pré-Java 8 ressemblera à ceci:

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

Answer 15

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) {
  ...
}

Answer 16

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

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

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

Answer 17

Outre les réponses ci-dessus, j'aimerais 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
  }

Answer 18

Dans les concours de programmation, où vous êtes assuré que ce nombre sera toujours un entier valide, vous pouvez écrire votre propre méthode pour analyser les entrées. 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 chiffres, alors assurez-vous de faire une str = str.trim() avant de poursuivre le traitement.

Answer 19

Comme mentionné précédemment, Apache Commons NumberUtils peut le faire. Quel retour 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; 

Answer 20

Vous pouvez aussi 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 n ° 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 à des fins de comparaison ou de tout type d'informatique est toujours une bonne idée, car une constante ne renvoie jamais une valeur nulle.

Answer 21

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

Answer 22

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

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

Answer 23

Pour une chaîne normale, vous pouvez utiliser:

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

Pour le constructeur de chaînes et le tampon de chaînes, vous pouvez utiliser:

Integer.parseInt(myBuilderOrBuffer.toString());

Answer 24

Vous pouvez simplement essayer ceci:

• Utilisez Integer.parseInt(your_string); pour convertir une String en int
• Utilisez Double.parseDouble(your_string); pour convertir une String en 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

Answer 25

Et c'est parti

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

Answer 26

Je suis un peu surpris que personne ne mentionne le constructeur Integer qui prend String en tant que paramètre.
Voici donc: 

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

Java 8 - Entier (Chaîne) . 

Bien sûr, le constructeur retournera le type Integer et l'opération unboxing convertira 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);
}

Answer 27

Utilisez Integer.parseInt () et placez-le dans un bloc try...catch pour gérer les erreurs 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);
    }
 }

Answer 28

Une des méthodes 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);

Answer 29

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

Answer 30

Integer.parseInt(myString); - utilisation de la classe wrapper

Answer 31

Peut être fait de 5 manières:

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

1) Utilisation de Ints.tryParse:

String number = "999";
int result = Ints.tryParse(number);

2) Utilisation de NumberUtils.createInteger:

String number = "999";
Integer result = NumberUtils.createInteger(number);

3) Utilisation de NumberUtils.toInt:

String number = "999";
int result = NumberUtils.toInt(number);

4) Utilisation de Integer.valueOf:

String number = "999";
Integer result = Integer.valueOf(number);

5) Utilisation de Integer.parseInt:

String number = "999";
int result = Integer.parseInt(number);

Answer 32

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

int i = Integer.parseInt(null);

lève NumberFormatException, pas NullPointerException.

Answer 33

importer Java.util. *;

classe publique strToint {

    public static void main(String[] args){

            String str = "123";

            byte barr[] = str.getBytes();

            System.out.println(Arrays.toString(barr));
            int result=0;
            for(int i=0;i<barr.length;i++){
                    //System.out.print(barr[i]+" ");
                    int ii = barr[i];
                    char a = (char)ii;
                    int no = Character.getNumericValue(a);
                    result=result*10+no;
                    System.out.println(result);

            }
            System.out.println("result:"+result);
    }

}

Answer 34

public static int parseInt (String s) lève une exception NumberFormatException

vous pouvez utiliser Integer.parseInt() pour convertir une chaîne en int.

convertir une chaîne 20 en une primitive int.

    String n = "20";
    int r = Integer.parseInt(n);//returns a primitive int       
    System.out.println(r);

Sortie-20

si la chaîne ne contient pas un entier analysable. il va jeter NumberFormatException

String n = "20I";// throwns NumberFormatException
int r = Integer.parseInt(n);
System.out.println(r);

public statique Integer valueOf (String s) lève NumberFormatException

vous pouvez utiliser Integer.valueOf(), dans ce cas, il retournera un objet Integer.

String n = "20";
Integer r = Integer.valueOf(n); //returns a new Integer() object.   
System.out.println(r);

Sortie-20

Références https://docs.Oracle.com/en/

Answer 35

Certaines des manières de convertir String en Int sont les suivantes:

1. vous pouvez utiliser Integer.parseInt():

   String test = "4568"; int new = Integer.parseInt(test);

2. vous pouvez aussi utiliser Integer.valueOf():

   String test = "4568"; int new =Integer.parseInt(test);

Answer 36

Convertissez une chaîne en un entier à l'aide de la méthode parseInt de la classe Java Integer. La méthode parseInt consiste à convertir la chaîne en un entier et jette un NumberFormatException si la chaîne ne peut pas être convertie en un type int.

En négligeant l'exception qu'il peut lancer, utilisez ceci:

int i = Integer.parseInt(myString);

Si la chaîne indiquée par la variable myString est un entier valide, tel que “1234”, “200”, “1”,, elle sera convertie en un entier Java. Si elle échoue pour une raison quelconque, la modification peut générer une NumberFormatException, le code devrait donc être un peu plus long pour en tenir compte.

Ex. Méthode de conversion Java String à int, contrôle pour une possible NumberFormatException

public class JavaStringToIntExample
{
  public static void main (String[] args)
  {
    // String s = "test";  // use this if you want to test the exception below
    String s = "1234";

    try
    {
      // the String to int conversion happens here
      int i = Integer.parseInt(s.trim());

      // print out the value after the conversion
      System.out.println("int i = " + i);
    }
    catch (NumberFormatException nfe)
    {
      System.out.println("NumberFormatException: " + nfe.getMessage());
    }
  }
}

Si la tentative de modification échoue (en l'occurrence, si vous pouvez essayer de convertir le test Java String en un entier), le processus Integer parseInt lancera une NumberFormatException, que vous devez gérer dans un bloc try/catch.

Answer 37

Vous pouvez utiliser la méthode parseInt  

  String SrNumber="5790";
int extractNumber = Integer.parseInt(SrNumber);
System.out.println(extractNumber);//Result will be --5790

Answer 38

Algorithme personnalisé:

public static int toInt(String value) {
  int output = 0;
  boolean isFirstCharacter = true;
  boolean isNegativeNumber = false;
  byte bytes[] = value.getBytes();
  for (int i = 0; i < bytes.length; i++) {
    char c = (char) bytes[i];
    if (!Character.isDigit(c)) {
      isNegativeNumber = (c == '-');
      if (!(isFirstCharacter && (isNegativeNumber || c == '+'))) {
        throw new NumberFormatException("For input string \"" + value + "\"");
      }
    } else {
      int number = Character.getNumericValue(c);
      output = output * 10 + number;
    }
    isFirstCharacter = false;
  }
  if (isNegativeNumber) output *= -1;
  return output;
}

autre solution: (utilisez la chaîne charAt à la place de la chaîne convertie en tableau d'octets):

public static int toInt(String value) {
  int output = 0;
  boolean isFirstCharacter = true;
  boolean isNegativeNumber = false;
  for (int i = 0; i < value.length(); i++) {
    char c = value.charAt(i);
    if (!Character.isDigit(c)) {
      isNegativeNumber = (c == '-');
      if (!(isFirstCharacter && (isNegativeNumber || c == '+'))) {
        throw new NumberFormatException("For input string \"" + value + "\"");
      }
    } else {
      int number = Character.getNumericValue(c);
      output = output * 10 + number;
    }
    isFirstCharacter = false;
  }
  if (isNegativeNumber) output *= -1;
  return output;
}

Exemples:

int number1 = toInt("20");
int number2 = toInt("-20");
int number3 = toInt("+20");
System.out.println("Numbers = " + number1 + ", " + number2 + ", " + number3);

try {
  toInt("20 Hadi");
} catch (NumberFormatException e) {
  System.out.println("Error: " + e.getMessage());
}

Answer 39

Utilisation de la méthode: Integer.parseInt(String s)

String s = "123";
int n = Integer.parseInt(s);

Answer 40

Utilisez Integer.parseInt(), cela vous aidera à analyser votre valeur de chaîne en int.

Exemple:

String str = "2017";
int i = Integer.parseInt(str);
System.out.println(i);

sortie: 2017

Answer 41

Utilisez cette méthode:

public int ConvertStringToInt(String number)
{
 int num = 0;
 try
 {
   int newNumber = Integer.ParseInt(number);
   num = newNumber;
 }
 catch(Exception ex)
 {
   num = 0;
   Log.i("Console",ex.toString);
 }
   return num;
}

Answer 42

Essayez ce code avec différentes entrées de String:

String a = "10";  
String a = "10ssda";  
String a = null; 
String a = "12102";

if(null != a) {
    try {
        int x = Integer.ParseInt(a.trim()); 
        Integer y = Integer.valueOf(a.trim());
        //  It will throw a NumberFormatException in case of invalid string like ("10ssda" or "123 212") so, put this code into try catch
    } catch(NumberFormatException ex) {
        // ex.getMessage();
    }
}

Answer 43

J'ai écrit cette méthode rapide pour analyser une entrée de chaîne dans int ou long. Il est plus rapide que l'actuel JDK 11 Integer.parseInt ou Long.parseLong. Bien que vous ayez seulement demandé int, j'ai également inclus l'analyseur long. L'analyseur de code ci-dessous nécessite que la méthode de l'analyseur soit petite pour pouvoir fonctionner rapidement. Une version alternative est sous le code de test. La version alternative est assez rapide et ne dépend pas de la taille de la classe.

Cette classe vérifie le débordement et vous pouvez personnaliser le code pour l'adapter à vos besoins. Une chaîne vide donnera 0 avec ma méthode, mais c'est intentionnel. Vous pouvez changer cela pour adapter votre cas ou utiliser tel quel. 

Ceci est seulement la partie de la classe où parseInt et parseLong sont nécessaires. Notez que cela ne concerne que les chiffres de base 10.

Le code de test de l'analyseur int est sous le code ci-dessous. 

/*
 * Copyright 2019 Khang Hoang Nguyen
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions
 * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 * @author: Khang Hoang Nguyen - [email protected].
 **/
final class faiNumber{        
    private static final long[] longpow = {0L, 1L, 10L, 100L, 1000L, 10000L, 100000L, 1000000L, 10000000L, 100000000L, 1000000000L,
                                           10000000000L, 100000000000L, 1000000000000L, 10000000000000L, 100000000000000L,
                                           1000000000000000L, 10000000000000000L, 100000000000000000L, 1000000000000000000L,
                                           };

    private static final int[] intpow = { 0, 1, 10, 100, 1000, 10000,
                                          100000, 1000000, 10000000, 100000000, 1000000000 
                                        };

    /**
     * parseLong(String str) parse a String into Long. 
     * All errors throw by this method is NumberFormatException.
     * Better errors can be made to tailor to each use case.
     **/
    public static long parseLong(final String str) { 
        final int length = str.length();
        if ( length == 0 ) return 0L;        

        char c1 = str.charAt(0); int start;

        if ( c1 == '-' || c1 == '+' ){
            if ( length == 1 ) throw new NumberFormatException( String.format("Not a valid long value. Input '%s'.", str) );
            start = 1;
        } else {
            start = 0;
        }
        /*
         * Note: if length > 19, possible scenario is to run through the string 
         * to check whether the string contains only valid digits.
         * If the check had only valid digits then a negative sign meant underflow, else, overflow.
         */
        if ( length - start > 19 ) throw new NumberFormatException( String.format("Not a valid long value. Input '%s'.", str) );

        long c; 
        long out = 0L;

        for ( ; start < length; start++){
            c = (str.charAt(start) ^ '0');
            if ( c > 9L ) throw new NumberFormatException( String.format("Not a valid long value. Input '%s'.", str) );
            out += c * longpow[length - start];
        }

        if ( c1 == '-' ){
            out = ~out + 1L;
            // if out > 0 number underflow(supposed to be negative).
            if ( out > 0L ) throw new NumberFormatException( String.format("Not a valid long value. Input '%s'.", str) );
            return out;
        }
        // if out < 0 number overflow(supposed to be positive).
        if ( out < 0L ) throw new NumberFormatException( String.format("Not a valid long value. Input '%s'.", str) );
        return out;
    }

    /**
     * parseInt(String str) parse a string into an int.
     * return 0 if string is empty. 
     **/
    public static int parseInt(final String str) { 
        final int length = str.length();
        if ( length == 0 ) return 0;        

        char c1 = str.charAt(0); int start; 

        if ( c1 == '-' || c1 == '+' ){
            if ( length == 1 ) throw new NumberFormatException( String.format("Not a valid integer value. Input '%s'.", str) );
            start = 1;
        } else {
            start = 0;
        }

        int out = 0; int c;
        int runlen = length - start;

        if ( runlen > 9 ) {
            if ( runlen > 10 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );

            c = (str.charAt(start) ^ '0');   // <- Any number from 0 - 255 ^ 48 will yield greater than 9 except 48 - 57
            if ( c > 9 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
            if ( c > 2 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
            out += c * intpow[length - start++];
        }

        for ( ; start < length; start++){
            c = (str.charAt(start) ^ '0');
            if ( c > 9 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
            out += c * intpow[length - start];
        }

        if ( c1 == '-' ){
            out = ~out + 1;
            if ( out > 0 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
            return out;
        }

        if ( out < 0 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
        return out;
    }
}

Section de code de test. Cela devrait prendre environ 200 secondes environ.

// Int Number Parser Test;
long start = System.currentTimeMillis();    
System.out.println("INT PARSER TEST");
for (int i = Integer.MIN_VALUE; i != Integer.MAX_VALUE; i++){
   if( faiNumber.parseInt(""+i) != i ) System.out.println("Wrong");
   if ( i == 0 ) System.out.println("HalfWay Done");
}

if( faiNumber.parseInt(""+Integer.MAX_VALUE) != Integer.MAX_VALUE ) System.out.println("Wrong");
long end = System.currentTimeMillis();
long result = (end - start);
System.out.println(result);        
// INT PARSER END */

Une méthode alternative qui est aussi très rapide. Notez que le tableau de la puissance n’est pas utilisé mais une optimisation mathématique consistant à multiplier par 10 par décalage de bits.

public static int parseInt(final String str) { 
    final int length = str.length();
    if ( length == 0 ) return 0;        

    char c1 = str.charAt(0); int start; 

    if ( c1 == '-' || c1 == '+' ){
        if ( length == 1 ) throw new NumberFormatException( String.format("Not a valid integer value. Input '%s'.", str) );
        start = 1;
    } else {
        start = 0;
    }

    int out = 0; int c;
    while( start < length && str.charAt(start) == '0' ) start++; // <-- This to disregard leading 0, can be removed if you know exactly your source does not have leading zeroes.
    int runlen = length - start;

    if ( runlen > 9 ) {
        if ( runlen > 10 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );

        c = (str.charAt(start++) ^ '0');   // <- Any number from 0 - 255 ^ 48 will yield greater than 9 except 48 - 57
        if ( c > 9 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
        if ( c > 2 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
        out = (out << 1) + (out << 3) + c; // <- alternatively this can just be out = c or c above can just be out;
    }

    for ( ; start < length; start++){
        c = (str.charAt(start) ^ '0');
        if ( c > 9 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
        out = (out << 1) + (out << 3) + c; 
    }

    if ( c1 == '-' ){
        out = ~out + 1;
        if ( out > 0 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
        return out;
    }

    if ( out < 0 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
    return out;
}