it-swarm-tr.com

Bir String'i Java'daki bir int'ye nasıl dönüştürebilirim?

Java'da String bir int dosyasına nasıl dönüştürebilirim?

Dize yalnızca sayılar içeriyor ve temsil ettiği sayıyı döndürmek istiyorum.

Örneğin, "1234" dizesi verildiğinde sonuç 1234 sayısı olmalıdır.

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

Java Dokümantasyonuna bakarsanız "yakala" nın farkına varacaksınız, bu fonksiyonun NumberFormatException atabilir; elbette hangisini kullanmanız gerekir:

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

(Bu tedavi varsayılan olarak 0 olarak hatalı biçimlendirilmiş bir sayıdır, ancak isterseniz başka bir şey yapabilirsiniz.)

Alternatif olarak, Java 8'in Ints ile birlikte bir dizgeyi int'ye dönüştürmek için güçlü ve özlü bir yol açan Guava kütüphanesinden bir Optional yöntemi kullanabilirsiniz:

import com.google.common.primitives.Ints;

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

Örneğin, işte iki yol:

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

Bu yöntemler arasında küçük bir fark vardır: 

  • valueOf, Java.lang.Integer 'nin yeni veya önbelleğe alınmış bir örneğini döndürür
  • parseInt, ilkel int değerini döndürür. 

Aynı durum tüm durumlar için geçerlidir: Short.valueOf/parseShort, Long.valueOf/parseLong, vb.

629
smas

Dikkat edilmesi gereken çok önemli bir nokta, Tamsayı ayrıştırıcısının, Javadoc içinde belirtildiği gibi NumberFormatException değerini atmasıdır. 

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

Bölünmüş argümanlardan tamsayı değerleri almaya çalışırken veya bir şeyi dinamik olarak ayrıştırırken bu istisnayı ele almak önemlidir.

230
Ali Akdurak

Manuel olarak yapı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

Şu anda kolej için ödev yapıyorum, yukarıdaki ifadeler gibi belirli ifadeleri kullanamıyorum ve ASCII masasına bakarak bunu yapmayı başardım. Çok daha karmaşık bir kod, ancak benim gibi kısıtlı olan başkalarına yardımcı olabilir.

Yapılacak ilk şey girdiyi, bu durumda bir rakam dizesini almaktır; Buna String number diyeceğim ve bu durumda, 12 sayısını kullanarak örnekleyeceğim, bu nedenle String number = "12";

Diğer bir sınırlama, tekrarlayan döngüleri kullanamadığım gerçeği idi, bu yüzden, (mükemmel olurdu) for döngüsü de kullanılamazdı. Bu bizi biraz kısıtlar, fakat sonra yine hedef budur. Sadece iki basamağa ihtiyacım olduğu için (son iki basamağı alarak), basit bir charAtsolved:

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

Kodları alarak sadece masaya bakmamız ve gerekli düzeltmeleri yapmamız gerekiyor:

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

Şimdi neden iki katı? Eh, gerçekten "garip" bir adım yüzünden. Şu anda 1 ve 2 olmak üzere iki çiftimiz var, ama bunu 12'ye dönüştürmemiz gerekiyor, yapabileceğimiz hiçbir matematiksel işlem yok.

İkincisini (lastdigit) şu şekilde 2/10 = 0.2 (ondan iki katına) şeklinde 10'a böldük:

 lastdigit = lastdigit/10;

Bu sadece rakamlarla oynuyor. Son haneyi ondalık basamağa çeviriyorduk. Ama şimdi ne olduğuna bak.

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

Matematiğe fazla girmeden, bir birimin basamaklarını ünitelerle izole ediyoruz. Görüyorsunuz, yalnızca 0-9'u düşündüğümüz için, 10'un katları ile bölmek, sakladığınız bir "kutu" oluşturmak gibidir (birinci sınıf öğretmeninizin size ne kadar ünite olduğunu açıkladığı zamanları düşünün). Yani:

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

Ve işte gidiyorsun. Aşağıdaki sınırlamaları göz önünde bulundurarak, bir rakam dizesini (bu durumda, iki rakam), bu iki rakamdan oluşan bir tamsayıya dönüştürdünüz:

  • Tekrarlanan döngü yok
  • Ayrıştırma gibi "Büyü" İfadeleri Yok
