Hoe converteer ik een string naar een int in Java?

Hoe kan ik een String converteren naar een int in Java?

Mijn string bevat alleen getallen en ik wil het getal teruggeven dat het vertegenwoordigt.

Bijvoorbeeld, gegeven de string "1234" zou het resultaat het getal 1234 moeten zijn.


Antwoord 1, autoriteit 100%

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

Als je kijkt naar de Java-documentatie zult u de "catch" is dat deze functie een NumberFormatException kan gooien, wat je natuurlijk moet doen:

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

(Deze behandeling zet een verkeerd opgemaakt getal standaard op 0, maar u kunt desgewenst iets anders doen.)

Als alternatief kunt u een Ints-methode uit de Guava-bibliotheek gebruiken, die in combinatie met Optional van Java 8 zorgt voor een krachtige en beknopte manier om een ​​tekenreeks om te zetten in een int:

import com.google.common.primitives.Ints;
int foo = Optional.ofNullable(myString)
 .map(Ints::tryParse)
 .orElse(0)

Antwoord 2, autoriteit 17%

Hier zijn bijvoorbeeld twee manieren:

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

Er is een klein verschil tussen deze methoden:

  • valueOf retourneert een nieuwe of in de cache opgeslagen instantie van java.lang.Integer
  • parseInt retourneert primitieve int.

Hetzelfde geldt voor alle gevallen: Short.valueOf/parseShort, Long.valueOf/parseLong, enz.


Antwoord 3, autoriteit 6%

Nou, een heel belangrijk punt om te overwegen is dat de Integer-parser NumberFormatException genereert zoals vermeld 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.
}

Het is belangrijk om met deze uitzondering om te gaan wanneer u gehele waarden probeert te krijgen uit gesplitste argumenten of bij het dynamisch ontleden van iets.


Antwoord 4, autoriteit 2%

Doe het handmatig:

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

Antwoord 5

Een alternatieve oplossing is het gebruik van Apache Commons’ NumberUtils:

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

Het Apache-hulpprogramma is leuk, want als de tekenreeks een ongeldig getalformaat heeft, wordt altijd 0 geretourneerd. Daarom bespaart u het try-catch-blok.

Apache NumberUtils API versie 3.4


Antwoord 6

Integer.decode

Je kunt ook public static Integer decode(String nm) throws NumberFormatException gebruiken.

Het werkt ook voor basis 8 en 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

Als u int wilt krijgen in plaats van Integer, kunt u het volgende gebruiken:

  1. Uitpakken:

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

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

Antwoord 7

Momenteel ben ik bezig met een opdracht voor de universiteit, waar ik bepaalde uitdrukkingen niet kan gebruiken, zoals de bovenstaande, en door naar de ASCII-tabel te kijken, is het me gelukt. Het is een veel complexere code, maar het kan anderen helpen die beperkt zijn zoals ik was.

Het eerste dat u moet doen, is de invoer ontvangen, in dit geval een reeks cijfers; Ik noem het String number, en in dit geval zal ik het illustreren met het getal 12, daarom String number = "12";

Een andere beperking was het feit dat ik geen repetitieve cycli kon gebruiken, daarom kan een for-cyclus (wat perfect zou zijn geweest) ook niet worden gebruikt. Dit beperkt ons een beetje, maar nogmaals, dat is het doel. Omdat ik maar twee cijfers nodig had (de laatste twee cijfers nemend), loste een simpele charAt het op:

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

Als we de codes hebben, hoeven we alleen maar naar de tafel te kijken en de nodige aanpassingen te maken:

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

Waarom verdubbelen? Nou, vanwege een echt "raar" stap. Momenteel hebben we twee doubles, 1 en 2, maar we moeten er 12 van maken, er is geen wiskundige bewerking die we kunnen doen.

We delen het laatste (laatste cijfer) door 10 op de manier 2/10 = 0.2 (vandaar waarom dubbel) als volgt:

 lastdigit = lastdigit / 10;

Dit is gewoon spelen met getallen. We veranderden het laatste cijfer in een decimaal. Maar kijk nu eens wat er gebeurt:

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

Zonder al te veel op de wiskunde in te gaan, isoleren we simpelweg eenheden van de cijfers van een getal. Zie je, aangezien we alleen rekening houden met 0-9, is delen door een veelvoud van 10 hetzelfde als het creëren van een "box" waar je het opslaat (denk terug aan de tijd dat je leraar in het eerste leerjaar je uitlegde wat een eenheid en honderd waren). Dus:

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

