java da integer - Come posso convertire una stringa in un int in Java?




15 Answers

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

Vedere la documentazione Java per ulteriori informazioni.

to c++

Come posso convertire una String in un int in Java?

My String contiene solo numeri e voglio restituire il numero che rappresenta.

Ad esempio, data la stringa "1234" il risultato dovrebbe essere il numero 1234 .




Bene, un punto molto importante da considerare è che il parser Integer genera NumberFormatException come indicato in 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.
}

È importante gestire questa eccezione quando si tenta di ottenere valori interi da argomenti divisi o l'analisi dinamica di qualcosa.




Attualmente sto facendo un incarico per il college, dove non posso usare certe espressioni, come quelle sopra, e guardando la tabella ASCII, sono riuscito a farlo. È un codice molto più complesso, ma potrebbe aiutare gli altri a essere ristretti come me.

La prima cosa da fare è ricevere l'input, in questo caso, una stringa di cifre; Lo chiamerò String number , e in questo caso, lo esemplificerò usando il numero 12, quindi String number = "12";

Un altro limite era il fatto che non potevo usare cicli ripetitivi, quindi un ciclo for (che sarebbe stato perfetto) non può essere usato neanche. Questo ci limita un po ', ma poi di nuovo, questo è l'obiettivo. Poiché avevo solo bisogno di due cifre (prendendo le ultime due cifre), un semplice charAt risolto:

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

Avendo i codici, dobbiamo solo cercare il tavolo e apportare le modifiche necessarie:

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

Ora, perché raddoppiare? Bene, a causa di un passo davvero "strano". Attualmente abbiamo due doppi, 1 e 2, ma dobbiamo trasformarlo in 12, non ci sono operazioni matematiche che possiamo fare.

Dividiamo quest'ultimo (lastdigit) per 10 nel modo 2/10 = 0.2 (quindi perché doppio) in questo modo:

 lastdigit = lastdigit/10;

Questo è semplicemente giocare con i numeri. Stavamo trasformando l'ultima cifra in un decimale. Ma ora, guarda cosa succede:

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

Senza entrare troppo in matematica, stiamo semplicemente isolando le unità di un numero. Vedete, dal momento che consideriamo solo 0-9, dividendo per un multiplo di 10 è come creare una "scatola" in cui archiviarla (ripensateci quando il vostro insegnante di prima elementare vi spiegò che unità erano e cento). Così:

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

E tu ci vai. Hai trasformato una stringa di cifre (in questo caso, due cifre) in un numero intero composto da queste due cifre, considerando le seguenti limitazioni:

  • Nessun ciclo ripetitivo
  • Nessuna espressione "magica" come parseInt



Integer.decode

È anche possibile utilizzare public static Integer decode(String nm) throws NumberFormatException .

Funziona anche per la base 8 e 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

Se vuoi ottenere int invece di Integer puoi usare:

  1. unboxing:

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

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



Convertire una stringa in un int è più complicato della semplice conversione di un numero. Hai pensato ai seguenti problemi:

  • La stringa contiene solo numeri 0-9 ?
  • Che succede con - / + prima o dopo la stringa? È possibile (facendo riferimento ai numeri contabili)?
  • Che cosa succede con MAX _- / MIN_INFINITY? Cosa succederà se la stringa è 99999999999999999999? La macchina può trattare questa stringa come int?



Metodi per farlo:

 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 produce oggetto intero, tutti gli altri metodi - int primitivo.

Ultimi 2 metodi da commons-lang3 e un grande articolo sulla conversione here .




Ho una soluzione, ma non so quanto sia efficace. Ma funziona bene, e penso che potresti migliorarlo. D'altra parte, ho fatto un paio di test con JUnit che funzionano correttamente. Ho allegato la funzione e il test:

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



Guava ha tryParse(String) , che restituisce null se non è possibile analizzare la stringa, ad esempio:

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



Oltre a queste risposte sopra, vorrei aggiungere diverse funzioni:

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

E qui ci sono risultati mentre li esegui:

  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
  }



Nella programmazione delle competizioni, dove si è certi che il numero sarà sempre un numero intero valido, sarà possibile scrivere il proprio metodo per analizzare l'input. Questo salterà tutti i codici relativi alla validazione (dato che non ne hai bisogno) e sarà un po 'più efficiente.

  1. Per intero positivo valido:

    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. Per i numeri interi sia positivi che negativi:

    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. Se ti aspetti uno spazio bianco prima o dopo questi numeri, assicurati di fare uno str = str.trim() prima di procedere ulteriormente.




Come menzionato Apache Commons NumberUtils può farlo. Che restituisce 0 se non può convertire string in int.

Puoi anche definire il tuo valore predefinito.

NumberUtils.toInt(String str, int defaultValue)

esempio:

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; 



Per la stringa normale puoi usare:

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

Per il generatore di stringhe e il buffer delle stringhe è possibile utilizzare:

Integer.parseInt(myBuilderOrBuffer.toString());



Eccoci qui

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



Un metodo è parseInt (String) restituisce un int primitivo

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

Il secondo metodo è valueOf (String) restituisce un nuovo oggetto Integer ().

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



Questo è un programma completo con tutte le condizioni positive, negative senza usare la libreria

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



Related