Проверка регулярного выражения на целочисленную действительность и диапазон

1

Я хочу сделать регулярное выражение, которое может помочь мне избавиться от следующего фрагмента кода -

public class Test {
    public static void main(String[] args) {
        String test = "1026";
        int testToInt = 0;
        if(checkIfInteger(test))
            testToInt = Integer.parseInt(test);
        if(testToInt >= 1024 && testToInt <= 65535)
            System.out.println("Validity is perfect");
        else
            System.out.println("Validity is WRONG");
    }

    public static boolean checkIfInteger(String givenString) {
        boolean check = false;
        for(int i = 0; i < givenString.length(); i++) {
            if(givenString.charAt(i) >= '0' && givenString.charAt(i) >= '9')
                check = true;
            else {
                check = false;
                break;
            }
        }
        return check;
    }
}

В основном, он проверяет, содержит ли строка только числовые цифры, а также, что его диапазон находится между 1024 и 65535.

Для этой цели я создал следующее регулярное выражение -

"\b(102[4-9]|10[3-9][0-9]|1[1-9][0-9]{2}|[2-9][0-9]{3}|[1-5][0-9]{4}|6[0-4][0-9]{3}|65[0-4][0-9]{2}|655[01][0-9]|6552[0-5])\b"

Но есть много значений, для которых он терпит неудачу. Может ли кто-нибудь дать мне разумный/правильный способ сделать это?

Здесь тестовый файл, если вы хотите проверить свое регулярное выражение -

public class Test {
    public static void main(String[] args) {

        for (int i = 0; i < 1024; i++) {
            if (String
                    .valueOf(i)
                    .matches(
                            "\b(102[4-9]|10[3-9][0-9]|1[1-9][0-9]{2}|[2-9][0-9]{3}|[1-5][0-9]{4}|6[0-4][0-9]{3}|65[0-4][0-9]{2}|655[01][0-9]|6552[0-5])\b"))
                System.out.println("Hum " + i);
        }


        for (int i = 1025; i < (int) Math.pow(2, 16); i++) {
            if (!String
                    .valueOf(i)
                    .matches(
                            "\b(102[4-9]|10[3-9][0-9]|1[1-9][0-9]{2}|[2-9][0-9]{3}|[1-5][0-9]{4}|6[0-4][0-9]{3}|65[0-4][0-9]{2}|655[01][0-9]|6552[0-5])\b"))
                System.out.println("Hum " + i);
        }

        for (int i = 0; i < 100; i++) {
            if (String
                    .valueOf((int)Math.pow(2, 16) + i)
                    .matches(
                            "\b(102[4-9]|10[3-9][0-9]|1[1-9][0-9]{2}|[2-9][0-9]{3}|[1-5][0-9]{4}|6[0-4][0-9]{3}|65[0-4][0-9]{2}|655[01][0-9]|6552[0-5])\b"))
                System.out.println("Hum " + i);
        }

    }
}
  • 0
    Просто интересно - что не так с тем фрагментом кода, который у тебя есть сейчас?
  • 1
    Разумнее: не используйте регулярные выражения ...?
Показать ещё 6 комментариев
Теги:

4 ответа

0
^(?:102[4-9]|10[3-9]\d|1[1-9]\d{2}|[2-9]\d{3}|[1-5]\d{4}|6[0-4]\d{3}|65[0-4]\d{2}|655[0-2]\d|6553[0-5])$

Вы можете попробовать это regex.See демо.

https://regex101.com/r/sJ9gM7/70

  • 0
    Да :). Хорошая итеративная разработка
  • 0
    @halex да с таким исчерпывающим тестированием это должно было случиться: P thanx :)
0

Измените свой код

из:

 testToInt = Integer.parseInt(test);
        if(testToInt >= 1024 && testToInt <= 65535)
            System.out.println("Validity is perfect");
        else
            System.out.println("Validity is WRONG");

Для того, чтобы:

try {
      testToInt = Integer.parseInt(test);
     if(testToInt >= 1024 && testToInt <= 65535)
        System.out.println("Validity is perfect");
    else
        System.out.println("Validity is WRONG");
    }  
      catch(NumberFormatException nfe)  
   {  
      System.out.println("Validity is WRONG"); 
   }  
0

Выбросив Exception здесь, ИМО будет лучшей стратегией, чем возвращение логического.

Что-то вроде:

public int parseAndCheck(String val, int low, int high) throws IllegalArgumentException {
  try {
    int num = Integer.parseInt(val);
    if (num < low || num > high) throw new IllegalArgumentException(val);
    return num;
  }
  catch (NumberFormatException ex) {
    throw new IllegalArgumentException(ex);
  }
}
0

В Java вам нужно использовать двойные экранированные символы, поэтому после исправления этого бита строка регулярного выражения выглядит так:

String pattern = "\\b(102[4-9]|10[3-9][0-9]|1[1-9][0-9]{2}|[2-9][0-9]{3}|[1-5][0-9]{4}|6[0-4][0-9]{3}|65[0-4][0-9]{2}|655[01][0-9]|6552[0-5])\\b";

Это уже многое исправляет, я получаю только эти "Hum":

Hum 65526                                                                                                                                                           
Hum 65527                                                                                                                                                           
Hum 65528                                                                                                                                                           
Hum 65529                                                                                                                                                           
Hum 65530                                                                                                                                                           
Hum 65531                                                                                                                                                           
Hum 65532                                                                                                                                                           
Hum 65533                                                                                                                                                           
Hum 65534                                                                                                                                                           
Hum 65535 

Теперь, добавив |6553[0-5] я получаю полностью действующее регулярное выражение:

String pattern = "\\b(102[4-9]|10[3-9][0-9]|1[1-9][0-9]{2}|[2-9][0-9]{3}|[1-5][0-9]{4}|6[0-4][0-9]{3}|65[0-4][0-9]{2}|655[012][0-9]|6552[0-5]|6553[0-5])\\b";

Примерная программа, основанная на вашем тестовом коде, доступна здесь.

Ещё вопросы

Сообщество Overcoder
Наверх
Меню