En daar ga je. U heeft een reeks cijfers (in dit geval twee cijfers) omgezet in een geheel getal bestaande uit die twee cijfers, rekening houdend met de volgende beperkingen:

  • Geen herhalende cycli
  • Geen "Magie" Expressies zoals parseInt

Antwoord 8

Als er ook maar de geringste mogelijkheid is dat de gegeven string geen geheel getal bevat, moet je met dit speciale geval omgaan. Helaas geven de standaard Java-methoden Integer::parseInt en Integer::valueOf een NumberFormatException om dit speciale geval te signaleren. Je moet dus uitzonderingen gebruiken voor flow control, wat over het algemeen als een slechte codeerstijl wordt beschouwd.

Naar mijn mening moet dit speciale geval worden afgehandeld door een lege Optional<Integer> te retourneren. Aangezien Java een dergelijke methode niet biedt, gebruik ik de volgende wrapper:

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

Voorbeeld van gebruik:

// prints "12"
System.out.println(tryParseInteger("12").map(i -> i.toString()).orElse("invalid"));
// prints "-1"
System.out.println(tryParseInteger("-1").map(i -> i.toString()).orElse("invalid"));
// prints "invalid"
System.out.println(tryParseInteger("ab").map(i -> i.toString()).orElse("invalid"));

Hoewel dit intern nog steeds uitzonderingen voor stroombeheer gebruikt, wordt de gebruikscode erg schoon. U kunt ook duidelijk onderscheid maken tussen het geval waarin -1 wordt geparseerd als een geldige waarde en het geval waarin een ongeldige string niet kan worden geparseerd.


Antwoord 9

Methoden om dat te doen:

  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 produceert een Integer-object en alle andere methoden een primitieve int.

De laatste twee methoden zijn van commons-lang3 en een grote artikel over converteren hier.


Antwoord 10

Gebruik Integer.parseInt(yourString).

Onthoud de volgende dingen:

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

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

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

Integer.parseInt(" 1"); // Uitzondering (lege ruimte)

Integer.parseInt("2147483648"); // Uitzondering (Integer is beperkt tot een maximale waarde van 2.147.483.647)

Integer.parseInt("1.1"); // Uitzondering (. of , of wat dan ook is niet toegestaan)

Integer.parseInt(""); // Uitzondering (niet 0 of zo)

Er is slechts één type uitzondering: NumberFormatException


Antwoord 11

Het converteren van een string naar een int is ingewikkelder dan alleen het converteren van een getal. U heeft nagedacht over de volgende problemen:

  • Bevat de string alleen cijfers 0-9?
  • Wat is er met -/+ voor of na de tekenreeks? Is dat mogelijk (verwijzend naar boekhoudnummers)?
  • Wat is er aan de hand met MAX_-/MIN_INFINITY? Wat gebeurt er als de string 99999999999999999999 is? Kan de machine deze string als een int behandelen?

Antwoord 12

We kunnen de parseInt(String str) methode van de Integer wrapper-klasse gebruiken voor het converteren van een String-waarde naar een geheel getal.

Bijvoorbeeld:

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

De klasse Integer biedt ook de methode valueOf(String str):

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

We kunnen ook toInt(String strValue) van NumberUtils Utility Class voor de conversie:

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

Antwoord 13

Ik heb een oplossing, maar ik weet niet hoe effectief die is. Maar het werkt goed, en ik denk dat je het kunt verbeteren. Aan de andere kant heb ik een aantal tests gedaan met JUnit die correct verlopen. Ik heb de functie en testen bijgevoegd:

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

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

Antwoord 14

Google Guava heeft tryParse(String), wat retourneert null als de tekenreeks niet kon worden geparseerd, bijvoorbeeld:

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

Antwoord 15

U kunt ook beginnen door alle niet-numerieke tekens te verwijderen en vervolgens het gehele getal te ontleden:

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

Maar wees gewaarschuwd: dit werkt alleen voor niet-negatieve getallen.


Antwoord 16

Naast de voorgaande antwoorden wil ik nog een aantal functies toevoegen. Dit zijn resultaten terwijl u ze gebruikt:

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
}

Implementatie:

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

Antwoord 17

