Регулярные выражения Java с использованием шаблона и сопоставления

Question

Мой вопрос связан с регулярными выражениями на Java и, в частности, несколькими совпадениями для данного шаблона поиска. Вся информация, которую мне нужно получить, находится в одной строке и содержит псевдоним (например, SA), который сопоставляется с IP-адресом. Каждый из них разделяется запятой. Мне нужно извлечь каждый из них.

SA "239.255.252.1", SB "239.255.252.2", SC "239.255.252.3", SD "239.255.252.4" 

Моего Reg Ex выглядит следующим образом:

Pattern alias = Pattern.compile("(\\S+)\\s+\"(\\d+\\.\\d+\\.\\d+\\.\\d+)\""); 
Matcher match = alias.matcher(lineInFile) 
while(match.find()) { 
    // do something 
} 

Это работает, но я не полностью счастлив с ним, потому что с введением этой небольшой кусок коды, моя программа немного замедлилась (< 1 сек), но достаточно заметить разницу.

Итак, мой вопрос: я собираюсь об этом правильно? Существует ли более эффективное или возможно легкое решение без необходимости в течение некоторого цикла (совпадения)? и/или классы Pattern/Matcher?

Answer 1

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

Answer 2

Боюсь, что ваш код выглядит довольно эффективно. Вот моя версия:

Matcher match = Pattern 
       .compile("(\\w+)\\s+\"(\\d+\\.\\d+\\.\\d+\\.\\d+)\"") 
       .matcher(lineInFile); 
while(match.find()) { 
    //do something 
} 

Есть два микро-оптимизация:

1. Нет необходимости держать шаблон дополнительной переменным, встраиваемые, что
2. Для псевдонима, поиск по слову символов , а не непрямые символы

Фактически, если вы много обрабатываете, как это, и образец никогда не меняется, вы должны сохранить скомпилированный шаблон в константе:

private static final Pattern PATTERN = Pattern 
      .compile("(\\w+)\\s+\"(\\d+\\.\\d+\\.\\d+\\.\\d+)\""); 

Matcher match = PATTERN.matcher(lineInFile); 
while(match.find()) { 
    //do something 
} 

---

Update: Я взял некоторое время на RegExr придумать гораздо более конкретный шаблон, который должен только обнаружить действительный IP-адрес как бонус. Я знаю, что это некрасиво, как ад, но я думаю, что это довольно эффективным, поскольку он устраняет большую часть возвратов:

([A-Z]+)\s*\"((?:1[0-9]{2}|2(?:(?:5[0-5]|[0-9]{2})|[0-9]{1,2})\.) 
{3}(?:1[0-9]{2}|2(?:5[0-5]|[0-9]{2})|[0-9]{1,2})) 

(обернутые для удобства чтения, все обратные косые черты должны быть экранированы в Java, но вы можете проверьте его на RegExr, как и в тестовой строке OP)

Answer 3

Вы можете улучшить свое регулярное выражение до: "(\\S{2})\\s+\"((\\d{1,3}\\.){3}\\d{1,3})\"", указав IP-адрес более явно.

Оцените эффективность использования StringTokenizer. Он не использует регулярные выражения. (Если вас беспокоит использование устаревшего класса, взгляните на его источник и посмотрите, как это делается.)

StringTokenizer st = new StringTokenizer(lineInFile, " ,\""); 
while(st.hasMoreTokens()){ 
    String key = st.nextToken(); 
    String ip = st.nextToken(); 
    System.out.println(key + " ip: " + ip); 
} 

Answer 4

Я не знаю, если это даст большой выигрыш в производительности, но вы можете сделать первый

string.split(", ") // separate groups 

, а затем

string.split(" ?\"") // separate alias from IP address 

на матчи.

Answer 5

Предварительная компиляция и повторное использование объекта Pattern (IMO), вероятно, является наиболее эффективной оптимизацией. Компиляция шаблонов - потенциально дорогостоящий шаг.

Повторное использование экземпляра Matcher (например, с использованием reset(CharSequence)) может помочь, но я сомневаюсь, что это будет иметь большое значение.

Само регулярное выражение не может быть оптимизировано значительно. Одним из возможных ускорений будет замена (\d+\.\d+\.\d+\.\d+) на ([0-9\.]+). Это может помочь, поскольку оно уменьшает количество потенциальных точек отскока ... но вам нужно будет сделать некоторые эксперименты, чтобы быть уверенными. И очевидным недостатком является то, что он соответствует символьным последовательностям, которые не являются допустимыми IP-адресами.

Answer 6

Если вы заметили разницу в < 1 сек на этом фрагменте кода, то ваша строка ввода должна содержать около миллиона (от не менее 100 тыс.) Записей. Я думаю, что это довольно хорошая производительность, и я не вижу, как вы могли бы значительно оптимизировать это, не называя свой собственный специализированный парсер.