ما هي أفضل طريقة للتحقق مما إذا كانت السلسلة تمثل عددًا صحيحًا في Java؟

StackOverflow https://stackoverflow.com/questions/237159

  •  04-07-2019
  •  | 
  •  

سؤال

عادةً ما أستخدم المصطلح التالي للتحقق مما إذا كان من الممكن تحويل السلسلة إلى عدد صحيح.

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

هل أنا فقط أم أن هذا يبدو مبتذلاً بعض الشيء؟ما هي الطريقة الأفضل؟

راجع إجابتي (مع المعايير، بناءً على إجابة سابقة بواسطة CodingWithSpike) لمعرفة سبب عكس موقفي وقبلت إجابة جوناس كليمنج لهذه المشكلة.أعتقد أن معظم الأشخاص سيستخدمون هذا الكود الأصلي لأنه أسرع في التنفيذ، وأكثر قابلية للصيانة، ولكنه يكون أبطأ من حيث الحجم عندما يتم توفير بيانات غير صحيحة.

هل كانت مفيدة؟

المحلول

إذا كنت لا تهتم مشاكل تجاوز المحتملة وهذه الوظيفة أداء حوالي 20-30 مرات أسرع من استخدام 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;
}

نصائح أخرى

لديك، ولكن يجب عليك ان تصطاد فقط NumberFormatException.

ومنذ هناك احتمال أن الناس لا يزالون زيارة هنا وسوف يكون متحيزا ضد التعبيرات المنتظمة بعد المعايير ... لذلك أنا ستعمل إعطاء نسخة محدثة من المؤشر، مع نسخة المترجمة من التعبيرات المنتظمة. التي تعارض المعايير السابقة، هذا واحد يظهر التعبيرات المنتظمة حل له الأداء الجيد دائما في الواقع.

ونسخ من مشروع قانون السحلية وتحديثها مع النسخة المترجمة: 

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

والنتائج: 

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

هل معيارا سريع. الاستثناءات ليست في الواقع أن expensivve، إلا إذا كنت بدء ظهرت العودة أساليب متعددة وJVM أن تفعل الكثير من العمل للحصول على كومة التنفيذ في المكان. عندما يقيمون في نفس الأسلوب، فهي ليست سيئة الأداء. 

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

وإخراج:

<اقتباس فقرة>   

وByException: 31

     

وByRegex: 453 (ملاحظة: إعادة تجميع النمط في كل مرة)

     

وByJonas: 16

وأنا أوافق على أن حل جوناس K هو الأكثر قوية جدا. يبدو انه الفوز بالدوري:) 

org.apache.commons.lang.StringUtils.isNumeric

وعلى الرغم من ليب القياسية جاوة يفتقد حقا مثل هذه الوظائف ذات المنفعة

وأعتقد أن أباتشي العموم هو "يجب أن يكون" لكل مبرمج جافا

وسيئة للغاية أنها ليست استدار إلى Java5 بعد

وانها تعتمد جزئيا على ما تعنيه ب "يمكن تحويلها إلى عدد صحيح".

إذا كنت تعني "يمكن تحويلها إلى عدد صحيح في جافا" ثم الجواب من جوناس هو بداية جيدة، ولكن لا تنتهي تماما بهذه المهمة. فإنه تمرير +999999999999999999999999999999 على سبيل المثال. وأود أن أضيف الدعوة حاول / الصيد العادية من السؤال الخاص بك في نهاية الأسلوب.

وسوف يتحقق حرف من حرف ترفض بكفاءة "ليس صحيحا على الإطلاق" الحالات، وترك "انها صحيح ولكن جافا لا يمكن التعامل معها" الحالات ليتم القبض بالطريق استثناء أبطأ. أنت <م> قد قيام بذلك قليلا باليد أيضا، ولكن سيكون من الكثير أكثر تعقيدا.

