92 Comments:

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

    se guardate la Documentazione Java noterete che la "cattura" è che questa funzione può lanciare un NumberFormatException, che naturalmente è necessario gestire:

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

    (questo trattamento predefinito un numero malformato a 0, ma si può fare qualcos'altro, se volete.)

    in alternativa, è possibile utilizzare un metodo Ints dalla libreria Guava, che in combinazione con Java 8 Optional, rende un modo potente e conciso per convertire una stringa in un int:

    import com.google.common.primitives.Ints;
    
    int foo = Optional.ofNullable(myString)
     .map(Ints::tryParse)
     .orElse(0)
    
    1. oltre a catturare una NumberFormatException, l'utente dovrebbe anche fare attenzione sulla lunghezza delle stringhe che stanno passando in; se sono abbastanza lunghi per overflow un intero, si potrebbe prendere in considerazione utilizzando Long:: parseLong invece.
    1. @Allison specialmente se si utilizza un campo BIGINT in un campo PostgreSQL automatico incrementato per esempio. molto più sicuro da usare a lungo
    1. si potrebbe verificare se la stringa è un Numero primo: https://stackoverflow.com/questions/1102891/how-to-check-if-a-string-is-numeric-in-java
    1. questo metodo fa eccezione anche quando string non è un intero parsable nella base 10. utilizzare il metodo sovraccarico per lavorare in altre basi. ad es. per esempio Integer.parseInt ("1001", 8); per base 8. fonte.
    1. se si utilizza Integer.parseInt preparare a metterlo all'interno di un blocco di cattura provare dal momento che questo getterà sono numberformat o InputMismatch Exception se non è un numero valido. poi in questo caso hanno corretta gestione eccezione a livello di blocco cattura. altrimenti, come indicato di seguito è anche possibile utilizzare la classe Integer e poi convertirlo in int.
  2. per esempio, ecco due modi:

    Integer x = Integer.valueOf(str);
    // or
    int y = Integer.parseInt(str);
    

    c'è una leggera differenza tra questi metodi:

    • valueOf restituisce una istanza nuova o memorizzata nella cache di java.lang.Integer
    • parseInt restituisce primitivo int.

    lo stesso vale per tutti i casi: Short.valueOf / parseShort, Long.valueOf / parseLong, ecc.

    1. @PaulVerest non riesco a farlo... valueOf si chiama ricorsivamente?
    1. @user463035818 valore ha due sovraccarichi - per int e String. valueOf(String) è implementato analizzando prima la Stringa ad un int usando parseInt(String) e poi avvolgendo l'int in un Integer usando valueOf(int). nessuna ricorsione qui perché valueOf(String) e valueOf(int) sono due funzioni completamente diverse, anche se hanno lo stesso nome.
  3. bene, un punto molto importante da considerare è che il parser Integer getta NumberFormatException come dichiarato 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.
    }
    

    e 'importante gestire questa eccezione quando si cerca di ottenere valori interi da argomenti divisi o analizzare dinamicamente qualcosa.

    1. come posso analizzare "26263Hello"? voglio estrarre 26263 in quel caso
    1. @user463035818 - Vedi https://docs.oracle.com/javase/8/docs/api/java/util/regex/package-summary.html - un modello di espressione regolare di "([0-9]+)" "cattura" la prima sequenza di una o più cifre da uno a nove. guarda la classe Matcher in quel pacchetto.
  4. farlo manualmente:

    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;
    }
    
    1. cosa succede se l'input è maggiore di 2 ^ 32? cosa succede se l'input contiene caratteri non numerici?
    1. una delle cose che un programmatore deve imparare a unire la forza lavoro, se non prima, non è mai di reinventare ruote. questo può essere un esercizio divertente, ma non aspettatevi il vostro codice di passare revisione del codice se si fa questo tipo di cosa in un ambiente commerciale.
    1. @yohm quelli sono caso speciale; è possibile gestire con lungo e qualche regex; tuttavia, da allora è possibile utilizzare parseInt.
    1. -1 Siamo spiacenti, ma questo è un algoritmo piuttosto povero, con molte limitazioni, nessuna gestione degli errori, e alcune anomalie strane (ad esempio "" dà un'eccezione, "-" produrrà 0, e "+" produce -5). perché chiunque sceglierebbe questo su Integer.parseInt(s)? - Vedo il punto su questo essere una domanda di intervista, ma a) che non implica che faresti in questo modo (che è quello che il interrogante ha chiesto), e b) questa risposta è un esempio abbastanza male comunque.
    1. -1 perché se voglio analizzare una base 31 int? Integer.parseInt (str, 31) è un unico liner per farlo. commento leggermente faceto, ma punto serio sotto. mai re-inventare ruote quando qualcun altro ha già messo il lavoro in
  5. puoi anche iniziare rimuovendo tutti i caratteri non numerici e poi analizzare l'int:

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

    ma attenzione che questo funziona solo per i numeri non negativi.

    1. sì, questo funziona solo per i numeri non negativi che sono corretti per cominciare e, quindi, non hanno bisogno di questo passo di sostituzione. per ogni altro caso, questo tentativo di risolvere automaticamente, peggiorare le cose (come quasi ogni tentativo di risolvere automaticamente qualcosa). se passo in "4+2", Otterrò 42 di conseguenza, senza alcun accenno su che quello che ho cercato di fare era sbagliato. l'utente avrà l'impressione che inserire espressioni di base come 4+2 sia stato un input valido, ma l'applicazione continua con un valore sbagliato. inoltre, il tipo è String, non string...
    1. oppure modificare la prima riga to-- > stringa mystr.replaceAll ("[^ & # 92; d & # 92; -]", ");
    1. @Holger Se ho visto qualcuno scrivere questo al lavoro, li sposterei dalla mia squadra. sarebbe fallire la revisione con un raggio abbastanza importante esplosione. non c "è praticamente nessun caso in cui faccia la Cosa Destra: produce risultati inaspettati, strani," WTF ". per favore, nessuno fa questo!
  6. convertire una stringa in un int è più complicato di un numero. avete in mente le seguenti questioni:

    • la stringa contiene solo i numeri 0-9?
    • cosa succede con - / + prima o dopo la stringa? è possibile (facendo riferimento ai numeri contabili)?
    • cosa succede con MAX _ - / MIN _ INFINITY? cosa accadrà se la stringa è 99999999999999999999? la macchina può trattare questa stringa come un int?
    1. sì - e c'è un caso brutto bordo intorno -2 ^ 31. se provate a negare 2 ^ 31, potreste incorrere in difficoltà......
  7. attualmente sto facendo un incarico per l'università, in cui non posso usare determinate espressioni, come quelle sopra e guardando la tabella di ASCII, sono riuscito a farlo. è un codice molto più complesso, ma potrebbe aiutare altri che sono limitati 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'altra limitazione era il fatto che non potevo usare cicli ripetitivi, quindi, un ciclo for (che sarebbe stato perfetto) non può essere utilizzato. questo ci limita un po ', ma poi ancora, questo è l'obiettivo. dato che avevo bisogno solo di due cifre (prendendo le ultime due cifre), un semplice charAt lo ha 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, basta guardare in alto la tabella, e apportare le necessarie regolazioni:

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

    ora, perché raddoppiare? beh, a causa di un passo davvero "strano". attualmente abbiamo due doppi, 1 e 2, ma dobbiamo trasformarlo in 12, non c'è alcuna operazione matematica che possiamo fare.

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

     lastdigit = lastdigit/10;
    

    questo è solo 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 nella matematica, stiamo semplicemente isolando le unità le cifre di un numero. si vede, dal momento che consideriamo solo 0-9, dividere per un multiplo di 10 è come creare una "scatola" in cui si memorizza (pensare indietro a quando il vostro insegnante di primo grado vi ha spiegato che cosa un unità e un centinaio erano). così: così:

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

    e là si va. hai trasformato una Stringa di cifre (in questo caso, due cifre), in un intero composto da quelle due cifre, considerando le seguenti limitazioni:

    • nessun ciclo ripetitivo
    • nessuna espressione "magica" come parseInt
    1. usare il tipo double per analizzare un intero non è solo una cattiva idea in termini di prestazioni. valori come 0.2 sono numeri periodici nella rappresentazione in virgola mobile e non possono essere rappresentati con precisione. provate System.out.println (0.1 + 0.2) per vedere il punto -- il risultato non sarà 0.3! meglio attaccare con il codice della libreria wherever è possibile, in questo caso Integer.parseInt ().
    1. non è chiaro che tipo di problema questa risposta cerca di risolvere, in primo luogo, perché qualcuno dovrebbe mai avere quella restrizione si descrive, in secondo luogo, perché si deve guardare una tabella ASCII come si può semplicemente utilizzare '0' per il carattere invece di 48 e non devono mai preoccuparsi con il suo valore numerico effettivo. in terzo luogo, l'intera deviazione con double valori non ha alcun senso, come si sta dividendo per dieci, solo per moltiplicare con dieci in seguito. il risultato è semplicemente semilastdigit * 10 + lastdigit come appreso nella scuola elementare, quando è stato introdotto il sistema decimale...
    1. @Holger Mi è stato dato personalmente che la restrizione al primo avvio di programmazione, e anche quando ho dovuto scrivere (penna / carta) interazioni simili in un test. non è comune, ma è un metodo che è facilmente comprensibile e pur non essendo il più efficiente per miglia è un metodo che funziona abbastanza decentemente per piccoli progetti. SO.SE è destinato ad aiutare tutti, non solo alcuni. ho fornito un metodo alternativo, per coloro che stanno iniziando da imparare a creare uno pseudo-algoritmo e trasformarlo in un algoritmo piuttosto che utilizzare espressioni java premade. anche se ho dimenticato che '0' è freddo
    1. perché dividere tutto per 10 poi moltiplicare di nuovo per 10 alla fine?! inoltre, "parseInt" non è magia e non è un'espressione, è una funzione libreria integrato che è stato testato e dimostrato in quasi 3 decenni
  8. ho una soluzione, ma non so quanto sia efficace. ma funziona bene, e penso che si potrebbe migliorare. d'altra parte, ho fatto un paio di test con JUnit che passo 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));
            }
        }
    }
    
    1. si può fare più semplice: (int) Double.parseDouble(input.replaceAll("[^0-9\\.\\-]", ""));
    1. raramente si desidera che 0 sia utilizzato quando un numero non valido viene analizzato.
    1. zero è ciò che Java usa come default se un campo int su un oggetto non è impostato. quindi in questo senso ha senso.
    1. @Ryboflavin No, non lo fa. uno di questi è un linguaggio ben definito semantica, e l'altro è un'eccezione
  9. possiamo usare il metodo parseInt(String str) della classe wrapper Integer per convertire un valore String in un valore intero.

    per esempio:

    String strValue = "12345";
    Integer intValue = Integer.parseInt(strVal);
    

    la classe Integer fornisce anche il metodo valueOf(String str):

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

    possiamo anche utilizzare toInt(String strValue) di NumberUtils classe Utility per la conversione:

    String strValue = "12345";
    Integer intValue = NumberUtils.toInt(strValue);
    
  10. è possibile utilizzare questo codice anche, con alcune precauzioni.

    • opzione # 1: gestire l'eccezione esplicitamente, per esempio, mostrando una finestra di dialogo dei messaggi e quindi interrompere l'esecuzione del flusso di lavoro corrente. per esempio:

      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;
      }
      
    • opzione # 2: resettare la variabile interessata se il flusso di esecuzione può continuare in caso di eccezione. per esempio, con alcune modifiche nel blocco di cattura

      catch (NumberFormatException ex) {
          integerValue = 0;
      }
      

    usare una stringa costante per il confronto o qualsiasi tipo di calcolo è sempre una buona idea, perché una costante non restituisce mai un valore nullo.

    1. mettere JOptionPane.showMessageDialog() nella risposta alla domanda vaniglia Java non ha senso.
  11. Integer.decode

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

    funziona anche per 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 si desidera ottenere int invece di Integer è possibile utilizzare:

    1. unboxing:

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

      Integer.decode("12").intValue();
      
    1. finalmente! finalmente! qualcuno che in realtà si preoccupa di pubblicare i risultati / output delle conversioni! si può anche aggiungere alcuni con "-" segni?
  12. ogni volta che c'è la minima possibilità che la stringa data non contiene un Integer, è necessario gestire questo caso speciale. purtroppo, i metodi standard Java Integer::parseInt e Integer::valueOf gettano un NumberFormatException per segnalare questo caso speciale. quindi, è necessario utilizzare le eccezioni per il controllo del flusso, che è generalmente considerato cattivo stile di codifica.

    a mio parere, questo caso speciale dovrebbe essere gestito restituendo un Optional<Integer>. dal momento che Java non offre un tale metodo, Io uso il seguente wrapper:

    private Optional<Integer> tryParseInteger(String string) {
        try {
            return Optional.of(Integer.valueOf(string));
        } catch (NumberFormatException e) {
            return Optional.empty();
        }
    }
    

    uso: uso:

    // prints 1234
    System.out.println(tryParseInteger("1234").orElse(-1));
    // prints -1
    System.out.println(tryParseInteger("foobar").orElse(-1));
    

    mentre questo sta ancora usando le eccezioni per il controllo del flusso internamente, il codice di utilizzo diventa molto pulito.

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

    assicurarsi che non ci siano dati non numerici nella stringa.

    1. non c'è alcun valore per il sito, nel ripetere una risposta che qualcun altro ha postato CINQUE ANNI prima di voi.
  14. come accennato Apache Commons NumberUtils può farlo. che restituisce 0 se non è possibile convertire stringa in int.

    è inoltre possibile definire il proprio valore di default.

    NumberUtils.toInt(String str, int defaultValue)
    

    esempio: 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; 
    
  15. oltre a queste risposte di cui sopra, vorrei aggiungere diverse funzioni. questi sono risultati mentre li usate:

      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
      }
    

    implementazione:

       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;
      }
    
  16. guava ha tryParse (String), che restituisce null se la stringa non può essere analizzata, per esempio:

    Integer fooInt = Ints.tryParse(fooString);
    if (fooInt != null) {
      ...
    }
    
  17. per la stringa normale è possibile utilizzare:

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

    per String builder e String buffer è possibile utilizzare:

    Integer.parseInt(myBuilderOrBuffer.toString());
    
  18. solo per divertimento: è possibile utilizzare Java 8 di Optional per convertire un String in 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.
    

    qui si combinano solo Integer.valueOf e Optinal. probabilmente ci potrebbero essere situazioni in cui questo è utile - per esempio quando si vuole evitare controlli nulli. pre Java 8 codice sarà simile a questo:

    Integer value = (str == null) ? -1 : Integer.parseInt(str);
    
    1. Return -1 in caso di null sembra davvero strano... cosa succede se voglio parse "-1" stringa?
  19. qui andiamo noi

    String str="1234";
    int number = Integer.parseInt(str);
    print number;//1234
    
  20. è possibile utilizzare new Scanner("1244").nextInt(). o chiedere se esiste anche un int: new Scanner("1244").hasNextInt()

  21. nei concorsi di programmazione, dove siete sicuri che il numero sarà sempre un numero intero valido, allora potete scrivere il vostro proprio metodo per analizzare l'input. questo salterà tutto il codice relativo alla validazione (dato che non ne avete bisogno) e sarà un po 'più efficiente.

    1. per un numero 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 gli 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 si aspetta uno spazio bianco prima o dopo questi numeri, quindi assicurarsi di fare un str = str.trim() prima di elaborare ulteriormente.

  22. in alternativa, è possibile utilizzare Integer.valueOf(). restituisce un oggetto Integer.

    String numberStringFormat = "10";
    Integer resultIntFormat = Integer.valueOf(numberStringFormat);
    LOG.info("result:"+resultIntFormat);
    

    uscita: 10

  23. 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);
    
  24. questo è Programma completo con tutte le condizioni positivo, negativo senza utilizzare 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;
         }
        }
    
    1. @TobiasWeimer sì, possiamo fare, ma questo è senza utilizzare la libreria
    1. @TobiasWeimer, alcune persone hanno bisogno di questo come fare a meno di usare Library.
    1. no, nessuno ne ha bisogno perché è una funzione all'interno del JDK, non alcuni plugin di terze parti.
  25. semplicemente potete provare questo:

    • utilizzare Integer.parseInt(your_string); per convertire un String a int
    • utilizzare Double.parseDouble(your_string); per convertire un String a double

    esempio di esempio

    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
    
    1. questa risposta non sembra aggiungere nulla al di là delle risposte raccomandando Integer.parseInt pubblicato pochi anni prima (convertire String in doppio sarebbe una domanda diversa).
  26. 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 oggetti Integer, tutti gli altri metodi - int primitivo.

    ultimi 2 metodi da commons-lang3 e grande articolo sulla conversione qui.

  27. utilizzare Integer.parseInt(yourString)

    ricordate le seguenti cose:

    Integer.parseInt("1"); / / ok

    Integer.parseInt("-1"); / / ok

    Integer.parseInt("+1"); / / ok

    Integer.parseInt(" 1"); / / Eccezione (spazio vuoto)

    Integer.parseInt("2147483648"); / / Eccezione (Integer è limitato ad un valore massimo di 2.147,483,647)

    Integer.parseInt("1.1"); / / Eccezione (. o, o qualsiasi cosa non sia consentita)

    Integer.parseInt(""); / / Eccezione (non o qualcosa)

    esiste un solo tipo di eccezione: NumberFormatException

  28. utilizzare Integer.parseInt () e metterlo all'interno di un blocco try...catch per gestire eventuali errori nel caso in cui venga inserito un carattere non numerico, per esempio

    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);
        }
     }
    
  29. sono un po 'sorpreso che nessuno abbia menzionato Integer costruttore che prende String come parametro.
    quindi, ecco:

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

    Java 8 - Integer (String).

    naturalmente, il costruttore restituisce il tipo Integer, e unboxing operazione converte valore a int.



    e 'importante menzionare
    Questo costruttore chiama parseInt metodo.

    public Integer(String var1) throws NumberFormatException {
        this.value = parseInt(var1, 10);
    }
    
  30. a proposito, essere consapevoli che se la stringa è nulla, la chiamata:

    int i = Integer.parseInt(null);
    

    lancia NumberFormatException, non NullPointerException.

  31. l'int statico pubblico parseInt (String s) lancia NumberFormatException

    è possibile utente Integer.parseInt() per convertire una stringa di int.

    convertire una Stringa 20 in un int primitivo.

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

    Output-20

    se la stringa non contiene un numero intero parziale. sarà gettato NumberFormatException

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

    pubblico statico valore Integer di (String s) getta NumberFormatException

    è possibile utilizzare Integer.valueOf(), in questo verrà restituito un oggetto Integer.

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

    Output-20

    riferimenti https://docs.oracle.com/en/

  32. utilizzare Integer.parseInt(), questo vi aiuterà a analizzare il valore della stringa di int.

    esempio: esempio:

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

    uscita: 2017

  33. prova questo codice con diversi input di 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();
        }
    }
    
  34. può essere fatto in 7 modi:

    import com.google.common.primitives.Ints;
    import org.apache.commons.lang.math.NumberUtils;
    
    String number = "999";
    

    1) Uso di Ints.tryParse:

    int result = Ints.tryParse(number);
    

    2) Utilizzo di NumberUtils.createInteger:

    Integer result = NumberUtils.createInteger(number);
    

    3) Utilizzo di NumberUtils.toInt:

    int result = NumberUtils.toInt(number);
    

    4) Uso di Integer.valueOf:

    Integer result = Integer.valueOf(number);
    

    5) Uso di Integer.parseInt:

    int result = Integer.parseInt(number);
    

    6) Utilizzo di Integer.decode:

    int result = Integer.decode(number);
    

    7) Utilizzo di Integer.parseUnsignedInt:

    int result = Integer.parseUnsignedInt(number);
    
  35. convertire una stringa in un intero con il metodo parseInt della classe Java Integer. il metodo parseInt è quello di convertire la stringa in un int e lancia un NumberFormatException se la stringa non può essere convertita in un tipo int.

    trascurando l'eccezione che può gettare, usare questo:

    int i = Integer.parseInt(myString);
    

    se la stringa significata dalla variabile myString è un intero valido come “1234”, “200”, “1”, e sarà convertito in un int Java. se fallisce per qualsiasi motivo, il cambiamento può lanciare un NumberFormatException, quindi il codice dovrebbe essere un po 'più a lungo per spiegare questo.

    ex. ex. Java String a int metodo di conversione, il controllo per un possibile 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());
        }
      }
    }
    

    se il tentativo di modifica fallisce - nel caso in cui, se si può provare a convertire il test Java String in un int - il processo Integer parseInt lancerà un NumberFormatException, che è necessario gestire in un try / catch block.

  36. import java.util.*;
    
    public class 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);
        }
    }
    
  37. è possibile utilizzare il metodo Integer.parseInt()

    esempio: esempio:

    String strNumber = "5790";
    int extractNumber = Integer.parseInt(strNumber);
    
    //Result will be --5790
    System.out.println(extractNumber);
    
    
  38. ho scritto questo metodo veloce per analizzare un input di stringa in int o long. è più veloce del JDK 11 Integer.parseInt o Long.parseLong. anche se, hai solo chiesto int, Ho anche incluso il parser lungo. il parser di codice qui sotto richiede che il metodo del parser deve essere piccolo affinchè funzioni rapidamente. una versione alternativa è sotto il codice di prova. la versione alternativa è abbastanza veloce e non dipende dalle dimensioni della classe.

    questo controllo di classe per overflow e si potrebbe personalizzare il codice per adattarsi alle vostre esigenze. una stringa vuota darà 0 con il mio metodo ma quello è intenzionale. è possibile modificare che per adattare il vostro caso o utilizzare come è.

    questa è solo la parte della classe in cui parseInt e parseLong sono necessari. si noti che si tratta solo di base 10 numeri.

    il codice di test per l'int parser è sotto il codice qui sotto.

    /*
     * 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 - kevin@fai.host.
     **/
    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;
        }
    }
    

    sezione Codice test. questo dovrebbe richiedere circa 200 secondi o giù di lì.

    // 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 */
    

    un metodo alternativo che è anche molto veloce. si noti che array di int pow non viene utilizzato, ma un'ottimizzazione matematica di moltiplicare per 10 per bit shifting.

    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;
    }
    
  39. alcuni dei modi per convertire String in Int sono i seguenti:

    1. è possibile utilizzare Integer.parseInt():

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

    2. inoltre è possibile utilizzare Integer.valueOf():

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

  40. è possibile utilizzare uno dei seguenti:

    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)
  41. utilizzare questo metodo:

    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;
    }
    
  42. algoritmo personalizzato:

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

    un'altra soluzione: (usare il metodo string charAt invece di convertire stringa in array byte):

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

    esempi: esempi:

    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());
    }
    
  43. utilizzando il metodo: Integer.parseInt(String s)

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