42
Oak

Alternatif bir çözüm de Apache Commons ' NumberUtils kullanmaktır:

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

Apache yardımcı programı Nice'dir, çünkü dize geçersiz bir sayı biçimindeyse, 0 her zaman döndürülür. Dolayısıyla, try catch bloğundan tasarruf etmenizi sağlar.

Apache NumberUtils API Sürüm 3.4

40
Ryboflavin

Integer.decode

public static Integer decode(String nm) throws NumberFormatException işlevini de kullanabilirsiniz.

Ayrıca, taban 8 ve 16 için de çalışır:

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

int yerine Integer almak istiyorsanız, şunu kullanabilirsiniz:

  1. Kutudan Çıkarma:

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

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

Verilen String'in bir Tamsayı içermediği en küçük ihtimal olduğunda, bu özel durumu ele almanız gerekir. Ne yazık ki, standart Java yöntemleri Integer::parseInt ve Integer::valueOf, bu özel durumu işaret etmek için bir NumberFormatException atar. Bu nedenle, genel olarak kötü kodlama stili olarak kabul edilen akış kontrolü için istisnalar kullanmanız gerekir.

Kanımca bu özel durum bir Optional<Integer> döndürülerek ele alınmalı. Java böyle bir yöntem sunmadığından, şu ambalajı kullanıyorum:

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

Kullanımı:

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

Bu hala dahili olarak akış kontrolü için istisnalar kullanırken, kullanım kodu çok temiz hale gelir.

25
Stefan Dollase

Bir dizgiyi bir int'ye dönüştürmek, bir sayıyı dönüştürmekten çok daha karmaşıktır. Aşağıdaki konuları düşündünüz:

  • Dize sadece 0-9 rakamlarını içeriyor mu?
  • Dizeden önce veya sonra -/+ ile ilgili neler var? Bu mümkün mü (muhasebe numaralarına atıfta bulunarak)?
  • MAX _-/MIN_INFINITY ile ilgili ne var? İp 9999999999999999999999 ise ne olacak? Makine bu dizgiyi int olarak algılayabilir mi?
23
Dennis Ahaus

Bunu yapmak için yöntemler:

 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, Integer nesnesini, diğer tüm yöntemleri üretir - ilkel int.

commons-lang3 'den son 2 yöntem ve here ' nin dönüştürülmesi ile ilgili büyük yazılar.

22

Bir String değerini tamsayı değerine dönüştürmek için Integer wrapper sınıfının parseInt(String str) yöntemini kullanabiliriz.

Örneğin:

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

Integer sınıfı ayrıca valueOf(String str) yöntemini sağlar:

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

Dönüşüm için NumberUtils Utility ClasstoInt(String strValue) işlevini de kullanabiliriz:

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

Integer.parseInt(yourString) kullanın 

Aşağıdakileri hatırla:

Integer.parseInt("1");/ tamam

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

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

Integer.parseInt(" 1"); // İstisna (boşluk)

Integer.parseInt("2147483648"); // İstisna (Tamsayı bir maksimum değer /2,147,483,647 ile sınırlıdır)

Integer.parseInt("1.1"); // İstisna (_ /. veya , veya hangisine izin verilmez)

Integer.parseInt(""); // İstisna (0 falan değil)

Yalnızca bir istisna türü vardır: NumberFormatException

19
Lukas Bauer

Bir çözümüm var, ama bunun ne kadar etkili olduğunu bilmiyorum. Ama iyi çalışıyor ve bence onu iyileştirebilirsin. Öte yandan, JUnit ile doğru bir şekilde yapılan birkaç test yaptım. Fonksiyonu ve testi ekledim:

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

JUnit ile test etme:

@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

Sadece eğlence için: Java 8'in Optional işlevini, String bir Integer haline dönüştürmek için kullanabilirsiniz:

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.

Burada sadece Integer.valueOf ve Optinal öğelerini birleştiriyoruz. Muhtemelen bunun yararlı olduğu durumlar olabilir - örneğin boş kontrollerden kaçınmak istediğinizde. Java 8 öncesi kod şöyle görünecek:

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

Guava, tryParse (String) , dizge ayrıştırılamadığında null değerini döndürür, örneğin:

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

