Bir String'in Java'da bir tamsayıyı temsil edip etmediğini kontrol etmenin en iyi yolu nedir?

Normalde bir dize bir tamsayı dönüştürülebilir olup olmadığını kontrol etmek için aşağıdaki deyimi kullanın.

public boolean isInteger( String input ) {
    try {
        Integer.parseInt( input );
        return true;
    }
    catch( Exception e ) {
        return false;
    }
}

Sadece ben mi, yoksa bu biraz acayip görünüyor mu? Daha iyi bir yol nedir?

(Dayalı kriterler, benim cevap bakınız önceki cevap tarafından CodingWithSpike buradaki konumumu ters ve kabul ettik neden) görmek Jonas Klemming yanıtını bu soruna. Bu orijinal kod çoğu insan tarafından kullanılacağını düşünüyorum çünkü uygulanması daha hızlı ve daha sürdürülebilir, ancak tamsayı olmayan veriler sağlandığında büyüklük sıralamaları daha yavaş.

Potansiyel taşma sorunlarıyla ilgilenmiyorsanız, bu işlev kullanmaktan yaklaşık 20-30 kat daha hızlı çalışacaktır Integer.parseInt().

public static boolean isInteger(String str) {
    if (str == null) {
        return false;
    }
    int length = str.length();
    if (length == 0) {
        return false;
    }
    int i = 0;
    if (str.charAt(0) == '-') {
        if (length == 1) {
            return false;
        }
        i = 1;
    }
    for (; i < length; i++) {
        char c = str.charAt(i);
        if (c < '0' || c > '9') {
            return false;
        }
    }
    return true;
}

Sende var, ama sadece yakalamalısın NumberFormatException.

Hızlı bir kıyaslama yaptı. İstisnalar aslında bu kadar pahalı değildir, birden fazla yöntemi geri atmaya başlamadığınız ve JVM'nin yürütme yığınını yerine getirmek için çok fazla iş yapması gerekmiyorsa. Aynı yöntemle kalırken, kötü performans göstermezler.

 public void RunTests()
 {
     String str = "1234567890";

     long startTime = System.currentTimeMillis();
     for(int i = 0; i < 100000; i++)
         IsInt_ByException(str);
     long endTime = System.currentTimeMillis();
     System.out.print("ByException: ");
     System.out.println(endTime - startTime);

     startTime = System.currentTimeMillis();
     for(int i = 0; i < 100000; i++)
         IsInt_ByRegex(str);
     endTime = System.currentTimeMillis();
     System.out.print("ByRegex: ");
     System.out.println(endTime - startTime);

     startTime = System.currentTimeMillis();
     for(int i = 0; i < 100000; i++)
         IsInt_ByJonas(str);
     endTime = System.currentTimeMillis();
     System.out.print("ByJonas: ");
     System.out.println(endTime - startTime);
 }

 private boolean IsInt_ByException(String str)
 {
     try
     {
         Integer.parseInt(str);
         return true;
     }
     catch(NumberFormatException nfe)
     {
         return false;
     }
 }

 private boolean IsInt_ByRegex(String str)
 {
     return str.matches("^-?\\d+$");
 }

 public boolean IsInt_ByJonas(String str)
 {
     if (str == null) {
             return false;
     }
     int length = str.length();
     if (length == 0) {
             return false;
     }
     int i = 0;
     if (str.charAt(0) == '-') {
             if (length == 1) {
                     return false;
             }
             i = 1;
     }
     for (; i < length; i++) {
             char c = str.charAt(i);
             if (c <= '/' || c >= ':') {
                     return false;
             }
     }
     return true;
 }

Çıktı:

ByException: 31

ByRegex: 453 (not: kalıbı her seferinde yeniden derleme)

ByJonas: 16

Jonas K'nin çözümünün de en sağlam çözüm olduğuna katılıyorum. Kazanıyor gibi görünüyor :)

İnsanların hala burayı ziyaret etmeleri ve kıyaslamalardan sonra Regex'e karşı önyargılı olma ihtimalleri olduğu için ... Ben de karşılaştırmanın güncellenmiş bir versiyonunu Regex'in derlenmiş bir versiyonuyla vereceğim. Önceki kıyaslamaların aksine, bu Regex çözümünün aslında sürekli olarak iyi bir performansa sahip olduğunu gösteriyor.

