Задержка в Regex без явной максимальной длины в Java

Я всегда думал, что утверждение в regex-API Java (и многих других языках) должно иметь очевидную длину. Таким образом, квантификаторы STAR и PLUS недопустимы.

Отличный онлайн-ресурс регулярные-выражения.info, кажется, подтверждает (некоторые из) мои предположения:

"[...] Java делает вещи на шаг вперед, разрешая конечное повторение. Вы по-прежнему не можете использовать звезду или плюс, но вы можете использовать вопросительный знак и фигурные скобки с указанным параметром max. Java распознает тот факт, что конечное повторение может быть переписан как чередование строк с разными, но фиксированными длинами. К сожалению, в JDK 1.4 и 1.5 есть некоторые ошибки, когда вы используете чередование в lookbehind. Они были исправлены в JDK 1.6. [...] "

- http://www.regular-expressions.info/lookaround.html

Использование фигурных скобок работает до тех пор, пока общая длина диапазона символов внутри вспомогательного элемента меньше или равна Integer.MAX_VALUE. Таким образом, эти регулярные выражения действительны:

"(?<=a{0,"   +(Integer.MAX_VALUE)   + "})B"
"(?<=Ca{0,"  +(Integer.MAX_VALUE-1) + "})B"
"(?<=CCa{0," +(Integer.MAX_VALUE-2) + "})B"

Но это не так:

"(?<=Ca{0,"  +(Integer.MAX_VALUE)   +"})B"
"(?<=CCa{0," +(Integer.MAX_VALUE-1) +"})B"

Однако я не понимаю следующее:

Когда я запускаю тест с использованием квантификаторов * и + в поиске, все идет хорошо (см. Выходные данные Test 1 и Test 2).

Но когда я добавляю один символ в начале просмотра из Теста 1 и Теста 2, он ломается (см. Вывод Тест 3).

Выдавливание жадности * из теста 3 не дает никакого эффекта, оно все еще ломается (см. Тест 4).

Вот тестовая подвеска:

public class Main {

    private static String testFind(String regex, String input) {
        try {
            boolean returned = java.util.regex.Pattern.compile(regex).matcher(input).find();
            return "testFind       : Valid   -> regex = "+regex+", input = "+input+", returned = "+returned;
        } catch(Exception e) {
            return "testFind       : Invalid -> "+regex+", "+e.getMessage();
        }
    }

    private static String testReplaceAll(String regex, String input) {
        try {
            String returned = input.replaceAll(regex, "FOO");
            return "testReplaceAll : Valid   -> regex = "+regex+", input = "+input+", returned = "+returned;
        } catch(Exception e) {
            return "testReplaceAll : Invalid -> "+regex+", "+e.getMessage();
        }
    }

    private static String testSplit(String regex, String input) {
        try {
            String[] returned = input.split(regex);
            return "testSplit      : Valid   -> regex = "+regex+", input = "+input+", returned = "+java.util.Arrays.toString(returned);
        } catch(Exception e) {
            return "testSplit      : Invalid -> "+regex+", "+e.getMessage();
        }
    }

    public static void main(String[] args) {
        String[] regexes = {"(?<=a*)B", "(?<=a+)B", "(?<=Ca*)B", "(?<=Ca*?)B"};
        String input = "CaaaaaaaaaaaaaaaBaaaa";
        int test = 0;
        for(String regex : regexes) {
            test++;
            System.out.println("********************** Test "+test+" **********************");
            System.out.println("    "+testFind(regex, input));
            System.out.println("    "+testReplaceAll(regex, input));
            System.out.println("    "+testSplit(regex, input));
            System.out.println();
        }
    }
}

Выход:

********************** Test 1 **********************
    testFind       : Valid   -> regex = (?<=a*)B, input = CaaaaaaaaaaaaaaaBaaaa, returned = true
    testReplaceAll : Valid   -> regex = (?<=a*)B, input = CaaaaaaaaaaaaaaaBaaaa, returned = CaaaaaaaaaaaaaaaFOOaaaa
    testSplit      : Valid   -> regex = (?<=a*)B, input = CaaaaaaaaaaaaaaaBaaaa, returned = [Caaaaaaaaaaaaaaa, aaaa]

********************** Test 2 **********************
    testFind       : Valid   -> regex = (?<=a+)B, input = CaaaaaaaaaaaaaaaBaaaa, returned = true
    testReplaceAll : Valid   -> regex = (?<=a+)B, input = CaaaaaaaaaaaaaaaBaaaa, returned = CaaaaaaaaaaaaaaaFOOaaaa
    testSplit      : Valid   -> regex = (?<=a+)B, input = CaaaaaaaaaaaaaaaBaaaa, returned = [Caaaaaaaaaaaaaaa, aaaa]

********************** Test 3 **********************
    testFind       : Invalid -> (?<=Ca*)B, Look-behind group does not have an obvious maximum length near index 6
(?<=Ca*)B
      ^
    testReplaceAll : Invalid -> (?<=Ca*)B, Look-behind group does not have an obvious maximum length near index 6
(?<=Ca*)B
      ^
    testSplit      : Invalid -> (?<=Ca*)B, Look-behind group does not have an obvious maximum length near index 6
(?<=Ca*)B
      ^

********************** Test 4 **********************
    testFind       : Invalid -> (?<=Ca*?)B, Look-behind group does not have an obvious maximum length near index 7
(?<=Ca*?)B
       ^
    testReplaceAll : Invalid -> (?<=Ca*?)B, Look-behind group does not have an obvious maximum length near index 7
(?<=Ca*?)B
       ^
    testSplit      : Invalid -> (?<=Ca*?)B, Look-behind group does not have an obvious maximum length near index 7
(?<=Ca*?)B
       ^

Мой вопрос может быть очевиден, но я все равно задам его: может ли кто-нибудь объяснить мне, почему Тест 1 и 2 не пройден, а Тест 3 и 4 - нет? Я бы ожидал, что все они потерпят неудачу, не половина из них будет работать, а половина из них выйдет из строя.

Благодарю.

PS. Я использую: Java версия 1.6.0_14

Источник

2 ответа

Решение

Взглянув на исходный код для Pattern.java, вы обнаружите, что '*' и '+' реализованы как экземпляры Curly (это объект, созданный для операторов curly). Так,

a*

реализуется как

a{0,0x7FFFFFFF}

а также

a+

реализуется как

a{1,0x7FFFFFFF}

Вот почему вы видите точно такое же поведение для фигур и звезд.

Источник

Это ошибка: http://bugs.sun.com/view_bug.do?bug_id=6695369

Pattern.compile() всегда должен генерировать исключение, если он не может определить максимально возможную длину совпадения с задним взглядом.

Источник
Другие вопросы по тегам