Список из 25 регулярных выражений в Java, без которых не обойтись ни новичку, ни профессиональному разработчику. С примерами.

Что такое Regex

Глупо спрашивать об очевидном, но вдруг вы новичок в сфере разработки? ;)

Регулярное выражение – это строка, последовательность символов. Данную строку также принято называть шаблоном, по которому происходит поиск соответствий в других последовательностях символов. Но не каждая строка компилируется в регулярное выражение, а только та, что соответствует их синтаксису.

Что за зверь "Pattern"?

Класс Java Pattern (java.util.regex.Pattern) является основной точкой доступа к API Java регулярных выражений. Всякий раз, когда требуется подключить Regex в работу, все начинается с Java-класса Pattern.

Java Pattern можно использовать двумя способами. Метод Pattern.matches() нужен для быстрой проверки соответствия текста заданному регулярному выражению. Так же можно скомпилировать экземпляр Pattern, используя Pattern.compile().  Его можно использовать несколько раз для сопоставления регулярного выражения с несколькими текстами.

Что за зверь "Matcher"?

Класс Java Matcher (java.util.regex.Matcher) создан для поиска некоторого множества вхождений регулярного выражения в одном тексте и поиска по одному шаблону в разных текстах. Класс Java Matcher имеет много полезных методов.

Например:

• boolean matches(): вернет значение true при совпадении строки с шаблоном.
• boolean find(): вернет значение true при обнаружении подстроки, совпадающей с шаблоном, и перейдет к ней.
• int start(): вернет значение индекса соответствия.
• int end(): вернет значение индекса последующего соответствия.
• String replaceAll(String str): вернет значение измененной строки подстрокой str.

Другие методы Matcher можно найти в официальной документации.

Рассмотрите простой пример работы с Pattern и Matcher.

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {

public static void main (String[] args) {

Pattern pattern1 = Pattern.compile ("[x-z]+");//Поиск будет происходить от x до z включительно.
//Поиск будет происходить только по символам нижнего регистра.
//Чтобы отключить чувствительность к регистру, можно использовать Pattern.CASE_INSENSITIVE.

Matcher matcher1 = pattern1.matcher ("x y z 1 2 3 4 ");
System.out.println (matcher1.find()); //Поиск любого совпадения с шаблоном.
//Выводится значение true, так как в строке есть символы шаблона.

Matcher matcher2 = pattern1.matcher ("X Y Z 1 2 3 4");
System.out.println (matcher2.find()); //Выводится значение false.
//Так как в строке нет символов, подходящих по шаблону.

Pattern pattern2 = Pattern.compile ("[a-zA-Z0-9]");
//Добавляется поиск по символам нижнего и верхнего регистра, а также цифр.

Matcher matcher3 = pattern2.matcher ("A B C D X Y Z a b c d x y z 1 2 3 4");
System.out.println (matcher3.find()); //Выводится значение true

25 самых используемых регулярных выражений

Следующие метасимволы имеют предопределенное значение и упрощают использование некоторых общих шаблонов, например, \d вместо [0..9].

Квантификаторы

Квантификатор определяет частоту появления элемента. Символы ?, *, + и {} определяют количество регулярных выражений:

Квантификаторы имеют три режима, которые называют сверхжадным, жадным и ленивым.

Жадный режим

“A.+a”// Ищет максимальное по длине совпадение в строке.

//Пример жадного квантификатора
import java.util.regex.Matcher; 
import java.util.regex.Pattern; 
   
public class Main 
{ 
    public static void main(String[] args) 
    { 
         
        Pattern p = Pattern.compile("a+"); 
        Matcher m = p.matcher("aaa"); 
   
        while (m.find()) 
            System.out.println("Pattern found from " + m.start() + 
                               " to " + (m.end()-1)); 
   
    } 
}

Output:

Pattern found from 0 to 2

Сверхжадный режим

"А.++а"?// Работает также как и жадный режим, но не производит реверсивный поиск при захвате строки.

// Пример сверхжадного квантификатора
import java.util.regex.Matcher; 
import java.util.regex.Pattern; 
   
public class Main 
{ 
    public static void main(String[] args) 
    {  
        Pattern p = Pattern.compile("a++"); 
        Matcher m = p.matcher("aaa"); 
   
        while (m.find()) 
            System.out.println("Pattern found from " + m.start() + 
                               " to " + (m.end()-1));  
    } 
}

Output:

Pattern found from 0 to 2

Ленивый режим

“A.+?a”// Ищет самое короткое совпадение.

//Пример ленивого квантификатора
import java.util.regex.Matcher; 
import java.util.regex.Pattern; 
   
public class Main
{ 
    public static void main(String[] args) 
    { 
        Pattern p = Pattern.compile("g+?"); 
        Matcher m = p.matcher("ggg"); 
   
        while (m.find()) 
            System.out.println("Pattern found from " + m.start() + 
                               " to " + (m.end()-1)); 
   
    } 
}

Output:

Pattern found from 0 to 0
Pattern found from 1 to 1
Pattern found from 2 to 2

Профессиональные разработчики все время работают с регулярными выражениями. Перенимайте их практику: при частом использовании регулярки запомнятся быстро и существенно сэкономят время.

У вас случалось, что вы не можете вспомнить, что сами написали ранее? :) Следите, чтобы регулярные выражения комментировались в коде. Особенно это касается новых для вас регулярок. А если всё-таки запутаетесь, помогут сервисы для тестирования и отладки.

Хотите расширить диапазон нашего must-have списка? Пишите в комментариях, что бы вы добавили в наш ТОП.

Полезные материалы по теме:

• ТОП-10 лучших книг по Java для программистов
• ТОП-25 трюков, советов и лучших практик программирования на Java
• Большая подборка книг, видео и статей для Java Junior
• Изучаем Java: дайджест для новичков в программировании