it-swarm-eu.dev

Jak lze převést řetězec na int v jazyce Java?

Jak lze převést soubor String na int v jazyce Java?

Můj řetězec obsahuje pouze čísla a chci vrátit číslo, které představuje.

Například daný řetězec "1234" by měl být číslo 1234.

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

Když se podíváte na Java dokumentaci budete si všimnout "catch" je to, že tato funkce může hodit NumberFormatException, což samozřejmě musíte zvládnout:

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

(Tato léčba standardně nastaví chybně formátované číslo na 0, ale můžete udělat něco jiného, ​​pokud chcete.)

Případně můžete použít metodu Ints z knihovny Guava, která v kombinaci s Optional jazyka Java 8 umožňuje výkonný a výstižný způsob převodu řetězce na int:

import com.google.common.primitives.Ints;

int foo = Optional.ofNullable(myString)
 .map(Ints::tryParse)
 .orElse(0)
3787
Rob Hruska

Zde jsou například dva způsoby:

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

Mezi těmito metodami je mírný rozdíl: 

  • valueOf vrací novou nebo uloženou instanci Java.lang.Integer
  • parseInt vrátí primitivní int

Totéž platí pro všechny případy: Short.valueOf/parseShort, Long.valueOf/parseLong, atd.

629
smas

Velmi důležitým bodem, který je třeba vzít v úvahu, je to, že syntaktický analyzátor Integer hází NumberFormatException, jak je uvedeno v 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.
}

Je důležité tuto výjimku zpracovat, když se pokoušíte získat celočíselné hodnoty z argumentů rozdělení nebo dynamicky něco analyzovat.

230
Ali Akdurak

Proveďte to ručně:

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

V současné době dělám úkol pro vysokou školu, kde nemohu používat určité výrazy, jako jsou ty výše uvedené, a když jsem se podíval na ASCII stůl, podařilo se mi to udělat. Je to mnohem složitější kód, ale může to pomoci ostatním, kteří jsou omezeni jako já.

První věc, kterou musíte udělat, je přijmout vstup, v tomto případě řetězec číslic; Zavolám to String number a v tomto případě ho uvedu na příkladu číslo 12, tedy String number = "12";

Dalším omezením byla skutečnost, že nemůžu používat opakované cykly, proto nelze použít ani for cyklus (který by byl dokonalý). To nás trochu omezuje, ale pak je to cíl. Jelikož jsem potřeboval pouze dvě číslice (poslední dvě číslice), jednoduchá charAt to vyřešila:

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

S kódy, stačí se podívat na stůl a provést nezbytné úpravy:

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

Proč se zdvojnásobit? No, protože opravdu "divný" krok. V současné době máme dva dvouhry, 1 a 2, ale potřebujeme je převést na 12, neexistuje žádná matematická operace, kterou můžeme udělat.

Posledně jmenované (lastdigit) dělíme o 10 v módu 2/10 = 0.2 (tedy proč zdvojnásobit) takto:

 lastdigit = lastdigit/10;

To je jen hraní s čísly. Poslední číslici jsme změnili na desetinné místo. Ale teď se podívejte, co se stane:

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

Bez toho, abychom se dostali do matematiky, jednoduše izolováme jednotky číslic. Vidíte, protože uvažujeme pouze 0-9, dělení násobkem 10 je jako vytvořit "krabici", kde ji uložíte (přemýšlejte o tom, kdy vám učitel první třídy vysvětlil, co je jednotka a sto). Tak:

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

A tam jdete. Zapnuli jste řetězec číslic (v tomto případě dvě číslice) na celé číslo složené z těchto dvou číslic, s ohledem na následující omezení:

  • Žádné opakované cykly
  • Žádné "Magic" výrazy jako parseInt
42
Oak

Alternativní řešení je použití Apache Commons ' NumberUtils:

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

Nástroj Apache je Nice, protože pokud je řetězec neplatný, pak se vždy vrátí 0. Uloží se tak blok vyzkoušení.

Apache NumberUtils API verze 3.4

40
Ryboflavin

Integer.decode

Můžete také použít public static Integer decode(String nm) throws NumberFormatException.

Funguje také pro základnu 8 a 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

Chcete-li místo int získat Integer, můžete použít:

  1. Rozbalení:

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

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

Kdykoliv existuje nejmenší možnost, že daný řetězec neobsahuje celé číslo, musíte tento zvláštní případ zpracovat. Je smutné, že standardní metody Java Integer::parseInt a Integer::valueOf hodí NumberFormatException, aby signalizovaly tento zvláštní případ. Proto musíte použít výjimky pro řízení toku, což je obecně považováno za špatný styl kódování.

Podle mého názoru by se tento zvláštní případ měl řešit vrácením Optional<Integer>. Jelikož Java tuto metodu nenabízí, používám následující wrapper:

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

Používání:

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

Zatímco toto stále používá výjimky pro řízení toku interně, kód použití se stává velmi čistý.

25
Stefan Dollase