More similar articles:

  • come convertire una Stringa in un InputStream in Java?
  • come convertire una Stringa con decimali in BigDecimal e mantenere i decimali, in Talend Java?
  • come posso convertire C # Stringa in Java.Lang.String?
  • come convertire Stringa per int
  • come scrivere un calcolo usando una Stringa e convertire il risultato in un nuovo Doppio correttamente?
  • convertire Stringa non numerica in Integer?
  • in una Stringa, come posso separare e memorizzare i caratteri e gli interi?
  • convertire una parola di input dell'utente in un array Unicode in Java
  • come convertire stringa come 0x000 per int
  • come convertire array di int in stringa?
  • come posso convertire String in Int?
  • convertire Lista <string>in Stringa [] in Java</string>
  • come convertire una parte di una stringa in int in C?
  • come convertire un java linked list di una rappresentazione binaria di un numero in una Stringa della rappresentazione decimale di un numero?
  • convertire Lista della Stringa in Lista del BigDecimale in Java
  • come convertire una Stringa in Integer e provarlo?
  • come convertire più numeri in una stringa in int
  • convertire Parte di una Stringa con un decimale in un Int in Python
  • convertire Java a lungo per int64 in C ++
  • convertire un int in una Stringa e poi cifrarlo con XOR
  • convertire da 2 o 4 byte a breve/int firmato/non firmato
  • PowerShell è lento per convertire interi in stringhe
  • il modo migliore per convertire una Stringa in un Integer o Naturale in Idris
  • convertire un array di byte in un array int in java
  • più efficiente per convertire la stringa in int o inverso?
  • come posso convertire una Stringa in un Integer o Float in Crystal?
  • convertire array di caratteri in un array di uint32_t in C-- è il modo corretto?
  • convertire Stringa in formato esadecimale piccolo endido in C ++
  • necessità di convertire una serie di 4 byte in un int
  • convertire byte per int utilizzando operators bit wise