تعبير منتظم في جافا – مثال Regex في جافا

الدروس التعليمية
Java

مرحبًا بك في تعبيرات العبارات العادية في جافا. يُطلق عليها أيضًا Regex في جافا. عندما بدأت في البرمجة ، كانت تعبيرات العبارات العادية في جافا كابوسًا بالنسبة لي. يهدف هذا البرنامج التعليمي لمساعدتك في إتقان تعبيرات العبارات العادية في جافا. سأعود أيضًا إلى هنا لتجديد تعلمي لتعبيرات العبارات العادية في جافا.

تعبيرات العبارات العادية في جافا

تعرف تعبيرات العبارات العادية في جافا نمطًا لسلسلة النص. يمكن استخدام تعبيرات العبارات العادية للبحث وتحرير أو تلاعب النص. لا تعتمد تعبيرات العبارات العادية على لغة معينة ولكنها تختلف قليلاً من لغة لأخرى. تعبيرات العبارات العادية في جافا تشبه إلى حد كبير لغة بيرل. تحتوي فئات تعبيرات العبارات العادية في جافا على حزمة java.util.regex التي تحتوي على ثلاث فئات:

  1. Pattern: كائن Pattern هو النسخة المترجمة لتعبير العبارات العادية. فئة Pattern ليس لديها أي بناء عام ونستخدم الطريقة الثابتة العامة compile لإنشاء كائن النمط بتمرير وسيط تعبير العبارة العادية.
  2. Matcher: Matcher هو كائن محرك تعبيرات الجافا يطابق نمط السلسلة المدخلة مع كائن النمط المنشأ. الفئة Matcher ليس لديها أي منشئ عام ونحصل على كائن Matcher باستخدام طريقة matcher لكائن النمط التي تأخذ سلسلة المدخلات كوسيطة. ثم نستخدم طريقة matches التي تعيد نتيجة بوليانية بناءً على مطابقة سلسلة المدخلات لنمط regex أم لا.
  3. PatternSyntaxException: يتم رمي استثناء PatternSyntaxException إذا كانت بنية تعبير العادة العادية غير صحيحة.

لنلقي نظرة على برنامج مثال لتعبيرات جافا Regex.

package com.journaldev.util;

import java.util.regex.*;

public class PatternExample {

	public static void main(String[] args) {
		Pattern pattern = Pattern.compile(".xx.");
		Matcher matcher = pattern.matcher("MxxY");
		System.out.println("Input String matches regex - "+matcher.matches());
		// bad regular expression
		pattern = Pattern.compile("*xx*");

	}

}

عند تشغيل برنامج مثال تعبيرات جافا هذا ، نحصل على الناتج التالي.

Input String matches regex - true
Exception in thread "main" java.util.regex.PatternSyntaxException: Dangling meta character '*' near index 0
*xx*
^
	at java.util.regex.Pattern.error(Pattern.java:1924)
	at java.util.regex.Pattern.sequence(Pattern.java:2090)
	at java.util.regex.Pattern.expr(Pattern.java:1964)
	at java.util.regex.Pattern.compile(Pattern.java:1665)
	at java.util.regex.Pattern.(Pattern.java:1337)
	at java.util.regex.Pattern.compile(Pattern.java:1022)
	at com.journaldev.util.PatternExample.main(PatternExample.java:13)

نظرًا لأن تعبيرات جافا العادية تدور حول سلسلة ، فقد تم تمديد فئة السلسلة في جافا 1.4 لتوفير طريقة تطابق تعبيرات الجافا التي تستخدم داخليًا فئتي Pattern و Matcher للقيام بالمعالجة ولكن بالطبع تقلل من أسطر الكود. تحتوي فئة Pattern أيضًا على طريقة matches التي تأخذ تعبيرًا عاديًا وسلسلة مدخلات كوسيطة وتعيد نتيجة بوليانية بعد مطابقتها. لذلك يعمل الكود أدناه بشكل جيد لمطابقة سلسلة المدخلات مع تعبير عادي في جافا.

String str = "bbb";
System.out.println("Using String matches method: "+str.matches(".bb"));
System.out.println("Using Pattern matches method: "+Pattern.matches(".bb", str));