Konverze řetězce na int je složitější než jen převod čísla. Přemýšlíte o následujících problémech:

  • Obsahuje řetězec pouze čísla 0-9?
  • Co je s -/+ před nebo po řetězci? Je to možné (s odkazem na účetní čísla)?
  • Co je s MAX _-/MIN_INFINITY? Co se stane, když je řetězec 99999999999999999999? Může stroj zacházet s tímto řetězcem jako s int?
23
Dennis Ahaus

Způsoby, jak toho dosáhnout:

 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 vytváří objekt Integer, všechny ostatní metody - primitive int.

Poslední 2 metody z commons-lang3 a velký článek o konverzi zde .

22

Pro převedení hodnoty String na celočíselnou hodnotu můžeme použít metodu parseInt(String str) třídy Integer wrapper.

Například:

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

Třída Integer také poskytuje metodu valueOf(String str):

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

Můžeme také použít toInt(String strValue) z ClassUtils Utility Class pro konverzi:

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

Použít Integer.parseInt(yourString)

Zapamatujte si následující věci:

Integer.parseInt("1");/ ok

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

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

Integer.parseInt(" 1"); // Výjimka (prázdné místo)

Integer.parseInt("2147483648"); // Výjimka (celé číslo je omezeno na maximální hodnota z 2 147 483 647)

Integer.parseInt("1.1"); // Výjimka (_ /. nebo , nebo co není povoleno)

Integer.parseInt(""); // Výjimka (ne 0 nebo něco)

Existuje pouze jeden typ výjimky: NumberFormatException

19
Lukas Bauer

Mám řešení, ale nevím, jak je to efektivní. Ale funguje to dobře a myslím, že byste to mohli vylepšit. Na druhou stranu jsem udělal pár testů s JUnit který krok správně. Připojil jsem funkci a testování:

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

Testování pomocí 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));
        }
    }
}
19
fitorec

Pro zábavu: Optional jazyka Java můžete použít pro převod String do 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.

Zde kombinujeme Integer.valueOf a Optinal. Pravděpodobně mohou nastat situace, kdy je to užitečné - například když se chcete vyhnout nulovým kontrolám. Kód Pre Java 8 bude vypadat takto:

Integer value = (str == null) ? -1 : Integer.parseInt(str);
17
Anton Balaniuc

Guava má tryParse (String) , který vrací null, pokud řetězec nemohl být analyzován, například:

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

Můžete také začít odstraněním všech nečíselných znaků a poté syntézou int:

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

Ale buďte upozorněni, že to funguje pouze u nezáporných čísel. 

14
Thijser

Kromě těchto výše uvedených odpovědí bych rád přidal několik funkcí: 

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

A tady jsou výsledky při jejich spouštění: 

  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
  }
12
nxhoaf

V programovacích soutěžích, kde jste si jisti, že číslo bude vždy platné celé číslo, můžete napsat vlastní metodu pro analýzu vstupu. Tím se vynechá veškerý kód související s validací (protože to nepotřebujete) a bude o něco efektivnější.

  1. Platné kladné celé číslo:

    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. Pro kladná i záporná celá čísla:

    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. Pokud očekáváte mezeru před nebo po těchto číslech, pak se před dalším zpracováním ujistěte, že jste provedli str = str.trim().

9
Raman Sahasi

Jak již bylo zmíněno, Apache Commons NumberUtils to dokáže. Který vrátí 0 jestliže to nemůže konvertovat řetězec k int.

Můžete také definovat vlastní výchozí hodnotu.

NumberUtils.toInt(String str, int defaultValue)

příklad:

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; 
9
Alireza Fattahi

Tento kód můžete použít také s určitými opatřeními.

  • Možnost č. 1: Explicitně zpracovat výjimku, například zobrazit dialogové okno zprávy a poté zastavit provádění aktuálního pracovního postupu. Například:

    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;
    }
    
  • Možnost č. 2: Obnovení ovlivněné proměnné v případě, že v případě výjimky může pokračovat proces provádění. Například s některými úpravami v blokovacím bloku

    catch (NumberFormatException ex) {
        integerValue = 0;
    }
    

Použití řetězcové konstanty pro porovnání nebo jakýkoli druh práce je vždy dobrý nápad, protože konstanta nikdy nevrací hodnotu null.

9
manikant gautam

Můžete použít new Scanner("1244").nextInt(). Nebo se zeptejte, zda existuje i int: new Scanner("1244").hasNextInt()

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

Ujistěte se, že v řetězci nejsou žádná nečíselná data.

7
iKing

Pro normální řetězec můžete použít:

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

Pro String builder a String buffer můžete použít:

Integer.parseInt(myBuilderOrBuffer.toString());
7
Aditya

Stačí to zkusit:

  • Použijte Integer.parseInt(your_string); k převodu String na int
  • Použijte Double.parseDouble(your_string); k převodu String na double

Příklad

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
7
Vishal Yadav

Tady jsme

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

Jsem trochu překvapen, že nikdo nezmínil konstruktor Integer, který bere String jako parametr.
Tak tady je: 

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

Java 8 - Integer (String)

Konstruktor samozřejmě vrátí typ Integer a operace unboxing převede hodnotu na int


Je důležité zmínit
Tento konstruktor volá metodu parseInt

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