Bill the Lizard'dan kopyalandı ve derlenmiş sürümle güncellendi:

private final Pattern pattern = Pattern.compile("^-?\\d+$");

public void runTests() {
    String big_int = "1234567890";
    String non_int = "1234XY7890";

    long startTime = System.currentTimeMillis();
    for(int i = 0; i < 100000; i++)
            IsInt_ByException(big_int);
    long endTime = System.currentTimeMillis();
    System.out.print("ByException - integer data: ");
    System.out.println(endTime - startTime);

    startTime = System.currentTimeMillis();
    for(int i = 0; i < 100000; i++)
            IsInt_ByException(non_int);
    endTime = System.currentTimeMillis();
    System.out.print("ByException - non-integer data: ");
    System.out.println(endTime - startTime);

    startTime = System.currentTimeMillis();
    for(int i = 0; i < 100000; i++)
            IsInt_ByRegex(big_int);
    endTime = System.currentTimeMillis();
    System.out.print("\nByRegex - integer data: ");
    System.out.println(endTime - startTime);

    startTime = System.currentTimeMillis();
    for(int i = 0; i < 100000; i++)
            IsInt_ByRegex(non_int);
    endTime = System.currentTimeMillis();
    System.out.print("ByRegex - non-integer data: ");
    System.out.println(endTime - startTime);

    startTime = System.currentTimeMillis();
    for (int i = 0; i < 100000; i++)
            IsInt_ByCompiledRegex(big_int);
    endTime = System.currentTimeMillis();
    System.out.print("\nByCompiledRegex - integer data: ");
    System.out.println(endTime - startTime);

    startTime = System.currentTimeMillis();
    for (int i = 0; i < 100000; i++)
            IsInt_ByCompiledRegex(non_int);
    endTime = System.currentTimeMillis();
    System.out.print("ByCompiledRegex - non-integer data: ");
    System.out.println(endTime - startTime);


    startTime = System.currentTimeMillis();
    for(int i = 0; i < 100000; i++)
            IsInt_ByJonas(big_int);
    endTime = System.currentTimeMillis();
    System.out.print("\nByJonas - integer data: ");
    System.out.println(endTime - startTime);

    startTime = System.currentTimeMillis();
    for(int i = 0; i < 100000; i++)
            IsInt_ByJonas(non_int);
    endTime = System.currentTimeMillis();
    System.out.print("ByJonas - non-integer data: ");
    System.out.println(endTime - startTime);
}

private boolean IsInt_ByException(String str)
{
    try
    {
        Integer.parseInt(str);
        return true;
    }
    catch(NumberFormatException nfe)
    {
        return false;
    }
}

private boolean IsInt_ByRegex(String str)
{
    return str.matches("^-?\\d+$");
}

private boolean IsInt_ByCompiledRegex(String str) {
    return pattern.matcher(str).find();
}

public boolean IsInt_ByJonas(String str)
{
    if (str == null) {
            return false;
    }
    int length = str.length();
    if (length == 0) {
            return false;
    }
    int i = 0;
    if (str.charAt(0) == '-') {
            if (length == 1) {
                    return false;
            }
            i = 1;
    }
    for (; i < length; i++) {
            char c = str.charAt(i);
            if (c <= '/' || c >= ':') {
                    return false;
            }
    }
    return true;
}

Sonuçlar:

ByException - integer data: 45
ByException - non-integer data: 465

ByRegex - integer data: 272
ByRegex - non-integer data: 131

ByCompiledRegex - integer data: 45
ByCompiledRegex - non-integer data: 26

ByJonas - integer data: 8
ByJonas - non-integer data: 2

org.apache.commons.lang.StringUtils.isNumeric 

Java'nın standart lib'i bu tür yardımcı program işlevlerini gerçekten özlüyor olsa da

Apache Commons'ın her Java programcısı için "olması gerekir" olduğunu düşünüyorum

çok kötü, henüz Java5'e taşınmadı

Kısmen "tamsayıya dönüştürülebilir" ile ne demek istediğinize bağlıdır.

"Java'da int'e dönüştürülebilir" demek istiyorsanız, Jonas'ın cevabı iyi bir başlangıçtır, ancak işi oldukça bitirmez. Örneğin 999999999999999999999999999999'u geçecekti. Yöntemin sonunda kendi sorunuzdan normal try / catch çağrısını eklerdim.