إذا كان مطلبك هو فقط التحقق مما إذا كانت السلسلة المدخلة تتطابق مع النمط، يجب عليك توفير الوقت وعدد الأسطر من خلال استخدام طريقة بسيطة لمطابقة السلاسل. يجب أن تستخدم فئتي Pattern و Matches فقط عندما تحتاج إلى التلاعب بالسلسلة المدخلة أو عندما تحتاج إلى إعادة استخدام النمط. يجب ملاحظة أن النمط المحدد بواسطة التعبير العادي يُطبق على السلسلة من اليسار إلى اليمين وبمجرد استخدام حرف المصدر في المطابقة، لا يمكن إعادة استخدامه. على سبيل المثال، سيتطابق التعبير العادي “121” مع “31212142121” فقط مرتين كـ “_121____121”.

التعبير العادي في جافا – الرموز الشائعة للمطابقة

Regular Expression Description Example
. Matches any single character (“…”, “a%”) – true(“…”, “.a”) – true (“…”, “a”) – false
^aaa Matches aaa regex at the beginning of the line (“^a.c.”, “abcd”) – true (“^a”, “ac”) – false
aaa$ Matches regex aaa at the end of the line (“…cd$”, “abcd”) – true(“a$”, “a”) – true (“a$”, “aca”) – false
[abc] Can match any of the letter a, b or c. [] are known as character classes. (“^[abc]d.”, “ad9”) – true(“[ab].d$”, “bad”) – true (“[ab]x”, “cx”) – false
[abc][12] Can match a, b or c followed by 1 or 2 (“[ab][12].”, “a2#”) – true(“[ab]…[12]”, “acd2”) – true (“[ab][12]”, “c2”) – false
[^abc] When ^ is the first character in [], it negates the pattern, matches anything except a, b or c (“[^ab][^12].”, “c3#”) – true(“[^ab]…[^12]”, “xcd3”) – true (“[^ab][^12]”, “c2”) – false
[a-e1-8] Matches ranges between a to e or 1 to 8 (“[a-e1-3].”, “d#”) – true(“[a-e1-3]”, “2”) – true (“[a-e1-3]”, “f2”) – false
xx yy Matches regex xx or yy

حروف تعبير الجافا العادية

لدينا بعض الحروف الفارزة في تعبيرات جافا، وهي عبارة عن رموز اختصارية لأنماط المطابقة الشائعة.

Regular Expression Description
\d Any digits, short of [0-9]
\D Any non-digit, short for [^0-9]
\s Any whitespace character, short for [\t\n\x0B\f\r]
\S Any non-whitespace character, short for [^\s]
\w Any word character, short for [a-zA-Z_0-9]
\W Any non-word character, short for [^\w]
\b A word boundary
\B A non word boundary

هناك طريقتان لاستخدام الحروف الفارزة كحروف عادية في التعبيرات العادية.

  1. قم بتسبيق الحرف الفارز بشرطة عكسية (\).
  2. احتفظ بالحرف الفارز داخل \Q (الذي يبدأ الاقتباس) و \E (الذي ينهيه).

تعبير منتظم في جافا – العوامل الكمية

تحدد العوامل الكمية في جافا العدد المتكرر لحرف يتم مطابقته.

Regular Expression Description
x? x occurs once or not at all
X* X occurs zero or more times
X+ X occurs one or more times
X{n} X occurs exactly n times
X{n,} X occurs n or more times
X{n,m} X occurs at least n times but not more than m times

يمكن استخدام العوامل الكمية في جافا مع فئات الأحرف ومجموعات الاسترجاع أيضًا. على سبيل المثال ، [abc]+ تعني – a أو b أو c – مرة واحدة أو أكثر. (abc)+ يعني المجموعة “abc” مرة واحدة أو أكثر. سنناقش الآن عن مجموعة الاسترجاع.

تعبير منتظم في جافا – مجموعات الاسترجاع

تستخدم مجموعات الاسترجاع في تعبير منتظم في جافا للتعامل مع أحرف متعددة كوحدة واحدة. يمكنك إنشاء مجموعة باستخدام (). يتم حفظ جزء من سلسلة الإدخال الذي يتطابق مع مجموعة الاسترجاع في الذاكرة ويمكن استرجاعه باستخدام الرجوع للخلف. يمكنك استخدام طريقة matcher.groupCount لمعرفة عدد مجموعات الاسترجاع في نمط تعبير منتظم في جافا. على سبيل المثال ، ((a)(bc)) يحتوي على 3 مجموعات استرجاع – ((a)(bc)) ، (a) و (bc). يمكنك استخدام الرجوع للخلف في التعبير المنتظم باستخدام شرطة مائلة (\) ومن ثم رقم المجموعة التي يجب استرجاعها. قد تكون مجموعات الاسترجاع والرجوع للخلف مربكة ، لذا دعنا نفهم ذلك من خلال مثال.

System.out.println(Pattern.matches("(\\w\\d)\\1", "a2a2")); //true
System.out.println(Pattern.matches("(\\w\\d)\\1", "a2b2")); //false
System.out.println(Pattern.matches("(AB)(B\\d)\\2\\1", "ABB2B2AB")); //true
System.out.println(Pattern.matches("(AB)(B\\d)\\2\\1", "ABB2B3AB")); //false

في المثال الأول، في وقت التشغيل أول مجموعة تم القبض عليها هي (\w\d) والتي تقيم إلى “a2” عندما يتم مطابقتها مع سلسلة الإدخال “a2a2” ويتم حفظها في الذاكرة. لذا \1 يشير إلى “a2” وبالتالي يعيد القيمة true. بسبب نفس السبب، يتم طباعة البيان الثاني بالقيمة false. حاول فهم هذا السيناريو بنفسك بالنسبة للبيانات 3 و 4. 🙂 الآن سننظر في بعض الوظائف الهامة لفئتي Pattern و Matcher.

  1. يمكننا إنشاء كائن Pattern مع الأعلام. على سبيل المثال Pattern.CASE_INSENSITIVE يمكنه مطابقة غير حساسة لحالة الأحرف.
  2. توفر فئة Pattern أيضًا طريقة split(String) التي تشبه طريقة تقسيم السلسلة في فئة String.
  3. تعيد طريقة toString() في فئة Pattern سلسلة التعبير العادية التي تمت ترجمتها منها هذا النمط.
  4. تحتوي فئات Matcher على طرق فهرس start() و end() التي تظهر بالضبط مكان العثور على التطابق في سلسلة الإدخال.
  5. توفر فئة Matcher أيضًا طرق تلاعب السلسلة replaceAll(String replacement) و replaceFirst(String replacement).

دعنا ننظر في هذه الوظائف regex في مثال برنامج بسيط.

package com.journaldev.util;

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

public class RegexExamples {

	public static void main(String[] args) {
		 // باستخدام النمط مع الأعلام 
		Pattern pattern = Pattern.compile("ab", Pattern.CASE_INSENSITIVE);
		Matcher matcher = pattern.matcher("ABcabdAb");
		 // باستخدام طرق Matcher find() و group() و start() و end() 
		while (matcher.find()) {
			System.out.println("Found the text \"" + matcher.group()
					+ "\" starting at " + matcher.start()
					+ " index and ending at index " + matcher.end());
		}

		 // باستخدام طريقة Pattern split() 
		pattern = Pattern.compile("\\W");
		String[] words = pattern.split("one@two#three:four$five");
		for (String s : words) {
			System.out.println("Split using Pattern.split(): " + s);
		}

		 // باستخدام طرق Matcher.replaceFirst() و replaceAll() 
		pattern = Pattern.compile("1*2");
		matcher = pattern.matcher("11234512678");
		System.out.println("Using replaceAll: " + matcher.replaceAll("_"));
		System.out.println("Using replaceFirst: " + matcher.replaceFirst("_"));
	}

}

إجراء البرنامج المثال أعلاه يعطي الناتج.

Found the text "AB" starting at 0 index and ending at index 2
Found the text "ab" starting at 3 index and ending at index 5
Found the text "Ab" starting at 6 index and ending at index 8
Split using Pattern.split(): one
Split using Pattern.split(): two
Split using Pattern.split(): three
Split using Pattern.split(): four
Split using Pattern.split(): five
Using replaceAll: _345_678
Using replaceFirst: _34512678

هذا كل ما لدينا عن التعبيرات العادية في جافا. يبدو تعبيرات الجافا صعبة في البداية، ولكن إذا عملت معها لبعض الوقت، فإنه من السهل تعلمها واستخدامها.

يمكنك التحقق من الشفرة الكاملة ومزيد من أمثلة التعبيرات العادية من مستودعنا في GitHub.

Source:
https://www.digitalocean.com/community/tutorials/regular-expression-in-java-regex-example