Tüm sayısal olmayan karakterleri kaldırarak ve sonra int'yi ayrıştırarak da başlayabilirsiniz:

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

Ancak bunun yalnızca negatif olmayan numaralar için çalıştığı konusunda uyarılmalıdır. 

14
Thijser

Yukarıdaki cevapların yanı sıra, birkaç işlev eklemek istiyorum: 

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

Ve işte onları çalıştırırken elde edilen sonuçlar: 

  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

Bu sayının her zaman geçerli bir tamsayı olacağından emin olduğunuz programlama yarışmalarında, girdiyi çözümlemek için kendi yönteminizi yazabilirsiniz. Bu, doğrulama ile ilgili tüm kodları atlayacaktır (bunlardan hiçbirine ihtiyacınız olmadığından) ve biraz daha verimli olacaktır.

  1. Geçerli pozitif tamsayı için:

    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. Hem pozitif hem de negatif tamsayılar için:

    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. Bu sayılardan önce veya sonra bir boşluk bekliyorsanız, , Daha sonra işlem yapmadan önce str = str.trim() yaptığınızdan emin olun.

9
Raman Sahasi

Apache Commons'da bahsedildiği gibi NumberUtils bunu yapabilir. Dizeyi int'ye dönüştüremezse hangi 0 döndürür.

Ayrıca kendi varsayılan değerinizi de tanımlayabilirsiniz.

NumberUtils.toInt(String str, int defaultValue)

örnek:

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

Bu kodu bazı önlemlerle birlikte de kullanabilirsiniz.

  • Seçenek # 1: İstisnayı açıkça ele al, örneğin bir mesaj iletişim kutusu göster ve ardından mevcut iş akışının yürütülmesini durdur. Örneğin:

    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;
    }
    
  • Seçenek # 2: Bir istisna durumunda yürütme akışı devam ederse etkilenen değişkeni sıfırlayın. Örneğin, catch bloğundaki bazı değişiklikler ile

    catch (NumberFormatException ex) {
        integerValue = 0;
    }
    

Karşılaştırma veya herhangi bir tür hesaplama için bir dize sabiti kullanmak her zaman iyi bir fikirdir, çünkü bir sabit asla boş değer döndürmez.

9
manikant gautam

new Scanner("1244").nextInt() kullanabilirsiniz. Veya bir int bile var mı diye sorun: new Scanner("1244").hasNextInt()

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

Dizede sayısal olmayan veri olmadığından emin olun.

7
iKing

Normal dize için kullanabilirsiniz:

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

String oluşturucu ve String tamponu için şunları kullanabilirsiniz:

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

Basitçe bunu deneyebilirsiniz:

  • Bir String - int dönüştürmek için Integer.parseInt(your_string); öğesini kullanın.
  • Bir String - double dönüştürmek için Double.parseDouble(your_string); öğesini kullanın.

Örnek

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

İşte başlıyoruz

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

Hiç kimsenin String'i parametre olarak alan Integer yapıcısından bahsetmediğinden şaşırdım.
Yani, işte: 

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

Java 8 - Tamsayı (Dize)

Elbette, yapıcı Integer türünü döndürür ve unboxing işlemi değeri int değerine dönüştürür. 


Bahsetmek önemlidir
Bu yapıcı parseInt yöntemini çağırır. 

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

Integer.parseInt () işlevini kullanın ve örneğin sayısal olmayan bir karakter girildiğinde herhangi bir hatayı işlemek için bir try...catch bloğunun içine koyun.

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

Bir yöntem parseInt (String), ilkel bir int döndürür

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

İkinci yöntem, valueOf (String), yeni bir Integer () nesnesi döndürür.

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

Bu, kütüphane kullanmadan tüm koşulların pozitif, negatif olduğu komple bir programdır 

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); - sarıcı sınıfını kullanarak

3
Phani Kumar

5 şekilde yapılabilir:

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

1) Ints.tryParse kullanımı:

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

2) NumberUtils.createInteger kullanımı:

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

3) NumberUtils.toInt kullanımı:

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

4) Integer.valueOf kullanımı:

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

5) Integer.parseInt kullanımı:

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

Bu arada, dize null olursa, şu çağrıya dikkat edin:

int i = Integer.parseInt(null);

nullPointerException değil, NumberFormatException atar.

3
Pavel Molchanov

