Учебник по регулярным выражениям Java | Регулярные выражения в Java

Извлечение или проверка данных — важный аспект каждого языка программирования. Один из самых популярных способов проверки данных — использование регулярных выражений. Java использует эти регулярные выражения для описания шаблона символов. Эта статья о Java регулярное выражение перечислит различные методы использования выражений.

Давайте начнем!

Что такое регулярные выражения?

А Регулярное выражение представляет собой последовательность символов, которая создает шаблон поиска. Когда вы ищете данные в тексте, вы можете использовать этот шаблон поиска, чтобы описать то, что вы ищете.

Регулярное выражение может состоять из одного символа или более сложного шаблона. Его можно использовать для любого типа операций текстового поиска и замены текста. Шаблон Regex состоит из простых символов, таких как /абв/или сочетание простых и специальных символов, например /аб*в/ или же /пример(д+).д*/.

Что такое регулярное выражение Java?

Java регулярное выражение это API, который используется для определить шаблон для поиска или управления строками. Он широко используется для определения ограничений для строк, таких как пароль и проверка электронной почты.

Существуют различные методы использования Java Regex. Итак, давайте продолжим и посмотрим на различные выражения.

Класс сопоставления

Этот класс используется для выполнения операций сопоставления последовательности символов. В таблице ниже представлены различные методы класса Matcher.

Класс шаблона

Pattern Class — это скомпилированная версия регулярного выражения, которая используется для определения шаблона для механизма регулярных выражений.

Теперь давайте возьмем небольшой пример, чтобы понять, как написать регулярное выражение.

import java.util.regex.*;
  public class RegexExample{
    public static void main (String[] args){
       Pattern pattern = Pattern.compile(".xx.");
       Matcher matcher = pattern.matcher("AxxB");
       System.out.println("String matches the given Regex - +matcher.matches());
   }
}

В этом случае внутри он использует Pattern и Matcher Ява классы регулярных выражений для обработки, но, очевидно, это уменьшает количество строк кода. Класс Pattern также содержит метод match, который принимает регулярное выражение и входную строку в качестве аргумента и возвращает логический результат после их сопоставления. Таким образом, код отлично работает для сопоставления ввода Нитьс регулярным выражением в Java. Следовательно, вывод будет верным, как показано ниже.

Выход:
true

Теперь давайте рассмотрим еще несколько категорий регулярных выражений Java.

Класс символов регулярных выражений

В таблице ниже представлены различные комбинации классов символов.

Пример:

import java.util.regex.*;
  public class CharacterExample{
    public static void main(String args[]){     
      //false (not x or y or z)
      System.out.println(Pattern.matches("[xyz]", "wbcd"));
      //true (among x or y or z)
      System.out.println(Pattern.matches("[xyz]", "x"));
      //false (x and y comes more than once)
      System.out.println(Pattern.matches("[xyz]", "xxyyyyyz"));
    }
}

Квантификаторы регулярных выражений

Квантификаторы определяют количество вхождений символа. В таблице ниже представлены различные квантификаторы.

Пример:

import java.util.regex.*;
   public class Example{
     public static void main(String args[]){
       System.out.println("? quantifier ....");

       //(a or y or z comes one time)
       System.out.println(Pattern.matches("[ayz]?", "a")); //output: true
       System.out.println(Pattern.matches("[ayz]?", "aaa")); 

       //(a y and z comes more than one time)
       System.out.println(Pattern.matches("[ayz]?", "ayyyyzz")); //output: false

       //(a comes more than one time)
       System.out.println(Pattern.matches("[ayz]?", "amnta")); //output: false

       //(a or y or z must come one time)
       System.out.println(Pattern.matches("[ayz]?", "ay")); //output: false 
       System.out.println("+ quantifier ....");

       //(a or y or z once or more times)
       System.out.println(Pattern.matches("[ayz]+", "a")); //output: true

       //(a comes more than one time)
       System.out.println(Pattern.matches("[ayz]+", "aaa")); //outpu: true

       //(a or y or z comes more than once)
       System.out.println(Pattern.matches([amn]+", "aayyyzz")); //output: true

       //(z and t are not matching pattern)
       System.out.println(Pattern.matches("[ayz]+", "aammta")); //output: false
       System.out.println("* quantifier ....");

       //(a or y or z may come zero or more times)
       System.out.println(Pattern.matches("[ayz]*", "ayyyza")); //output: true
    }
}

По сути, он ищет соответствующий квантификатор и соответствует результату поиска.

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

Пример:

import java.util.regex.*;
   public class MetacharExample{
     public static void main(String args[]){
       // d means digit
       System.out.println("metacharacters d...."); 
       //(non-digit)
       System.out.println(Pattern.matches("d", "abc"));//Output: false 

       //(digit and comes once)
       System.out.println(Pattern.matches("d", "1"));//Output: true 

       //(digit but comes more than once)
       System.out.println(Pattern.matches("d", "4443")); //Output: false

       //(digit and char)
       System.out.println(Pattern.matches("d", "323abc"));//Output: false
       //D means non-digit
       System.out.println("metacharacters D....");

       //(non-digit but comes more than once)
       System.out.println(Pattern.matches("D", "abc")); // Output: false

       //Its a Digit
       System.out.println(Pattern.matches("D", "1")); //Output: false 
       System.out.println(Pattern.matches("D", "4443")); //Output: false 

       // (digit and char)
       System.out.println(Pattern.matches("D", "323abc")); //Output: false
       //(non-digit and comes once)
       System.out.println(Pattern.matches("D", "m")); //Output: true 

       System.out.println("metacharacters D with quantifier....");
       //(non-digit and may come 0 or more times)
       System.out.println(Pattern.matches("D*", "abc")); //Output: true 

     }
}

На основе вышеупомянутых условий он будет отображать выходные данные. Вот как это работает. Итак, это было все о различных типах Java Regex. На этом мы подошли к концу этой статьи. Надеюсь, вы нашли его информативным.

Есть к нам вопрос? Пожалуйста, укажите это в разделе комментариев к этой статье «Java Regex», и мы свяжемся с вами как можно скорее.