Rate this post

Chào mừng bạn đến với Regular Expression trong Java. Nó còn được gọi là Regex trong Java. Khi tôi bắt đầu lập trình, java Regular Expression là một cơn ác mộng đối với tôi. Hướng dẫn này nhằm mục đích giúp bạn thành thạo Regular Expression trong Java. Tôi cũng các ban để làm mới việc học Java Regex của mình.

Các bài viết liên quan:

Regular Expression trong Java

Regular Expression trong java xác định một Pattern cho Chuỗi. Regular Expression có thể được sử dụng để tìm kiếm, chỉnh sửa hoặc thao tác văn bản. Một Regular Expression không phải là ngôn ngữ cụ thể nhưng chúng hơi khác nhau đối với từng ngôn ngữ. Regular Expression trong Java gần giống nhất với Perl. Các lớp Java Regex có trong gói java.util.regex chứa ba lớp:

  • Pattern: Đối tượng Pattern là phiên bản được biên dịch của Regular Expression. Lớp Pattern không có bất kỳ hàm tạo công khai nào và chúng tôi sử dụng trình biên dịch phương thức tĩnh công khai của nó để tạo đối tượng Pattern bằng cách truyền đối số Regular Expression.
  • Matcher: Matcher là đối tượng công cụ regex java khớp Pattern Chuỗi đầu vào với đối tượng Pattern được tạo. Lớp Matcher không có bất kỳ hàm tạo công khai nào và chúng tôi nhận được một đối tượng Matcher bằng cách sử dụng phương thức đối sánh đối tượng Pattern lấy Chuỗi đầu vào làm đối số. Sau đó, chúng tôi sử dụng phương thức đối sánh trả về kết quả boolean dựa trên Chuỗi đầu vào có khớp với Pattern Regular Expression hay không.
  • PatternSyntaxException: PatternSyntaxException bị ném nếu cú pháp Regular Expression không đúng.

Chúng ta hãy xem chương trình ví dụ Java Regex.

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*");

	}

}

Khi chúng tôi chạy chương trình ví dụ về regex java này, chúng tôi nhận được kết quả bên dưới.

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)

Vì Regular Expression java xoay quanh Chuỗi, nên lớp Chuỗi đã được mở rộng trong Java 1.4 để cung cấp một phương thức phù hợp thực hiện khớp Pattern Regular Expression. Bên trong, nó sử dụng các lớp regex java Pattern và Matcher để thực hiện xử lý nhưng rõ ràng là nó làm giảm các dòng mã. Lớp Pattern cũng chứa phương thức khớp lấy Regular Expression và Chuỗi đầu vào làm đối số và trả về kết quả boolean sau khi khớp chúng. Vì vậy, mã bên dưới hoạt động tốt để khớp Chuỗi đầu vào với một Regular Expression trong Java.

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

Vì vậy, nếu yêu cầu của bạn chỉ là kiểm tra xem Chuỗi đầu vào có khớp với Pattern hay không, bạn nên tiết kiệm thời gian và các dòng mã bằng cách sử dụng phương thức khớp Chuỗi đơn giản. Bạn chỉ nên sử dụng các lớp Pattern và Khớp khi bạn cần thao tác với Chuỗi đầu vào hoặc bạn cần sử dụng lại Pattern. Lưu ý rằng Pattern được xác định bởi Regular Expression được áp dụng trên Chuỗi từ trái sang phải và sau khi một ký tự nguồn được sử dụng trong một kết quả khớp, ký tự đó không thể được sử dụng lại. Ví dụ: regex “121” sẽ chỉ khớp với “31212142121” hai lần là “_121____121”.

Các ký hiệu khớp phổ biến

  • . Khớp với bất kỳ ký tự đơn nào
  • ^aaa Khớp aaa regex ở đầu dòng
  • aaa$ Khớp regex aaa ở cuối dòng
  • [abc] Có thể khớp với bất kỳ ký tự a, b hoặc c nào. [] được gọi là các lớp ký tự.
  • [abc][12] Có thể khớp với a, b hoặc c theo sau là 1 hoặc 2
  • [^abc] Khi ^ là ký tự đầu tiên trong [], nó phủ định Pattern, khớp với mọi thứ trừ a, b hoặc c
  • [a-e1-8] So khớp phạm vi từ a đến e hoặc từ 1 đến 8
  • xx Khớp regex xx hoặc yy

Siêu ký tự Java Regex

Chúng tôi có một số ký tự meta trong Regular Expression Java, nó giống như mã ngắn cho các Pattern đối sánh phổ biến.

Mô tả Regular Expression

  • \d Bất kỳ chữ số nào, thiếu [0-9]
  • \D Bất kỳ chữ số nào, viết tắt của [^0-9]
  • \s Bất kỳ ký tự khoảng trắng nào, viết tắt của [\t\n\x0B\f\r]
  • \S Bất kỳ ký tự nào không phải khoảng trắng, viết tắt của [^\s]
  • \w Bất kỳ ký tự từ nào, viết tắt của [a-zA-Z_0-9]
  • \W Bất kỳ ký tự không phải từ nào, viết tắt của [^\w]
  • \b word boundary
  • \B Một non word boundary

