Vraag Hoe converteer ik een String naar een int in Java?


Hoe kan ik een String aan een int in Java?

My String bevat alleen getallen en ik wil het getal dat het vertegenwoordigt, retourneren.

Bijvoorbeeld, gezien de string "1234" het resultaat zou het nummer moeten zijn 1234.


2514
2018-04-07 18:27


oorsprong


antwoorden:


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

Zie de Java-documentatie voor meer informatie.


3554
2018-04-07 18:29



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 geeft een nieuwe of gecachte instantie terug van java.lang.Integer
  • parseInt komt terug primitief int.

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


588
2018-04-07 18:36



Wel, 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 getallen uit gehele getallen probeert op te halen uit gesplitste argumenten of iets dynamisch te ontleden.


215
2018-04-30 06:54



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

72
2017-09-11 02:08



Momenteel doe ik een opdracht voor college, waar ik bepaalde uitdrukkingen, zoals de bovenstaande, niet kan gebruiken en door naar de ASCII-tabel te kijken, heb ik het voor elkaar gekregen. 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 zal het noemen String number, en in dit geval zal ik het dus illustreren met behulp van het getal 12 String number = "12";

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

 // 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 aan te brengen:

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

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

We delen de laatste (lastdigit) door 10 in de mode 2/10 = 0.2 (vandaar waarom dubbel) zoals dit:

 lastdigit = lastdigit/10;

Dit is alleen maar spelen met cijfers. We veranderden het laatste cijfer in een decimaal. Maar nu, kijk naar wat er gebeurt:

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

Zonder al te veel in de wiskunde te geraken, isoleren we eenheden gewoon de cijfers van een getal. Zie je, aangezien we alleen 0-9 beschouwen, is delen door een veelvoud van 10 hetzelfde als het creëren van een "kader" waar je het opslaat (denk eens terug aan toen je leraar in de eerste graad je uitlegde wat een eenheid en honderd waren). Zo:

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

En daar ga je. U hebt een reeks cijfers (in dit geval twee cijfers) omgezet in een geheel getal dat uit twee cijfers bestaat, waarbij u rekening houdt met de volgende beperkingen:

  • Geen repetitieve cycli
  • Geen "Magic" -uitdrukkingen zoals parseInt

38
2018-03-20 23:51



Een alternatieve oplossing is om te gebruiken Apache Commons ' NumberUtils:

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

Het Apache-hulpprogramma is leuk omdat als de tekenreeks een ongeldige getalnotatie is, 0 altijd wordt geretourneerd. Daarom bewaar je het try catch-blok.

Apache NumberUtils API-versie 3.4


33
2017-08-27 12:07



Integer.decode

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

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 je wilt krijgen int in plaats van Integer je kunt gebruiken:

  1. unboxing:

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

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

27
2018-03-07 00:42



Wanneer er de geringste mogelijkheid is dat de gegeven String geen Integer bevat, moet je dit speciale geval behandelen. Helaas, de standaard Java-methoden Integer::parseInt en Integer::valueOf Gooi een NumberFormatException om dit speciale geval te signaleren. U moet dus uitzonderingen gebruiken voor stroomregeling, die over het algemeen als slechte coderingsstijl wordt beschouwd.

Naar mijn mening moet dit speciale geval worden afgehandeld door een Optional<Integer>. Omdat Java zo'n 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();
    }
}

Gebruik:

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

Hoewel dit nog steeds uitzonderingen gebruikt voor de interne stroomregeling, wordt de gebruikscode erg schoon.


20
2018-04-04 03:13



Het converteren van een string naar een int is gecompliceerder dan alleen het converteren van een nummer. U denkt na over de volgende problemen:

  • Bevat de string alleen cijfers 0-9?
  • Wat is er met - / + voor of na de string? Is dat mogelijk (verwijzend naar boekhoudkundige nummers)?
  • Wat is er met MAX _- / MIN_INFINITY? Wat gebeurt er als de string 99999999999999999999 is? Kan de machine deze snaar behandelen als een int?

19
2017-10-20 13:18