Zoals gezegd, NumberUtils van Apache Commons kan het. Het retourneert 0 als het een string niet naar een int kan converteren.

U kunt ook uw eigen standaardwaarde definiëren:

NumberUtils.toInt(String str, int defaultValue)

Voorbeeld:

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;

Antwoord 18

U kunt deze code ook gebruiken, met enkele voorzorgsmaatregelen.

  • Optie #1: Behandel de uitzondering expliciet, bijvoorbeeld door een berichtvenster weer te geven en stop dan de uitvoering van de huidige workflow. Bijvoorbeeld:

    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;
    }
    
  • Optie #2: Reset de betrokken variabele als de uitvoeringsstroom kan doorgaan in geval van een uitzondering. Bijvoorbeeld, met enkele aanpassingen in het catch-blok

    catch (NumberFormatException ex) {
        integerValue = 0;
    }
    

Het is altijd een goed idee om een ​​tekenreeksconstante te gebruiken voor vergelijking of enige vorm van computergebruik, omdat een constante nooit een null-waarde retourneert.


Antwoord 19

U kunt new Scanner("1244").nextInt() gebruiken. Of vraag of er zelfs een int bestaat: new Scanner("1244").hasNextInt()


Antwoord 20

In programmeerwedstrijden, waarbij je er zeker van bent dat het getal altijd een geldig geheel getal is, kun je je eigen methode schrijven om invoer te ontleden. Hiermee wordt alle validatiegerelateerde code overgeslagen (aangezien je die niet nodig hebt) en wordt het een beetje efficiënter.

  1. Voor geldig positief geheel getal:

    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. Voor zowel positieve als negatieve gehele getallen:

    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. Als u een spatie voor of na deze cijfers verwacht,
    zorg er dan voor dat je een str = str.trim() doet voordat je verder gaat.


Antwoord 21

Je kunt dit gewoon proberen:

  • Gebruik Integer.parseInt(your_string); om een ​​String te converteren naar int
  • Gebruik Double.parseDouble(your_string); om een ​​String te converteren naar double

Voorbeeld

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

Antwoord 22

Voor een normale string kun je gebruiken:

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

Voor een String builder en String buffer kun je het volgende gebruiken:

Integer.parseInt(myBuilderOrBuffer.toString());

Antwoord 23

Het verbaast me een beetje dat niemand de Integer-constructor noemde die String als parameter gebruikt.

Dus hier is het:

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

Java 8 – Integer(String).

Natuurlijk zal de constructor het type Integer retourneren, en een unboxing-bewerking converteert de waarde naar int.


Opmerking 1: het is belangrijk om te vermelden: deze constructor roept de methode parseInt aan.

public Integer(String var1) throws NumberFormatException {
    this.value = parseInt(var1, 10);
}

Opmerking 2: Het is verouderd: @Deprecated(since="9")JavaDoc.


Antwoord 24

Gebruik Integer.parseInt() en plaats het in een try...catch-blok om eventuele fouten af ​​te handelen voor het geval er een niet-numeriek teken wordt ingevoerd, bijvoorbeeld

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

Antwoord 25

Het kan op zeven manieren:

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

    int resultaat = Ints.tryParse(getal);

  2. NumberUtils.createInteger:

    Integer resultaat = NumberUtils.createInteger(getal);

  3. NumberUtils.toInt:

    int resultaat = NumberUtils.toInt(getal);

  4. Integer.valueOf:

    Integer resultaat = Integer.valueOf(getal);

  5. Integer.parseInt:

    int resultaat = Integer.parseInt(getal);

  6. Integer.decode:

    int resultaat = Integer.decode(getal);

  7. Integer.parseUnsignedInt:

    int resultaat = Integer.parseUnsignedInt(getal);


Antwoord 26

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

Zorg ervoor dat er geen niet-numerieke gegevens in de tekenreeks staan.


Antwoord 27

Dit is een compleet programma met alle positieve en negatieve voorwaarden zonder een bibliotheek te gebruiken

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

Antwoord 28

Eén methode is parseInt(String). Het retourneert een primitieve int:

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

De tweede methode is valueOf(String), en deze retourneert een nieuw Integer()-object:

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

Antwoord 29

Daar gaan we

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

Antwoord 30

U kunt een van de volgende dingen gebruiken:

  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)

LEAVE A REPLY

Please enter your comment!
Please enter your name here

Other episodes