Karakter karakter kontrolleri, "bir tamsayı değil" durumlarını etkin bir şekilde reddeder, bu da bir tamsayıdır, ancak Java bunu kaldıramaz. Sen olabilir de elle bu düşeni yapmak, ancak bir olurdu çok daha karmaşık.

Regexp hakkında sadece bir yorum. Burada verilen her örnek yanlış !. Regexp kullanmak istiyorsanız, desen derlemenin çok zaman aldığını unutmayın. Bu:

str.matches("^-?\\d+$")

ve ayrıca bu:

Pattern.matches("-?\\d+", input);

her yöntem çağrısında desen derlemesine neden olur. Doğru bir şekilde kullanmak için şunları izleyin:

import java.util.regex.Pattern;

/**
 * @author Rastislav Komara
 */
public class NaturalNumberChecker {
    public static final Pattern PATTERN = Pattern.compile("^\\d+$");

    boolean isNaturalNumber(CharSequence input) {
        return input != null && PATTERN.matcher(input).matches();
    }
}

Guava sürümü var:

import com.google.common.primitives.Ints;

Integer intValue = Ints.tryParse(stringValue);

Dize ayrıştırılamazsa istisna atmak yerine null değerini döndürür.

Ben rally25rs cevap kod kopyaladı ve tamsayı olmayan veriler için bazı testler ekledi. Sonuçlar yadsınamaz bir şekilde Jonas Klemming tarafından yayınlanan yöntemin lehinedir. Tam sayı verileriniz olduğunda ilk olarak gönderdiğim İstisna yönteminin sonuçları oldukça iyi, ancak RegEx çözümünün sonuçları (bir çok insanın kullanacağına bahse gireceğim) idi sürekli kötü. Çok daha hızlı derlenmiş normal ifade örneği için Felipe'nin cevabına bakınız .

public void runTests()
{
    String big_int = "1234567890";
    String non_int = "1234XY7890";

    long startTime = System.currentTimeMillis();
    for(int i = 0; i < 100000; i++)
        IsInt_ByException(big_int);
    long endTime = System.currentTimeMillis();
    System.out.print("ByException - integer data: ");
    System.out.println(endTime - startTime);

    startTime = System.currentTimeMillis();
    for(int i = 0; i < 100000; i++)
        IsInt_ByException(non_int);
    endTime = System.currentTimeMillis();
    System.out.print("ByException - non-integer data: ");
    System.out.println(endTime - startTime);

    startTime = System.currentTimeMillis();
    for(int i = 0; i < 100000; i++)
        IsInt_ByRegex(big_int);
    endTime = System.currentTimeMillis();
    System.out.print("\nByRegex - integer data: ");
    System.out.println(endTime - startTime);

    startTime = System.currentTimeMillis();
    for(int i = 0; i < 100000; i++)
        IsInt_ByRegex(non_int);
    endTime = System.currentTimeMillis();
    System.out.print("ByRegex - non-integer data: ");
    System.out.println(endTime - startTime);

    startTime = System.currentTimeMillis();
    for(int i = 0; i < 100000; i++)
        IsInt_ByJonas(big_int);
    endTime = System.currentTimeMillis();
    System.out.print("\nByJonas - integer data: ");
    System.out.println(endTime - startTime);

    startTime = System.currentTimeMillis();
    for(int i = 0; i < 100000; i++)
        IsInt_ByJonas(non_int);
    endTime = System.currentTimeMillis();
    System.out.print("ByJonas - non-integer data: ");
    System.out.println(endTime - startTime);
}

private boolean IsInt_ByException(String str)
{
    try
    {
        Integer.parseInt(str);
        return true;
    }
    catch(NumberFormatException nfe)
    {
        return false;
    }
}

private boolean IsInt_ByRegex(String str)
{
    return str.matches("^-?\\d+$");
}

public boolean IsInt_ByJonas(String str)
{
    if (str == null) {
            return false;
    }
    int length = str.length();
    if (length == 0) {
            return false;
    }
    int i = 0;
    if (str.charAt(0) == '-') {
            if (length == 1) {
                    return false;
            }
            i = 1;
    }
    for (; i < length; i++) {
            char c = str.charAt(i);
            if (c <= '/' || c >= ':') {
                    return false;
            }
    }
    return true;
}

Sonuçlar:

ByException - integer data: 47
ByException - non-integer data: 547

ByRegex - integer data: 390
ByRegex - non-integer data: 313

ByJonas - integer data: 0
ByJonas - non-integer data: 16

Bu daha kısa, ancak daha kısa olması daha iyi değildir (ve danatel'in yorumunda belirtildiği gibi aralık dışında olan tamsayı değerlerini yakalamaz ):

input.matches("^-?\\d+$");

Şahsen, uygulama yardımcı bir yöntemle sincaplandığından ve doğruluk uzunluğa düştüğü için, sadece sahip olduğunuz gibi bir şeyle giderdim (eksi temel Exceptionsınıfı yakalamak değil NumberFormatException).

String sınıfının match yöntemini kullanabilirsiniz. [0-9], olabileceği tüm değerleri temsil eder, +, en az bir karakter uzunluğunda olması gerektiği anlamına gelir ve *, sıfır veya daha fazla karakter uzunluğunda olabileceği anlamına gelir.

boolean isNumeric = yourString.matches("[0-9]+"); // 1 or more characters long, numbers only
boolean isNumeric = yourString.matches("[0-9]*"); // 0 or more characters long, numbers only

Nasıl olur:

return Pattern.matches("-?\\d+", input);

Bu, Jonas Klemming yanıtının Java 8 varyasyonudur:

public static boolean isInteger(String str) {
    return str != null && str.length() > 0 &&
         IntStream.range(0, str.length()).allMatch(i -> i == 0 && (str.charAt(i) == '-' || str.charAt(i) == '+')
                  || Character.isDigit(str.charAt(i)));
}

Test kodu:

public static void main(String[] args) throws NoSuchAlgorithmException, UnsupportedEncodingException {
    Arrays.asList("1231231", "-1232312312", "+12313123131", "qwqe123123211", "2", "0000000001111", "", "123-", "++123",
            "123-23", null, "+-123").forEach(s -> {
        System.out.printf("%15s %s%n", s, isInteger(s));
    });
}

Test kodunun sonuçları:

        1231231 true
    -1232312312 true
   +12313123131 true
  qwqe123123211 false
              2 true
  0000000001111 true
                false
           123- false
          ++123 false
         123-23 false
           null false
          +-123 false

Sadece NumberFormatException kontrol edin : -

 String value="123";
 try  
 {  
    int s=Integer.parseInt(any_int_val);
    // do something when integer values comes 
 }  
 catch(NumberFormatException nfe)  
 {  
          // do something when string values comes 
 }  

Dize diziniz saf Tamsayılar ve Dizeler içeriyorsa, aşağıdaki kodun çalışması gerekir. Sadece ilk karaktere bakmalısın. örneğin ["4", "44", "abc", "77", "bağ"]

if (Character.isDigit(string.charAt(0))) {
    //Do something with int
}

Tarayıcı sınıfını da kullanabilir ve hasNextInt () yöntemini kullanabilirsiniz - ve bu, kayan noktalar vb. Gibi diğer türleri de test etmenizi sağlar.

Dizenin int türüne uyan bir tamsayıyı temsil edip etmediğini kontrol etmek isterseniz, jonas'ın cevabında küçük bir değişiklik yaptım, böylece Integer.MAX_VALUE değerinden daha büyük veya Integer'den daha küçük tam sayıları temsil eden dizeler şimdi dönecek yanlış. Örneğin: 3147483647 2147483647'den büyük olduğu için "3147483647" yanlış döndürür ve benzer şekilde -2147483649 -2147483648'den küçük olduğu için "-2147483649" da yanlış döndürür.

public static boolean isInt(String s) {
  if(s == null) {
    return false;
  }
  s = s.trim(); //Don't get tricked by whitespaces.
  int len = s.length();
  if(len == 0) {
    return false;
  }
  //The bottom limit of an int is -2147483648 which is 11 chars long.
  //[note that the upper limit (2147483647) is only 10 chars long]
  //Thus any string with more than 11 chars, even if represents a valid integer, 
  //it won't fit in an int.
  if(len > 11) {
    return false;
  }
  char c = s.charAt(0);
  int i = 0;
  //I don't mind the plus sign, so "+13" will return true.
  if(c == '-' || c == '+') {
    //A single "+" or "-" is not a valid integer.
    if(len == 1) {
      return false;
    }
    i = 1;
  }
  //Check if all chars are digits
  for(; i < len; i++) {
    c = s.charAt(i);
    if(c < '0' || c > '9') {
      return false;
    }
  }
  //If we reached this point then we know for sure that the string has at
  //most 11 chars and that they're all digits (the first one might be a '+'
  // or '-' thought).
  //Now we just need to check, for 10 and 11 chars long strings, if the numbers
  //represented by the them don't surpass the limits.
  c = s.charAt(0);
  char l;
  String limit;
  if(len == 10 && c != '-' && c != '+') {
    limit = "2147483647";
    //Now we are going to compare each char of the string with the char in
    //the limit string that has the same index, so if the string is "ABC" and
    //the limit string is "DEF" then we are gonna compare A to D, B to E and so on.
    //c is the current string's char and l is the corresponding limit's char
    //Note that the loop only continues if c == l. Now imagine that our string
    //is "2150000000", 2 == 2 (next), 1 == 1 (next), 5 > 4 as you can see,
    //because 5 > 4 we can guarantee that the string will represent a bigger integer.
    //Similarly, if our string was "2139999999", when we find out that 3 < 4,
    //we can also guarantee that the integer represented will fit in an int.
    for(i = 0; i < len; i++) {
      c = s.charAt(i);
      l = limit.charAt(i);
      if(c > l) {
        return false;
      }
      if(c < l) {
        return true;
      }
    }
  }
  c = s.charAt(0);
  if(len == 11) {
    //If the first char is neither '+' nor '-' then 11 digits represent a 
    //bigger integer than 2147483647 (10 digits).
    if(c != '+' && c != '-') {
      return false;
    }
    limit = (c == '-') ? "-2147483648" : "+2147483647";
    //Here we're applying the same logic that we applied in the previous case
    //ignoring the first char.
    for(i = 1; i < len; i++) {
      c = s.charAt(i);
      l = limit.charAt(i);
      if(c > l) {
        return false;
      }
      if(c < l) {
        return true;
      }
    }
  }
  //The string passed all tests, so it must represent a number that fits
  //in an int...
  return true;
}

Apache araçlarını deneyebilirsiniz

NumberUtils.isCreatable(myText)

Javadoc'a buradan bakın

Muhtemelen kullanım durumunu da dikkate almanız gerekir:

Çoğu zaman sayıların geçerli olmasını bekliyorsanız, istisnayı yakalamak yalnızca geçersiz sayıları dönüştürmeye çalışırken performans yüküne neden olur. Bazı isInteger()yöntemlerin çağrılması ve ardından dönüştürmenin kullanılması Integer.parseInt()her zaman geçerli sayılar için bir performans yüküne neden olur - dizeler bir kez kontrolle ve bir kez dönüşümle iki kez ayrıştırılır.

Bu, dizenin bir tamsayıya dönüştürülecek aralıkta olup olmadığını kontrol eden Jonas kodunda yapılan bir değişikliktir .

public static boolean isInteger(String str) {
    if (str == null) {
        return false;
    }
    int length = str.length();
    int i = 0;

    // set the length and value for highest positive int or lowest negative int
    int maxlength = 10;
    String maxnum = String.valueOf(Integer.MAX_VALUE);
    if (str.charAt(0) == '-') { 
        maxlength = 11;
        i = 1;
        maxnum = String.valueOf(Integer.MIN_VALUE);
    }  

    // verify digit length does not exceed int range
    if (length > maxlength) { 
        return false; 
    }

    // verify that all characters are numbers
    if (maxlength == 11 && length == 1) {
        return false;
    }
    for (int num = i; num < length; num++) {
        char c = str.charAt(num);
        if (c < '0' || c > '9') {
            return false;
        }
    }

    // verify that number value is within int range
    if (length == maxlength) {
        for (; i < length; i++) {
            if (str.charAt(i) < maxnum.charAt(i)) {
                return true;
            }
            else if (str.charAt(i) > maxnum.charAt(i)) {
                return false;
            }
        }
    }
    return true;
}

Android API'sını kullanıyorsanız şunları kullanabilirsiniz:

TextUtils.isDigitsOnly(str);

Başka seçenek:

private boolean isNumber(String s) {
    boolean isNumber = true;
    for (char c : s.toCharArray()) {
        isNumber = isNumber && Character.isDigit(c);
    }
    return isNumber;
}

is_number = true;
try {
  Integer.parseInt(mystr)
} catch (NumberFormatException  e) {
  is_number = false;
}

Yaptıklarınız işe yarıyor, ama muhtemelen her zaman bu şekilde kontrol etmemelisiniz. Fırlatma istisnaları "istisnai" durumlar için ayrılmalıdır (belki de sizin durumunuza uyan) ve performans açısından çok maliyetlidir.

Number number;
try {
    number = NumberFormat.getInstance().parse("123");
} catch (ParseException e) {
    //not a number - do recovery.
    e.printStackTrace();
}
//use number

Bu yalnızca pozitif tamsayılar için işe yarar.

public static boolean isInt(String str) {
    if (str != null && str.length() != 0) {
        for (int i = 0; i < str.length(); i++) {
            if (!Character.isDigit(str.charAt(i))) return false;
        }
    }
    return true;        
}

Bu benim için çalışıyor. Bir String'in bir ilkel mi yoksa bir sayı mı olduğunu belirlemek için.

private boolean isPrimitive(String value){
        boolean status=true;
        if(value.length()<1)
            return false;
        for(int i = 0;i<value.length();i++){
            char c=value.charAt(i);
            if(Character.isDigit(c) || c=='.'){

            }else{
                status=false;
                break;
            }
        }
        return status;
    }

Tüm int karakterlerini kontrol etmek için çift negatif kullanabilirsiniz.

eğer (! searchString.matches ("[^ 0-9] + $")) ...

[^ 0-9] + $, tamsayı olmayan karakterler olup olmadığını kontrol eder, bu nedenle test doğru ise başarısız olur. Sadece bu DEĞİLDİR ve başarıya ulaşırsınız.

Bunu faydalı bulabilir:

public static boolean isInteger(String self) {
    try {
        Integer.valueOf(self.trim());
        return true;
    } catch (NumberFormatException nfe) {
        return false;
    }
}

Hep güvenle ayrıştırmak altınızda gördüğünüz gibi çünkü bir istisna haline çalışan sıfır risk, orada inanmak intiçinString aksi halde değil.

Yani:

1. Sen kontrol eğer dize eşleşmeleri karakterlerin en az biri karakterin her yuva { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9"} .

   if(aString.substring(j, j+1).equals(String.valueOf(i)))

2. Sen Özetle slotlardaki yukarıdaki karakterler karşılaşılan tüm kez.

   digits++;

3. Son olarak, karakter olarak tamsayılarla karşılaştığınız zamanların verilen dizenin uzunluğuna eşit olup olmadığını kontrol edersiniz.

   if(digits == aString.length())

Ve pratikte:

    String aString = "1234224245";
    int digits = 0;//count how many digits you encountered
    for(int j=0;j<aString.length();j++){
        for(int i=0;i<=9;i++){
            if(aString.substring(j, j+1).equals(String.valueOf(i)))
                    digits++;
        }
    }
    if(digits == aString.length()){
        System.out.println("It's an integer!!");
        }
    else{
        System.out.println("It's not an integer!!");
    }
    
    String anotherString = "1234f22a4245";
    int anotherDigits = 0;//count how many digits you encountered
    for(int j=0;j<anotherString.length();j++){
        for(int i=0;i<=9;i++){
            if(anotherString.substring(j, j+1).equals(String.valueOf(i)))
                    anotherDigits++;
        }
    }
    if(anotherDigits == anotherString.length()){
        System.out.println("It's an integer!!");
        }
    else{
        System.out.println("It's not an integer!!");
    }

Ve sonuçlar:

Bu bir tamsayı !!

Tamsayı değil !!

Benzer şekilde, a'nın Stringa floatveya a olup olmadığını doğrulayabilirsiniz , doubleancak bu gibi durumlarda yalnızca bir tanesiyle karşılaşmanız gerekir . (nokta) Dizede ve tabii ki digits == (aString.length()-1)

Yine, orada burada bir ayrıştırma istisna haline çalışan sıfır risk, ama bunu (let diyelim bir sayı içeren bilinmektedir ki bir dize ayrıştırma planlıyorsanız int veri türü) veri türü uyuyorsa öncelikle kontrol edilmelidir. Aksi takdirde dökmeniz gerekir.

umarım yardımcı olmuşumdur