Aşağıdakilerden herhangi birini kullanabilirsiniz: 

  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

java.util'i içe aktarın. *;

genel sınıf 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) NumberFormatException öğesini atar.

bir String'i int'ye dönüştürmek için Integer.parseInt() kullanıcısını kullanabilirsiniz.

string 20'yi ilkel int'ye dönüştürün.

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

Çıkış-20

dizge ayrıştırılabilir bir tamsayı içermiyorsa. NumberFormatException atılacak

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

public static Tamsayı valueOf (String s) NumberFormatException öğesini atıyor

Integer.valueOf() işlevini kullanabilirsiniz, bunun içinde bir Integer nesnesi döndürülür.

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

Çıkış-20

Kaynakça https://docs.Oracle.com/en/

1

String dosyasını Int dosyasına dönüştürmenin yollarından bazıları şunlardır:

  1. Integer.parseInt() kullanabilirsiniz:

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

  2. ayrıca Integer.valueOf() kullanabilirsiniz:

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

0

Java Integer sınıfının parseInt yöntemiyle bir dizeyi tamsayıya dönüştürün. parseInt yöntemi, String'i bir int'ye dönüştürmek ve dize bir int türüne dönüştürülemiyorsa NumberFormatException atanmasıdır.

Atabileceği istisnaya bakarken, şunu kullanın:

int i = Integer.parseInt(myString);

myString değişkeni ile belirtilen String, “1234”, “200”, “1”, gibi geçerli bir tamsayıysa ve bir int int değerine dönüştürülür. Herhangi bir nedenden dolayı başarısız olursa, değişiklik NumberFormatException değerini atabilir, bu nedenle kodun hesaba katılması biraz daha uzun sürmelidir.

Ör. Java String - int dönüştürme yöntemi, olası NumberFormatException için denetim

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

Değişiklik denemesi başarısız olursa - Java String sınamasını bir int biçimine dönüştürmeyi deneyebilirsiniz - Integer parseInt işlemi, try/catch bloğunda işlemesi gereken bir NumberFormatException atacaktır.

0
Nisarg

parseInt yöntemini kullanabilirsiniz  

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

Özel algoritma:

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

başka bir çözüm: (string dizesini byte dizisine dönüştürmek yerine charAt yöntemini kullanın):

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

Örnekler:

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

Yöntem kullanarak: Integer.parseInt(String s)

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

Integer.parseInt() işlevini kullanın, bu, dize değerinizi int olarak ayrıştırmanıza yardımcı olur.

Örnek:

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

çıkışı:. .__ 2017

0
Alekya

Bu yöntemi kullanın:

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

Bu kodu String öğesinin farklı girişleriyle deneyin:

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

Bir dize girdisini int veya long olarak ayrıştırmak için bu hızlı yöntemi yazdım. Geçerli JDK 11 Integer.parseInt veya Long.parseLong öğesinden daha hızlıdır. Her ne kadar sadece int için sorsan da, ben de uzun zamandır ayrıştırıcıyı dahil ettim. Aşağıdaki kod ayrıştırıcı, hızlı bir şekilde çalışması için ayrıştırıcı yönteminin küçük olmasını gerektirir. Alternatif bir versiyon test kodunun altındadır. Alternatif sürüm oldukça hızlıdır ve sınıfın büyüklüğüne bağlı değildir.

Bu sınıf taşma olup olmadığını kontrol eder ve gereksinimlerinize uyarlamak için kodu özelleştirebilirsiniz. Boş bir dize benim yöntemimle 0 verecek, ancak bu kasıtlı. Davanızı uyarlamak veya olduğu gibi kullanmak için bunu değiştirebilirsiniz. 

Bu sadece sınıfın ayrıştırma ve ayrıştırma işleminin gerekli olduğu kısımdır. Bunun yalnızca 10 rakamı ile ilgili olduğunu unutmayın.

İnt ayrıştırıcısının test kodu aşağıdaki kodun altındadır. 

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

Test Kodu Bölümü. Bu yaklaşık 200 saniye sürer.

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

Aynı zamanda çok hızlı olan alternatif bir yöntem. İnt pow dizisinin kullanılmadığına, ancak 10'luk bit kaydırma ile çarpılan matematiksel bir optimizasyon olduğuna dikkat edin.

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