Java Regex - Regular Expressions คืออะไรและจะใช้อย่างไร



Java Regex เป็น API ที่ใช้เพื่อกำหนดรูปแบบสำหรับการค้นหาหรือจัดการสตริง บทความนี้จะพูดถึงคลาสต่างๆของ Regular Expressions ที่จัดเตรียมโดย Java

การแยกข้อมูลหรือการตรวจสอบความถูกต้องเป็นสิ่งสำคัญของภาษาโปรแกรมทุกภาษา วิธีหนึ่งที่ได้รับความนิยมมากที่สุดสำหรับการตรวจสอบข้อมูลคือการใช้นิพจน์ทั่วไป ใช้สิ่งเหล่านี้นิพจน์ทั่วไปเพื่ออธิบายรูปแบบของอักขระ บทความนี้เกี่ยวกับ Java Regex จะแสดงรายการวิธีการใช้นิพจน์ต่างๆตามลำดับต่อไปนี้:

มาเริ่มกันเลย!





นิพจน์ทั่วไปคืออะไร?

ถึง นิพจน์ทั่วไป คือลำดับของอักขระที่สร้างรูปแบบการค้นหา เมื่อคุณค้นหาข้อมูลในข้อความคุณสามารถใช้รูปแบบการค้นหานี้เพื่ออธิบายสิ่งที่คุณกำลังมองหา

นิพจน์ทั่วไป - Java Regex - Edureka



นิพจน์ทั่วไปสามารถเป็นไฟล์ อักขระเดี่ยวหรือรูปแบบที่ซับซ้อนมากขึ้น สามารถใช้สำหรับการค้นหาข้อความและการแทนที่ข้อความประเภทใดก็ได้ รูปแบบ Regex ประกอบด้วยอักขระง่ายๆเช่น / abc / หรือการรวมกันของอักขระธรรมดาและอักขระพิเศษเช่น / ab * c / หรือ /example(d+).d*/ .

Java Regex คืออะไร

Java Regex เป็น API ที่ใช้ในการ กำหนดรูปแบบสำหรับการค้นหาหรือจัดการ . มีการใช้กันอย่างแพร่หลายเพื่อกำหนดข้อ จำกัด ของ Strings เช่นรหัสผ่านและการตรวจสอบอีเมล

มีวิธีการต่างๆในการใช้ Java Regex มาดูสำนวนต่างๆกันดีกว่า



คลาส Matcher

คลาสนี้ใช้เพื่อดำเนินการจับคู่กับลำดับอักขระ ตารางด้านล่างแสดงถึงวิธีการต่างๆของคลาส Matcher

วิธี คำอธิบาย
การจับคู่บูลีน () ทดสอบว่านิพจน์ทั่วไปที่ระบุตรงกับรูปแบบหรือไม่
หาบูลีน () ใช้เพื่อค้นหานิพจน์ถัดไปที่ตรงกับรูปแบบ
หาบูลีน (เริ่มต้น int) ค้นหานิพจน์ถัดไปที่ตรงกับรูปแบบจากหมายเลขเริ่มต้นที่กำหนด
กลุ่มสตริง () ใช้เพื่อส่งคืนการจับคู่ในภายหลัง
int เริ่มต้น () ส่งคืนดัชนีเริ่มต้นของลำดับต่อมาที่ตรงกัน
สิ้นสุด int () ส่งคืนดัชนีสิ้นสุดของลำดับต่อมาที่ตรงกัน
int groupCount () ส่งคืนจำนวนรวมของลำดับต่อมาที่ตรงกัน

คลาสรูปแบบ

Pattern Class เป็นเวอร์ชันคอมไพล์ของนิพจน์ทั่วไปซึ่งใช้เพื่อกำหนดรูปแบบสำหรับเอนจิน regex

วิธี คำอธิบาย
คอมไพล์รูปแบบคงที่ (String regex) รวบรวม regex ที่กำหนดและส่งคืนอินสแตนซ์ของ Pattern
จับคู่การแข่งขัน (อินพุต CharSequence) ใช้เพื่อสร้างตัวจับคู่ที่ตรงกับอินพุตที่กำหนดกับรูปแบบ
การจับคู่บูลีนแบบคงที่ (String regex, CharSequence input) มันทำงานร่วมกันระหว่างวิธีการคอมไพล์และการจับคู่ รวบรวมนิพจน์ทั่วไปและจับคู่อินพุตที่กำหนดกับรูปแบบ
สตริง [] แยก (อินพุต CharSequence) ใช้เพื่อแยกสตริงอินพุตที่กำหนดรอบการจับคู่ของรูปแบบที่กำหนด
รูปแบบสตริง () ช่วยคืนรูปแบบนิพจน์ทั่วไป