واحد فقط تعليق حول التعبير العادي. كل سبيل المثال المقدمة هنا هو الخطأ! إذا كنت ترغب في استخدام التعبير العادي لا ننسى أن تجميع نمط تأخذ الكثير من الوقت. هذا: 

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

وهذا أيضا: 

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

والأسباب وتجميع من النمط في كل استدعاء الأسلوب. لاستخدامه بشكل صحيح اتبع: 

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

وأنا نسخ رمز من rally25rs الإجابة وإضافة بعض الاختبارات للحصول على بيانات غير صحيحة. وكانت النتائج لا يمكن إنكارها لصالح طريقة المرسلة بواسطة جوناس Klemming. نتائج لأسلوب الاستثناء التي نشرت لي في الأصل هي جيدة عندما يكون لديك بيانات عدد صحيح، ولكنها أسوأ عندما لم تقم بذلك، بينما (استخدم أن أراهن الكثير من الناس) نتائج الحل باستخدام التعابير المنطقية كانت باستمرار سيئة. انظر href="https://stackoverflow.com/a/7324087/1288"> للحصول على مثال رجإكس المترجمة، وهو أسرع بكثير. 

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

والنتائج: 

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

وهناك نسخة الجوافة: 

import com.google.common.primitives.Ints;

Integer intValue = Ints.tryParse(stringValue);

ووسيعود لاغية بدلا من رمي استثناء إذا فشلت في تحليل السلسلة.

وهذا هو أقصر، ولكن أقصر ليست بالضرورة أفضل (وأنه لن يمسك قيم الأعداد التي هي خارج النطاق، <وأ href = "https://stackoverflow.com/questions/237159/whats-the- أفضل طريقة ل-تحقق لنرى اذا واحد في سلسلة يمثل-على-صحيح في وجافا # 237161 "> كما أشار في تعليق danatel في ): 

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

وشخصيا، حيث يتم إخفاؤه تنفيذ بعيدا في أسلوب مساعد وصحة ينسخ طول، كنت أذهب فقط مع شيء من هذا القبيل ما لديك (ناقص اصطياد الفئة الأساسية Exception بدلا من NumberFormatException).

يمكنك استخدام الأسلوب مباريات الدرجة السلسلة. و[0-9] يمثل جميع القيم التي يمكن أن يكون، و+ يعني أنه يجب أن يكون حرف واحد على الأقل طويلة، و* يعني أنها يمكن أن تكون الأحرف صفر أو أكثر لفترة طويلة. 

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

وهذا هو الاختلاف جافا 8 جوناس Klemming الجواب: 

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

ورمز اختبار: 

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

ونتائج اختبار رمز: 

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

إذا مجموعة سلسلة الخاص بك يحتوي على الأعداد الصحيحة النقية وسلاسل، رمز أدناه يجب أن تعمل. أنك لا تملك إلا أن ننظر إلى الحرف الأول. مثلا [ "4"، "44"، "اي بي سي"، "77"، "السندات"] 

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

ويمكنك أيضا استخدام الصف، واستخدام hasNextInt () - وهذا يسمح لك اختبار لأنواع أخرى أيضا، مثل العوامات، الخ

.

وماذا عن: 

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

وأنت تحقق فقط على NumberFormatException : في - 

 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 
 }

يمكنك محاولة تيلس اباتشي 

NumberUtils.isNumber( myText)

<وأ href = "http://commons.apache.org/proper/commons-lang/javadocs/api-2.6/org/apache/commons/lang/math/NumberUtils.html#isNumber٪28java.lang. سلسلة٪ 29 "يختلط =" نوفولو "> انظر جافادوك هنا

وربما كنت بحاجة الى اتخاذ حالة استخدامها في حساب أيضا:

وإذا كان معظم الوقت الذي نتوقع الأرقام لتكون صالحة، ثم اصطياد استثناء يسبب فقط فوق الأداء عند محاولة تحويل الأرقام غير صالحة. في حين دعا بعض الطرق isInteger() ومن ثم تحويل باستخدام Integer.parseInt() سوف <م> دائما يتسبب في النفقات العامة الأداء لأرقام صحيحة - يتم تحليل السلاسل مرتين، مرة من قبل الاختيار واحدة عن طريق تحويل

