Comment convertir une chaîne en int en Java?




convertir string en int vba (24)

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 retourne primitive int .

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

Comment puis-je convertir une String en un 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 .


Utilisez Integer.parseInt () et insérez-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);
    }
 }

Guava a tryParse(String) , qui renvoie null si la chaîne ne peut pas être analysée, par exemple:

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

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.


Dans les concours de programmation, où vous êtes assuré que ce nombre sera toujours un entier valide, vous pouvez alors é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, assurez-vous de faire str = str.trim() avant de poursuivre le traitement.


Actuellement, je fais 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 avec le numéro 12, donc String number = "12";

Une autre limitation é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 chiffres), un caractère simple 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 à la mode 2/10 = 0.2 (d'où le double) 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'étaient 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

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 de 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 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 int?

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

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

Vous pouvez simplement essayer ceci:

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

Nous pouvons utiliser la parseInt(String str) de la classe d'encapsuleur Integer pour convertir une valeur String 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 Utility Class pour la conversion:

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

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.


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
  }

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

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

Consultez la documentation Java pour plus d'informations.


Comme mentionné précédemment, Apache Commons NumberUtils peut le faire. Quel retourne 0 s'il ne peut pas convertir string 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; 

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 entendu, le constructeur renverra 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);
}

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

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.

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


Vous pouvez aussi utiliser ce code avec quelques précautions.

  • Option n ° 1: Gérez explicitement l'exception, en affichant une boîte de dialogue de message, puis arrêtez l'exécution du workflow 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.


Utilisez Integer.parseInt(yourString)

Rappelez-vous 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 existe un seul type d'exception: NumberFormatException


Juste pour le plaisir: vous pouvez utiliser Java 8 Optional pour convertir une String en un 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);

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 d' Integer vous pouvez utiliser:

  1. Déballage:

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

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

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 ont fonctionné correctement. J'ai joint la fonction et tester:

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




type-conversion