ตอนนี้เรามาดูตัวอย่างเล็กน้อยเพื่อทำความเข้าใจวิธีการเขียนนิพจน์ทั่วไป

นำเข้า java.util.regex. * คลาสสาธารณะ RegexExample {public static void main (String [] args) {Pattern pattern = Pattern.compile ('. xx.') Matcher matcher = pattern.matcher ('AxxB') System.out .println ('String ตรงกับ Regex - + matcher.matches ())}} ที่กำหนด

ในกรณีนี้ภายในจะใช้ Pattern และ Matcher คลาส regex เพื่อทำการประมวลผล แต่เห็นได้ชัดว่าจะลดบรรทัดรหัส คลาส Pattern ยังมีวิธีการจับคู่ที่ใช้ regex และ input String เป็นอาร์กิวเมนต์และส่งคืนผลลัพธ์บูลีนหลังจากจับคู่ ดังนั้นรหัสจึงทำงานได้ดีสำหรับอินพุตที่ตรงกัน ด้วยนิพจน์ทั่วไปใน Java ดังนั้นผลลัพธ์จะเป็นจริงดังที่แสดงด้านล่าง

ความยาวของอาร์เรย์ในจาวาสคริปต์

เอาท์พุต:
จริง

ตอนนี้เรามาดูหมวดหมู่อื่น ๆ ของ Java Regular Expressions กัน

คลาสตัวละคร Regex

ตารางด้านล่างแสดงถึงการรวมคลาสอักขระที่แตกต่างกัน

คลาสตัวละครคำอธิบาย
[abc] a, b หรือ c (คลาสง่าย ๆ )
[^ abc] อักขระใด ๆ ยกเว้น a, b หรือ c (การปฏิเสธ)
[a-zA-Z] a ถึง z หรือ A ถึง Z รวม (ช่วง)
[a-d [m-p]] a ถึง d หรือ m ถึง p: [a-dm-p] (สหภาพ)
[a-z && [def]] d, e หรือ f (จุดตัด)
[a-z && [^ bc]] a ถึง z ยกเว้น b และ c: [ad-z] (การลบ)
[a-z && [^ m-p]] a ถึง z ไม่ใช่ m ถึง p: [a-lq-z] (การลบ)

ตัวอย่าง:

นำเข้า java.util.regex. * คลาสสาธารณะ CharacterExample {public static void main (String args []) {// false (ไม่ใช่ x หรือ y หรือ z) System.out.println (Pattern.matches ('[xyz]', 'wbcd')) // true (ระหว่าง x หรือ y หรือ z) System.out.println (Pattern.matches ('[xyz]', 'x')) // false (x และ y มามากกว่าหนึ่งครั้ง) .out.println (Pattern.matches ('[xyz]', 'xxyyyyyz'))}}

Regex Quantifiers

ตัวระบุจำนวนระบุจำนวนครั้งที่เกิดขึ้นของอักขระ ตารางด้านล่างแสดงปริมาณต่างๆ

Regexคำอธิบาย
เอ็กซ์? X เกิดขึ้นครั้งเดียวหรือไม่เกิดขึ้นเลย
X + X เกิดขึ้นหนึ่งครั้งหรือมากกว่านั้น
X * X เกิดขึ้นเป็นศูนย์หรือมากกว่าครั้ง
X {n} X เกิดขึ้น n ครั้งเท่านั้น
X {n,} X เกิดขึ้น n ครั้งหรือมากกว่า
X และ Z} X เกิดขึ้นอย่างน้อย y ครั้ง แต่น้อยกว่า z ครั้ง

ตัวอย่าง:

import java.util.regex. * คลาสสาธารณะตัวอย่าง {public static void main (String args []) {System.out.println ('? quantifier .... ') // (a หรือ y หรือ z มาครั้งเดียว) System.out.println (Pattern.matches ('[ayz]?', 'a')) // เอาท์พุท: true System.out.println (Pattern.matches ('[ayz]?', 'aaa')) / / (ay และ z มามากกว่าหนึ่งครั้ง) System.out.println (Pattern.matches ('[ayz]?', 'ayyyyzz')) // output: false // (a มามากกว่าหนึ่งครั้ง) ระบบ out.println (Pattern.matches ('[ayz]?', 'amnta')) // output: false // (a หรือ y หรือ z ต้องมาครั้งเดียว) System.out.println (Pattern.matches ('[ ayz]? ',' ay ')) // output: false System.out.println (' + quantifier .... ') // (a หรือ y หรือ z หนึ่งครั้งขึ้นไป) System.out.println (รูปแบบ .matches ('[ayz] +', 'a')) // output: true // (a มามากกว่าหนึ่งครั้ง) System.out.println (Pattern.matches ('[ayz] +', 'aaa' )) // outpu: true // (a หรือ y หรือ z มามากกว่าหนึ่งครั้ง) System.out.println (Pattern.matches ([amn] + ',' aayyyzz ')) // output: true // (z และ t ไม่ใช่รูปแบบที่ตรงกัน) System.out.println (Pat tern.matches ('[ayz] +', 'aammta')) // output: false System.out.println ('* quantifier .... ') // (a หรือ y หรือ z อาจมาเป็นศูนย์หรือมากกว่าครั้ง ) System.out.println (Pattern.matches ('[ayz] *', 'ayyyza')) // เอาต์พุต: true}}

โดยทั่วไปจะค้นหาปริมาณที่ตรงกันและตรงกับผลการค้นหา

Metacharacters ของ Regex

อักขระเมตาของนิพจน์ทั่วไปทำงานเป็นรหัสย่อ มาดูตารางด้านล่างเพื่อทำความเข้าใจอักขระเมตาประเภทต่างๆ

Regexคำอธิบาย
. สามารถเป็นอักขระใดก็ได้ (อาจจะตรงหรือไม่ตรงกับเทอร์มิเนเตอร์)
หมายถึงตัวเลขใด ๆ โดยย่อ [0-9]
แสดงถึงตัวเลขที่ไม่ใช่ตัวเลขย่อมาจาก [^ 0-9]
เอส แสดงอักขระเว้นวรรคใด ๆ ย่อมาจาก [tnx0Bfr]
สามารถเป็นอักขระที่ไม่ใช่ช่องว่างย่อมาจาก [^ s]
ใน สามารถเป็นอักขระคำย่อมาจาก [a-zA-Z_0-9]
ใน แสดงถึงอักขระที่ไม่ใช่คำใด ๆ ย่อมาจาก [^ w]
แสดงขอบเขตของคำ
มันเป็นขอบเขตที่ไม่ใช่คำ

ตัวอย่าง:

นำเข้า java.util.regex. * คลาสสาธารณะ MetacharExample {public static void main (String args []) {// d หมายถึงหลัก System.out.println ('metacharacters d .... ') // (non-digit) System.out.println (Pattern.matches ('d', 'abc')) // Output: false // (หลักและมาครั้งเดียว) System.out.println (Pattern.matches ('d', '1') ) // Output: true // (หลัก แต่มามากกว่าหนึ่งครั้ง) System.out.println (Pattern.matches ('d', '4443')) // Output: false // (หลักและถ่าน) System.out .println (Pattern.matches ('d', '323abc')) // Output: false // D หมายถึง System.out.println ที่ไม่ใช่ตัวเลข ('metacharacters D .... ') // (ไม่ใช่ตัวเลข แต่ มามากกว่าหนึ่งครั้ง) System.out.println (Pattern.matches ('D', 'abc')) // Output: false // มันเป็น Digit System.out.println (Pattern.matches ('D', '1 ')) // ผลลัพธ์: false System.out.println (Pattern.matches (' D ',' 4443 ')) // ผลลัพธ์: false // (หลักและอักขระ) System.out.println (Pattern.matches (' D ',' 323abc ')) // เอาต์พุต: false // (ไม่ใช่ตัวเลขและมาครั้งเดียว) System.out.println (Pattern.matches (' D ',' m ')) // Output: true System.out .pr intln ('metacharacters D with quantifier .... ') // (ไม่ใช่ตัวเลขและอาจมา 0 ครั้งขึ้นไป) System.out.println (Pattern.matches ('D *', 'abc')) // เอาท์พุท : true}}

ตามเงื่อนไขที่กล่าวมาข้างต้นจะแสดงผลลัพธ์ นั่นคือวิธีการทำงาน นั่นคือทั้งหมดที่เกี่ยวกับประเภทต่างๆ Regex ด้วยเหตุนี้เราจึงมาถึงจุดสิ้นสุดของบทความนี้ ผมหวังว่าคุณจะพบข้อมูล หากคุณต้องการเรียนรู้เพิ่มเติมคุณสามารถดูได้ที่ เช่นกัน.

ตรวจสอบไฟล์ โดย Edureka บริษัท การเรียนรู้ออนไลน์ที่เชื่อถือได้ซึ่งมีเครือข่ายผู้เรียนที่พึงพอใจมากกว่า 250,000 คนกระจายอยู่ทั่วโลก เราพร้อมที่จะช่วยเหลือคุณในทุกขั้นตอนในการเดินทางของคุณสำหรับการเป็นนอกเหนือจากคำถามสัมภาษณ์ java นี้เรามาพร้อมกับหลักสูตรที่ออกแบบมาสำหรับนักเรียนและมืออาชีพที่ต้องการเป็น Java Developer

ข้อดีและข้อเสียของ python

มีคำถามสำหรับเรา? โปรดระบุไว้ในส่วนความคิดเห็นของบทความ 'Java Regex' และเราจะติดต่อกลับโดยเร็วที่สุด