هذا تعديل على جوناس"رمز يتحقق مما إذا كانت السلسلة ضمن النطاق ليتم تحويلها إلى عدد صحيح. 

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

إذا كنت تستخدم API الروبوت التي يمكنك استخدامها: 

TextUtils.isDigitsOnly(str);

وثمة خيار آخر: 

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

إذا كنت ترغب في معرفة ما اذا كان يمثل سلسلة عددا صحيحا التي تناسبها في نوع int، فعلت القليل من التعديل على الإجابة جوناس "، بحيث السلاسل التي تمثل الأعداد الصحيحة أكبر من Integer.MAX_VALUE أو أصغر من Integer.MIN_VALUE، والآن عودة كاذبة. على سبيل المثال: "3147483647" سيعود كاذبة لأن 3147483647 هو أكبر من 2147483647، وبالمثل، "-2147483649" كما عودة كاذبة ل-2147483649 -2147483648 أصغر من

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

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

ما فعلته ينجح، ولكن ربما لا ينبغي عليك التحقق دائمًا بهذه الطريقة.يجب أن يتم حجز الاستثناءات للمواقف "الاستثنائية" (ربما يناسب حالتك)، وهي مكلفة للغاية من حيث الأداء.

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

وهذا من شأنه أن تعمل فقط من أجل الأعداد الصحيحة الموجبة. 

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

وهذا يعمل بالنسبة لي. ببساطة لتحديد ما إذا كانت سلسلة هي بدائية أو رقم. 

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

لتحقق لجميع أحرف كثافة العمليات، يمكنك ببساطة استخدام النفي المزدوج.

وإذا (! searchString.matches ( "[^ 0-9] + $")) ...

[^ 0-9] + $ الشيكات لمعرفة ما إذا كان هناك أي أحرف غير صحيح، لذلك فشل الاختبار إذا كان هذا صحيحا. ليس فقط أن وتحصل الحقيقي على النجاح.

والبحث عن هذه مايو مفيدة: 

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

أعتقد أنه لا يوجد أي خطر في حدوث استثناء، لأنه كما ترون أدناه، فإنك تقوم دائمًا بالتحليل بأمان int ل String وليس العكس.

لذا:

  1. أنت يفحص إذا تطابق كل فتحة من الأحرف في سلسلتك واحدة على الأقل من الشخصيات {"0","1","2","3","4","5","6","7","8","9"}. 

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

  2. أنت مجموع في جميع الأوقات التي واجهتها في فتحات الشخصيات أعلاه.

    digits++;

  3. وأخيرا أنت يفحص إذا كانت الأوقات التي واجهت فيها أعداد صحيحة حيث تساوي الأحرف بطول السلسلة المحددة. 

    if(digits == aString.length())

وعمليا لدينا:

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

والنتائج هي:

إنه عدد صحيح!!

إنه ليس عدداً صحيحاً!!

وبالمثل، يمكنك التحقق من صحة ما إذا كان أ String هو float أو أ double ولكن في تلك الحالات عليك أن تواجه واحد فقط . (نقطة) في السلسلة وبالطبع تحقق مما إذا digits == (aString.length()-1)

مرة أخرى، ليس هناك أي خطر في حدوث استثناء تحليل هنا، ولكن إذا كنت تخطط لتحليل سلسلة فمن المعروف أنها تحتوي على رقم (على سبيل المثال كثافة العمليات نوع البيانات) يجب عليك أولاً التحقق مما إذا كان مناسبًا لنوع البيانات.وإلا يجب عليك أن تلقيها.

أرجو أن أكون ساعدت

مرخصة بموجب: CC-BY-SA مع الإسناد
لا تنتمي إلى StackOverflow
scroll top