java - convertir string en int vba




Comment convertir une chaîne en int en Java? (20)

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 .


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

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

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; 

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?

Et c'est parti

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

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

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

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

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 .


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

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.


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

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.


Une autre solution consiste à utiliser NumberUtils d' Apache Commons :

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

L'utilitaire Apache est pratique 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.

Apache NumberUtils API version 3.4


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


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

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.


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

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.





type-conversion