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 retourne une instance nouvelle ou mise en cache de java.lang.Integer
• parseInt renvoie primitive int .

le même est 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 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 de split arguments ou de façon dynamique parsing 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 l'université, où je ne peux pas utiliser certaines expressions, comme celles ci-dessus, et en regardant la table ASCII, j'ai réussi à le faire. C'est un code beaucoup plus complexe, mais ça pourrait aider d'autres qui sont limités 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 numéro 12, donc String number = "12";

une autre limitation était le fait que je ne pouvais pas utiliser des cycles répétitifs, donc, un cycle for (qui aurait été parfait) ne peut pas être utilisé non plus. Cela nous limite un peu, mais encore une fois, c'est le but. Puisque je n'avais besoin que de deux chiffres (en prenant les deux derniers chiffres), un simple charAt 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, nous avons juste besoin de regarder la table, et faire les ajustements nécessaires:

 double semilastdigit = semilastdigitASCII - 48;  //A quick look, and -48 is the key
 double lastdigit = lastdigitASCII - 48;

maintenant, pourquoi doubler? Eh bien, parce que de un vraiment "bizarre". Actuellement nous avons deux doubles, 1 et 2, mais nous avons besoin de le transformer en 12, Il n'y a aucune opération mathématique que nous pouvons faire.

nous divisons ce dernier (lastdigit) par 10 de la façon 2/10 = 0.2 (d'où pourquoi double) comme ceci:

 lastdigit = lastdigit/10;

ce n'est qu'un jeu de chiffres. On transformait 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 maths, 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 l'entreposez (rappelez-vous quand votre professeur de première année vous a expliqué ce qu'étaient une unité et une centaine d'unités). So:

 int finalnumber = (int) (jointdigits*10); // Be sure to use parentheses "()"

et voilà. Vous avez tourné une Chaîne de chiffres (dans ce cas, deux chiffres), en un entier composé de ces deux chiffres, considérant les limitations suivantes:

• pas de cycles répétitifs
• Aucune "Magie" des Expressions telles que parseInt

une autre solution consiste à utiliser Apache Commons' NumberUtils:

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

L'utilitaire Apache est agréable parce que si la chaîne est un format de nombre invalide alors 0 est toujours retourné. Par conséquent vous sauver le bloc d'essai de capture.

Apache NumberUtils API Version 3.4

Integer.decode

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

il travaille aussi 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 voulez obtenir int au lieu de Integer vous pouvez utiliser:

1. Unboxing:

   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 jettent un 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 mauvais style de codage.

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

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 encore des exceptions pour le contrôle du débit 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 devez penser aux questions suivantes:

• la chaîne ne contient-elle que les numéros 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 Compte)?
• Quoi de neuf avec MAX_-/MIN_INFINITY? Ce sera arrive si la chaîne est 999999999999999999? La machine peut-elle traiter cette chaîne comme un int?

nous pouvons utiliser la méthode parseInt(String str) de la classe 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 comprend également la méthode valueOf(String str) :

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

nous pouvons également utiliser toInt(String strValue) de classe utilitaire numéros pour la conversion:

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

Utilisation Integer.parseInt(yourString)

souvenez-vous des 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 tout ce qui n'est pas autorisé)

Integer.parseInt(""); // Exception (et non de 0 ou de quelque chose)

il n'y a qu'un seul type d'exception: NumberFormatException

j'ai une solution, mais je ne sais pas si elle est efficace. Mais il fonctionne bien, et je pense que vous pourriez améliorer. D'autre part, j'ai fait quelques tests avec JUnit une étape correctement. J'ai attaché la fonction et l'essai:

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

des Tests 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 objet entier, toutes les autres méthodes - primitive int.

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

juste pour le plaisir: vous pouvez utiliser Java 8 Optional pour convertir un 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 ne faisons que combiner Integer.valueOf et Optinal . Probablement il peut y avoir des situations où cela est utile - par exemple quand vous voulez éviter les vérifications nulles. Le code pre Java 8 ressemblera à ceci:

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

Guava a tryParse (String) , qui retourne null si la chaîne ne pouvait pas ê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 Parser l'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 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 demander si même un int existe: new Scanner("1244").hasNextInt()

vous pouvez utiliser ce code aussi, avec quelques précautions.

• Option # 1: gérer l'exception explicitement, par exemple, en montrant une boîte de dialogue message et puis arrêter l'exécution du flux de travail actuel. 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éinitialiser 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 n'importe quelle sorte de calcul est toujours une bonne idée, parce qu'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 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; 

dans les concours de programmation, où vous êtes assuré que le nombre sera toujours un entier valide, alors vous pouvez écrire votre propre méthode pour analyser les entrées. Cela sautera tout le code lié à la validation (puisque vous n'avez pas besoin de tout cela) et sera un peu plus efficace.

1. pour 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, ensuite, assurez-vous de faire un str = str.trim() avant de poursuivre le traitement.

simplement vous pouvez essayer ceci:

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

pour la chaîne normale vous pouvez utiliser:

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

pour le constructeur de chaîne et le tampon de chaîne 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.

Here we go

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

je suis un peu surpris que personne n'ait mentionné le constructeur entier qui prend String comme paramètre.

Donc, voici:

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

Java 8 - Integer(String) .

bien sûr, le constructeur retournera le type Integer , et l'opération de décompression 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 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);

Utiliser Entier.parseInt () et mettez-le dans un bloc try...catch pour gérer toutes 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 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 nulle, l'appel:

int i = Integer.parseInt(null);

lance NumberFormatException, pas NullPointerException.