Có hai cách để sử dụng siêu ký tự làm ký tự thông thường trong Regular Expression.

  • Trước siêu ký tự có dấu gạch chéo ngược (\).
  • Giữ metacharcter trong \Q (bắt đầu trích dẫn) và \E (kết thúc trích dẫn).

Java Regex Quantifiers

Java Regex Quantifiers chỉ định số lần xuất hiện của một ký tự để so khớp.

  • x? x xảy ra một lần hoặc không xảy ra
  • X* X xảy ra không hoặc nhiều lần
  • X+ X xảy ra một hoặc nhiều lần
  • X{n} X xảy ra đúng n lần
  • X{n,} X xảy ra n lần trở lên
  • X{n,m} X xảy ra ít nhất n lần nhưng không quá m lần

Bộ định lượng Java Regex cũng có thể được sử dụng với các lớp ký tự và các nhóm chụp. Ví dụ: [abc]+ có nghĩa là – a, b hoặc c – một hoặc nhiều lần. (abc)+ có nghĩa là nhóm “abc” thêm một lần nữa. Bây giờ chúng ta sẽ thảo luận về Capture Group.

Capturing Groups

Regular Expression trong các nhóm Capturing Groups được sử dụng để xử lý nhiều ký tự dưới dạng một đơn vị. Bạn có thể tạo một nhóm bằng cách sử dụng (). Phần Chuỗi đầu vào khớp với Capturing Groups được lưu vào bộ nhớ và có thể được gọi lại bằng Backreference. Bạn có thể sử dụng phương thức matcher.groupCount để tìm ra số lượng nhóm chụp trong Pattern Regular Expression java.

Ví dụ: ((a)(bc)) chứa 3 nhóm – ((a)(bc)), (a) và (bc) . Bạn có thể sử dụng Backreference trong Regular Expression với dấu gạch chéo ngược (\) và sau đó là số của nhóm được gọi lại. Việc Capturing Groups và Tham chiếu ngược có thể gây nhầm lẫn, vì vậy hãy hiểu điều này bằng một ví dụ.

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

Trong ví dụ đầu tiên, trong thời gian chạy, nhóm đầu tiên là (\w\d) đánh giá thành “a2” khi khớp với Chuỗi đầu vào “a2a2” và được lưu trong bộ nhớ. Vì vậy, \1 đang đề cập đến “a2” và do đó nó trả về giá trị true. Vì lý do tương tự, câu lệnh thứ hai in sai. Hãy cố gắng tự hiểu kịch bản này cho câu 3 và 4. 🙂 Bây giờ chúng ta sẽ xem xét một số phương thức quan trọng của các lớp Pattern và Matcher.

  • Chúng ta có thể tạo một đối tượng Pattern với các flag. Ví dụ: Pattern.CASE_INSENSITIVE cho phép khớp không phân biệt chữ hoa chữ thường.
  • Lớp Pattern cũng cung cấp phương thức split(String) tương tự như phương thức split() của lớp String.
  • Phương thức toString() của lớp Pattern trả về Chuỗi Regular Expression mà từ đó Pattern này được biên dịch.
  • Các lớp đối sánh có các phương thức chỉ mục start() và end() hiển thị chính xác vị trí tìm thấy đối sánh trong chuỗi đầu vào.
  • Lớp Matcher cũng cung cấp các phương thức thao tác Chuỗi replaceAll(Chuỗi thay thế) và replaceFirst(Chuỗi thay thế).

Hãy xem xét các phương thức regex java này trong một chương trình ví dụ đơn giản.

package com.web.util;

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

public class RegexExamples {

	public static void main(String[] args) {
		// using pattern with flags
		Pattern pattern = Pattern.compile("ab", Pattern.CASE_INSENSITIVE);
		Matcher matcher = pattern.matcher("ABcabdAb");
		// using Matcher find(), group(), start() and end() methods
		while (matcher.find()) {
			System.out.println("Found the text \"" + matcher.group()
					+ "\" starting at " + matcher.start()
					+ " index and ending at index " + matcher.end());
		}

		// using Pattern split() method
		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);
		}

		// using Matcher.replaceFirst() and replaceAll() methods
		pattern = Pattern.compile("1*2");
		matcher = pattern.matcher("11234512678");
		System.out.println("Using replaceAll: " + matcher.replaceAll("_"));
		System.out.println("Using replaceFirst: " + matcher.replaceFirst("_"));
	}


}

Đầu ra của chương trình ví dụ về regex java ở trên là.

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

Đó là tất cả cho Regular Expression trong Java. Java Regex thoạt nghe có vẻ khó, nhưng nếu bạn làm việc với chúng một thời gian, nó rất dễ học và sử dụng.

Trả lời

Email của bạn sẽ không được hiển thị công khai. Các trường bắt buộc được đánh dấu *

Contact Me on Zalo
Call now