Použijte Integer.parseInt () a vložte jej dovnitř bloku try...catch, abyste zpracovali všechny chyby pouze v případě, že je zadán nečíselný znak, například

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

Jedna metoda je parseInt (String) vrací primitivní int

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

Druhá metoda je valueOf (String) vrací nový objekt Integer ().

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

Toto je kompletní program se všemi podmínkami pozitivní, negativní bez použití knihovny  

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;
     }
    }
4
Anup Gupta

Integer.parseInt(myString); - použití třídy wrapper

3
Phani Kumar

Lze provést 5 způsoby:

import com.google.common.primitives.Ints;
import org.Apache.commons.lang.math.NumberUtils;

1) Použití Ints.tryParse:

String number = "999";
int result = Ints.tryParse(number);

2) Použití NumberUtils.createInteger:

String number = "999";
Integer result = NumberUtils.createInteger(number);

3) Použití NumberUtils.toInt:

String number = "999";
int result = NumberUtils.toInt(number);

4) Použití Integer.valueOf:

String number = "999";
Integer result = Integer.valueOf(number);

5) Použití Integer.parseInt:

String number = "999";
int result = Integer.parseInt(number);
3
Santosh Jadi

Mimochodem, uvědomte si, že pokud je řetězec null, volání:

int i = Integer.parseInt(null);

hodí NumberFormatException, nikoli NullPointerException.

3
Pavel Molchanov

Můžete použít některou z následujících možností: 

  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)
2
Rajeev Ranjan

import Java.util. *;

veřejná třída 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);
    }

}

2
Abhijeet Kale

public static int parseInt (String s) vyvolá NumberFormatException

Integer.parseInt() můžete převést řetězec na int.

převést řetězec 20 na primitivní int.

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

Výstup-20

pokud řetězec neobsahuje analyzovatelné celé číslo. bude hozen NumberFormatException

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

public static Integer valueOf (String s) vyvolá NumberFormatException

můžete použít Integer.valueOf(), v tomto vrátí objekt Integer.

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

Výstup-20

Odkazy https://docs.Oracle.com/en/

1

Některé ze způsobů převodu String do Int jsou následující:

  1. můžete použít Integer.parseInt():

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

  2. můžete také použít Integer.valueOf():

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

0

Převeďte řetězec na celé číslo metodou parseInt třídy Java Integer. Metoda parseInt je převést řetězec na int a vyvolá NumberFormatException, pokud řetězec nelze převést na typ int.

S výhledem na výjimku, kterou může hodit, použijte toto:

int i = Integer.parseInt(myString);

Pokud je řetězec označený proměnnou myString platným celým číslem jako “1234”, “200”, “1”, a bude převeden na Java int. Pokud se z nějakého důvodu nezdaří, změna může vyvolat proměnnou NumberFormatException, takže kód by měl být o něco delší.

Př. Metoda konverze String na int, kontrola možného 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());
    }
  }
}

Pokud se pokus o změnu nezdaří - v případě, že se můžete pokusit převést test Java String na int - proces Integer parseInt, vyvolá NumberFormatException, které musíte zpracovat v bloku try/catch.

0
Nisarg

Můžete použít metodu parseInt  

  String SrNumber="5790";
int extractNumber = Integer.parseInt(SrNumber);
System.out.println(extractNumber);//Result will be --5790
0

Vlastní algoritmus:

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

jiné řešení: (namísto převodu řetězce na byte použijte řetězec charAt method):

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

Příklady:

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());
}
0
nabeghe

Použití metody: Integer.parseInt(String s)

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

Použijte Integer.parseInt(), toto vám pomůže při analýze hodnoty řetězce na int.

Příklad:

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

výstup: 2017

0
Alekya

Použijte tuto metodu:

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;
}
0
mohamad sheikhi

Vyzkoušejte tento kód s různými vstupy 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();
    }
}
0
Ram Chhabra

Tuto rychlou metodu jsem napsal, aby analyzoval vstup řetězce do int nebo long. Je rychlejší než aktuální JDK 11 Integer.parseInt nebo Long.parseLong. Ačkoliv jste žádali jen o int, zahrnula jsem i dlouhý parser. Analyzátor kódu níže vyžaduje, aby metoda parseru byla malá, aby mohla rychle fungovat. Alternativní verze je pod zkušebním kódem. Alternativní verze je velmi rychlá a nezávisí na velikosti třídy.

Tato třída kontroluje přetečení a můžete přizpůsobit kód tak, aby se přizpůsobil vašim potřebám. Prázdný řetězec přinese 0 metodou, ale to je úmyslné. Můžete změnit, že přizpůsobit váš případ nebo použití jako je. 

Toto je pouze část třídy, kde jsou potřeba parseInt a parseLong. Všimněte si, že se jedná pouze o čísla základny 10.

Testovací kód pro par parser je pod níže uvedeným kódem. 

/*
 * 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 - [email protected]
 **/
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;
    }
}

Sekce zkušebního řádu. To by mělo trvat asi 200 sekund.

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

Alternativní metoda, která je také velmi rychlá. Všimněte si, že pole int pow není použito, ale matematická optimalizace násobení 10 bitovým posunem.

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;
}
0
Kevin Ng