นิพจน์ทั่วไปใน Java ตอนที่ 2

เราขอนำเสนอคำแปลคำแนะนำสั้นๆ เกี่ยวกับนิพจน์ทั่วไปในภาษา Java ซึ่งเขียนโดย Jeff Friesen สำหรับเว็บไซต์javaworld เพื่อความสะดวกในการอ่าน เราได้แบ่งบทความออกเป็นหลายส่วน นิพจน์ทั่วไปใน Java ตอนที่ 1

การรวมหลายช่วง

คุณสามารถรวมหลายช่วงเป็นคลาสอักขระช่วงเดียวได้โดยการวางไว้เคียงข้างกัน ตัวอย่างเช่น คลาส[a-zA-Z]จะจับคู่อักขระตัวอักษรละตินทั้งหมดโดยใช้ตัวพิมพ์เล็กหรือตัวพิมพ์ใหญ่

การรวมคลาสตัวละคร

การรวมคลาสอักขระประกอบด้วยคลาสอักขระที่ซ้อนกันหลายคลาส และจับคู่อักขระทั้งหมดในการรวมคลาสผลลัพธ์ ตัวอย่างเช่น คลาส[a-d[m-p]]จะจับคู่อักขระจากaถึงdและจากmถึง pพิจารณาตัวอย่างต่อไปนี้: ตัวอย่าง นี้java RegexDemo [ab[c-e]] abcdef จะค้นหาอักขระa, b, cและซึ่งมีข้อมูลที่ตรงกันใน: deabcdef

regex = [ab[c-e]]
input = abcdef
Found [a] starting at 0 and ending at 0
Found [b] starting at 1 and ending at 1
Found [c] starting at 2 and ending at 2
Found [d] starting at 3 and ending at 3
Found [e] starting at 4 and ending at 4

สี่แยกคลาสตัวละคร

จุดตัดกันของคลาสอักขระประกอบด้วยอักขระทั่วไปสำหรับคลาสที่ซ้อนกันทั้งหมด และจับคู่เฉพาะอักขระทั่วไปเท่านั้น ตัวอย่างเช่น คลาสจะ จับ คู่[a-z&&[d-f]]อักขระdและ พิจารณาตัวอย่างต่อไปนี้: โปรดทราบว่าบนระบบปฏิบัติการ Windows ของฉัน ต้องใช้เครื่องหมายคำพูดคู่เนื่องจากเชลล์คำสั่งถือว่าเครื่องหมายคำพูดเหล่านั้นเป็นตัวคั่นคำสั่ง ตัวอย่างนี้จะค้นหาเฉพาะอักขระที่ตรงกันใน: efjava RegexDemo "[aeiouy&&[y]]" party&yparty

regex = [aeiouy&&[y]]
input = party
Found [y] starting at 4 and ending at 4

การลบคลาสอักขระ

การลบคลาสอักขระประกอบด้วยอักขระทั้งหมด ยกเว้นอักขระที่มีอยู่ในคลาสอักขระที่ซ้อนกัน และจับคู่เฉพาะอักขระที่เหลือเท่านั้น ตัวอย่างเช่น คลาส[a-z&&[^m-p]]จะจับคู่อักขระจากaถึงlและ จากqถึงz: java RegexDemo "[a-f&&[^a-c]&&[^e]]" abcdefg ตัวอย่างนี้จะค้นหาอักขระdและfมีรายการที่ตรงกันในabcdefg:

regex = [a-f&&[^a-c]&&[^e]]
input = abcdefg
Found [d] starting at 3 and ending at 3
Found [f] starting at 5 and ending at 5

คลาสตัวละครที่กำหนดไว้ล่วงหน้า

คลาสอักขระบางตัวปรากฏบ่อยครั้งเพียงพอในนิพจน์ทั่วไปเพื่อยืนยันการใช้สัญลักษณ์ชวเลข คลาสPatternนำเสนอคลาสอักขระที่กำหนดไว้ล่วงหน้าเป็นตัวย่อดังกล่าว คุณสามารถใช้เพื่อทำให้นิพจน์ทั่วไปของคุณง่ายขึ้นและลดข้อผิดพลาดทางไวยากรณ์ให้เหลือน้อยที่สุด คลาสอักขระที่กำหนดไว้ล่วงหน้ามีหลายประเภท ได้แก่java.lang.Characterคุณสมบัติมาตรฐาน POSIX และ Unicode เช่น สคริปต์ บล็อก หมวดหมู่ และไบนารี รายการต่อไปนี้แสดงเฉพาะหมวดหมู่ของคลาสมาตรฐาน:

• \d: ตัวเลข. เทียบเท่า[0-9].
• \D: อักขระที่ไม่ใช่ตัวเลข เทียบเท่า[^0-9].
• \s: อักขระช่องว่าง เทียบเท่า[ \t\n\x0B\f\r].
• \S: ไม่ใช่อักขระช่องว่าง เทียบเท่า[^\s].
• \w: สัญลักษณ์สร้างคำ เทียบเท่า[a-zA-Z_0-9].
• \W: ไม่ใช่ตัวละครที่สร้างคำ เทียบเท่า[^\w].

ตัวอย่างต่อไปนี้ใช้คลาสอักขระที่กำหนดไว้ล่วงหน้า\wเพื่ออธิบายอักขระคำทั้งหมดในข้อความอินพุต: java RegexDemo \w "aZ.8 _" ดูผลการดำเนินการต่อไปนี้อย่างใกล้ชิด ซึ่งแสดงว่าอักขระจุดและช่องว่างไม่ถือเป็นอักขระคำ:

regex = \w
input = aZ.8 _
Found [a] starting at 0 and ending at 0
Found [Z] starting at 1 and ending at 1
Found [8] starting at 3 and ending at 3
Found [_] starting at 5 and ending at 5

กลุ่มที่ถูกจับ

กลุ่มการจับภาพใช้เพื่อบันทึกชุดอักขระที่พบเพื่อใช้เพิ่มเติมเมื่อค้นหาตามรูปแบบ โครงสร้างนี้เป็นลำดับของอักขระที่อยู่ในวงเล็บเมตา ( ( )) อักขระทั้งหมดภายในกลุ่มที่ถูกจับจะถือเป็นอักขระตัวเดียวเมื่อค้นหาตามรูปแบบ ตัวอย่างเช่น กลุ่มการจับ ( Java) จะรวมตัวอักษรJ, a, vและaให้เป็นหน่วยเดียว กลุ่มแคปเจอร์นี้จะค้นหารูปแบบที่เกิดขึ้นทั้งหมดJavaในข้อความอินพุต ในการจับคู่แต่ละครั้ง อักขระที่เก็บไว้ก่อน หน้านี้ Javaจะถูกแทนที่ด้วยอักขระถัดไป กลุ่มที่ถูกจับสามารถซ้อนอยู่ภายในกลุ่มที่ถูกจับอื่นๆ ได้ ตัวอย่างเช่น ในนิพจน์ทั่วไปกลุ่ม(Java( language))จะ(language)ซ้อนอยู่ภายในกลุ่ม (Java)แต่ละกลุ่มการดักจับแบบซ้อนหรือไม่ซ้อนกันจะถูกกำหนดหมายเลข โดยเริ่มจาก 1 และลำดับเลขจะเรียงจากซ้ายไปขวา ในตัวอย่างก่อนหน้านี้(Java( language))จับคู่การจับหมายเลขกลุ่ม 1 และ(language)ตรงกับกลุ่มการจับหมายเลข 2 ในนิพจน์ทั่วไป จับ คู่ (a)(b)การ(a)จับคู่หมายเลขกลุ่มการจับ 1 และ(b)กลุ่มการจับหมายเลข 2 การจับคู่ที่จัดเก็บโดยกลุ่มการจับสามารถเข้าถึงได้ในภายหลังโดยใช้การอ้างอิงย้อนกลับ ระบุเป็นอักขระแบ็กสแลชตามด้วยอักขระตัวเลขที่สอดคล้องกับหมายเลขของกลุ่มที่ถูกจับ การอ้างอิงย้อนกลับทำให้คุณสามารถอ้างอิงถึงอักขระในข้อความที่กลุ่มจับได้ การมีลิงก์ย้อนกลับทำให้ตัวจับคู่อ้างอิงถึงผลการค้นหาที่จัดเก็บไว้ของกลุ่มที่บันทึกไว้ตามหมายเลขจากนั้นใช้อักขระจากผลลัพธ์นั้นเพื่อพยายามค้นหาเพิ่มเติม ตัวอย่างต่อไปนี้แสดงการใช้การอ้างอิงย้อนกลับเพื่อค้นหาข้อผิดพลาดทางไวยากรณ์ในข้อความ: java RegexDemo "(Java( language)\2)" "The Java language language" ตัวอย่างนี้(Java( language)\2)ใช้นิพจน์ทั่วไปเพื่อค้นหาข้อผิดพลาดทางไวยากรณ์ที่มีคำที่ซ้ำกันlanguageตามหลังJavaในข้อความที่ป้อน"The Java language language"ทันที นิพจน์ทั่วไปนี้ระบุสองกลุ่มที่จะจับ: หมายเลข 1 – (Java( language)\2)สอดคล้องกับJava language languageและหมายเลข 2 – (language)สอดคล้องกับอักขระช่องว่างตามlanguageด้วย การอ้างอิงย้อนกลับ\2ช่วยให้สามารถกลับมาเยี่ยมชมผลลัพธ์ที่เก็บไว้ของกลุ่มหมายเลข 2 ได้อีกครั้ง เพื่อให้ผู้จับคู่สามารถค้นหาการเกิดขึ้นครั้งที่สองของช่องว่าง ตามด้วยlanguageทันทีหลังจากการเกิดขึ้นครั้งแรกของช่องว่างlanguageและ ผลการแข่งขันRegexDemoมีดังนี้:

regex = (Java( language)\2)
input = The Java language language
Found [Java language language] starting at 4 and ending at 25

ตัวจับคู่ขอบเขต

บางครั้งคุณจำเป็นต้องดำเนินการจับคู่รูปแบบที่จุดเริ่มต้นของบรรทัด ที่ขอบเขตคำ ที่ท้ายข้อความ ฯลฯ คุณสามารถทำได้โดยใช้ class edge matcher ตัวใดตัวหนึ่งPatternซึ่งเป็นโครงสร้างนิพจน์ทั่วไปที่ค้นหารายการที่ตรงกันในตำแหน่งต่อไปนี้:

• ^: จุดเริ่มต้นของบรรทัด;
• $: สิ้นสุดบรรทัด;
• \b: ขอบเขตของคำ;
• \B: ขอบเขตคำนามแฝง;
• \A: เริ่มต้นข้อความ;
• \G: จบการแข่งขันนัดที่แล้ว;
• \Z: ท้ายข้อความ ไม่รวมตัวคั่นบรรทัดต่อท้าย (ถ้ามี)
• \z: สิ้นสุดข้อความ

ตัวอย่างต่อไปนี้ใช้^meta character ของตัวจับคู่ขอบเขตเพื่อค้นหาบรรทัดที่ขึ้นต้นด้วยTheตามด้วยอักขระคำเป็นศูนย์หรือมากกว่า: java RegexDemo "^The\w*" Therefore อักขระ^ระบุว่าอักขระสามตัวแรกของข้อความอินพุตต้องตรงกับอักขระรูปแบบที่ต่อเนื่องกันTและhซึ่งeสามารถตามหลังด้วยตัวเลขใดก็ได้ ของสัญลักษณ์ที่สร้างคำ นี่คือผลลัพธ์ของการดำเนินการ:

regex = ^The\w*
input = Therefore
Found [Therefore] starting at 0 and ending at 8

จะเกิดอะไรขึ้นหากคุณเปลี่ยนบรรทัดคำสั่งเป็นjava RegexDemo "^The\w*" " Therefore"? จะไม่พบรายการที่ตรงกันเนื่องจากThereforeข้อความที่ป้อนนำหน้าด้วยอักขระเว้นวรรค

การจับคู่ที่มีความยาวเป็นศูนย์

บางครั้ง เมื่อทำงานกับ Edge Matcher คุณจะพบกับการจับคู่ที่มีความยาวเป็นศูนย์ Совпадение нулевой длиныคือการจับคู่ที่ไม่มีอักขระใดๆ สิ่งเหล่านี้สามารถเกิดขึ้นได้ในข้อความอินพุตที่ว่างเปล่า ที่จุดเริ่มต้นของข้อความอินพุต หลังอักขระสุดท้ายของข้อความอินพุต และระหว่างอักขระสองตัวใดๆ ของข้อความอินพุต การแข่งขันที่มีความยาวเป็นศูนย์นั้นง่ายต่อการจดจำเนื่องจากการแข่งขันจะเริ่มต้นและสิ้นสุดที่ตำแหน่งเดียวกันเสมอ พิจารณาตัวอย่างต่อไปนี้: java RegExDemo \b\b "Java is" ตัวอย่างนี้ค้นหาขอบเขตคำสองขอบเขตที่ต่อเนื่องกัน และผลลัพธ์จะมีลักษณะดังนี้:

regex = \b\b
input = Java is
Found [] starting at 0 and ending at -1
Found [] starting at 4 and ending at 3
Found [] starting at 5 and ending at 4
Found [] starting at 7 and ending at 6

เราเห็นการแข่งขันที่มีความยาวเป็นศูนย์หลายครั้งในผลลัพธ์ ตำแหน่งสิ้นสุดที่นี่น้อยกว่าตำแหน่งเริ่มต้นหนึ่งตำแหน่ง เนื่องจากRegexDemoฉันได้ระบุไว้ในซอร์สโค้ดในรายการend() – 11

ปริมาณ

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

• ตัวระบุปริมาณโลภ ( ?, *หรือ+) ได้รับการออกแบบมาเพื่อค้นหาคู่ที่ยาวที่สุด ฉันถามได้ไหมX? เพื่อค้นหาหนึ่งหรือน้อยกว่าXเพื่อX*ค้นหาการเกิดเป็นศูนย์หรือมากกว่าXเพื่อX+ค้นหาหนึ่งหรือหลายเหตุการณ์Xเพื่อX{n}ค้นหาnการเกิดXเพื่อX{n,}ค้นหาอย่างน้อย (และอาจมากกว่า) เกิดnขึ้นXและX{n,m}เพื่อค้นหาอย่างน้อยnแต่ไม่มากกว่าmนั้นX
• Lazy quantifier ( ??, *?หรือ+?) ได้รับการออกแบบมาเพื่อค้นหาค่าที่ตรงกันที่สั้นที่สุด คุณสามารถระบุX??เพื่อค้นหาเหตุการณ์X, X*? เพื่อค้นหาการเกิดเหตุการณ์เป็นศูนย์หรือมากกว่าเพื่อค้นหาเหตุการณ์หนึ่งเหตุการณ์ขึ้นไปการค้นหาการเกิดเหตุการณ์การ ค้นหา เหตุการณ์อย่างน้อย (และอาจมากกว่านั้น) และXการค้นหาอย่างน้อยแต่ไม่เกินกว่าเหตุการณ์X+?XX{n}?nXX{n,}?nXX{n,m}?nmX
• ตัวระบุปริมาณโลภมาก ( ?+, *+หรือ++) มีลักษณะคล้ายกับปริมาณโลภมาก ยกเว้นว่าตัวระบุปริมาณโลภมากจะพยายามค้นหารายการที่ตรงกันที่ยาวที่สุดเท่านั้น ในขณะที่ตัวปริมาณโลภสามารถพยายามได้หลายครั้ง สามารถตั้งค่าX?+ให้ค้นหาหนึ่งรายการหรือน้อยกว่าXเพื่อX*+ค้นหารายการที่เกิดขึ้นเป็นศูนย์หรือมากกว่า เพื่อค้นหารายการอย่างน้อยหนึ่งรายการเพื่อค้นหารายการของเพื่อ ค้นหา รายการอย่างน้อย (และอาจมากกว่า) Xรายการและเพื่อค้นหารายการอย่างน้อยแต่ไม่เกินรายการ.X++XX{n}+nXX{n,}+nXX{n,m}+ nmX

ตัวอย่างต่อไปนี้แสดงให้เห็นถึงการใช้ปริมาณโลภ: java RegexDemo .*ox "fox box pox" นี่คือผลลัพธ์:

regex = .*ox
input = fox box pox
Found [fox box pox] starting at 0 and ending at 10

ตัวระบุปริมาณโลภ ( .*) ค้นหาลำดับที่ยาวที่สุดของอักขระที่ลงท้ายoxด้วย โดยจะใช้ข้อความที่ป้อนทั้งหมดแล้วย้อนกลับจนกว่าจะตรวจพบว่าข้อความที่ป้อนลงท้ายด้วยอักขระเหล่านี้ พิจารณาปริมาณขี้เกียจตอนนี้: java RegexDemo .*?ox "fox box pox" ผลลัพธ์:

regex = .*?ox
input = fox box pox
Found [fox] starting at 0 and ending at 2
Found [ box] starting at 3 and ending at 6
Found [ pox] starting at 7 and ending at 10

Lazy quantifier ( .*?) ค้นหาลำดับที่สั้นที่สุดของอักขระที่ลงท้ายoxด้วย เริ่มต้นด้วยสตริงว่างและค่อยๆ ใช้อักขระจนกว่าจะพบรายการที่ตรงกัน จากนั้นทำงานต่อไปจนกว่าข้อความที่ป้อนจะหมด สุดท้าย เรามาดูปริมาณที่โลภมาก: java RegexDemo .*+ox "fox box pox" และนี่คือผลลัพธ์:

regex = .*+ox
input = fox box pox

ตัวระบุปริมาณที่โลภมาก ( .*+) ไม่พบรายการที่ตรงกันเนื่องจากใช้ข้อความที่ป้อนทั้งหมด และไม่มีสิ่งใดเหลือให้จับคู่oxที่ส่วนท้ายของนิพจน์ทั่วไป ต่างจากตัวปริมาณที่โลภมาก ตัวปริมาณที่โลภมากจะไม่ย้อนกลับ

การจับคู่ที่มีความยาวเป็นศูนย์

บางครั้งเมื่อทำงานกับตัวระบุปริมาณ คุณจะพบกับการจับคู่ที่มีความยาวเป็นศูนย์ ตัวอย่างเช่น การใช้ greedy quantifier ต่อไปนี้จะส่งผลให้เกิดการจับคู่ที่มีความยาวเป็นศูนย์หลายรายการ java RegexDemo a? abaa ผลลัพธ์ของการเรียกใช้ตัวอย่างนี้:

regex = a?
input = abaa
Found [a] starting at 0 and ending at 0
Found [] starting at 1 and ending at 0
Found [a] starting at 2 and ending at 2
Found [a] starting at 3 and ending at 3
Found [] starting at 4 and ending at 3

มีการแข่งขันห้านัดในผลการดำเนินการ แม้ว่าตัวแรก สาม และสี่นั้นค่อนข้างคาดหวัง (ตรงกับตำแหน่งของตัวอักษรสามตัวaในabaa) แต่ตัวที่สองและห้าอาจทำให้คุณประหลาดใจ ดูเหมือนว่าพวกเขาจะระบุสิ่งที่aสอดคล้องbกับส่วนท้ายของข้อความ แต่ในความเป็นจริงแล้วไม่เป็นเช่นนั้น นิพจน์ทั่วไปa?ไม่ค้นหาbที่ส่วนท้ายของข้อความ มันค้นหาว่ามีหรือaไม่มี เมื่อa?ไม่พบaระบบจะรายงานว่าเป็นการจับคู่ที่มีความยาวเป็นศูนย์

นิพจน์แฟล็กที่ซ้อนกัน

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

• (?i): เปิดใช้งานการจับคู่รูปแบบที่ไม่คำนึงถึงตัวพิมพ์เล็กและตัวพิมพ์ใหญ่ ตัวอย่างเช่น เมื่อใช้คำสั่งjava RegexDemo (?i)tree TreehouseลำดับของอักขระTreeจะตรงกับรูปtreeแบบ ค่าเริ่มต้นคือการค้นหารูปแบบที่คำนึงถึงตัวพิมพ์เล็กและตัวพิมพ์ใหญ่
• (?x): อนุญาตให้ใช้อักขระช่องว่างและความคิดเห็นที่ขึ้นต้นด้วยอักขระเมตาภายในรูป#แบบ ผู้จับคู่จะไม่สนใจทั้งสองอย่าง ตัวอย่างเช่น สำหรับjava RegexDemo ".at(?x)#match hat, cat, and so on" matterลำดับอักขระmatที่ตรงกับรูป.atแบบ ตามค่าเริ่มต้น ไม่อนุญาตให้ใช้อักขระช่องว่างและความคิดเห็น และผู้จับคู่จะถือว่าอักขระเหล่านั้นเป็นอักขระที่เกี่ยวข้องกับการค้นหา
• (?s): เปิดใช้งานโหมด dotall ซึ่งอักขระ dot meta จะจับคู่ตัวคั่นบรรทัด นอกเหนือจากอักขระอื่นๆ เช่น คำสั่งjava RegexDemo (?s). \nจะค้นหาอักขระขึ้นบรรทัดใหม่ ค่าเริ่มต้นจะตรงกันข้ามกับ dotall: ไม่พบตัวคั่นบรรทัด ตัวอย่างเช่น คำสั่งJava RegexDemo . \nจะไม่พบอักขระขึ้นบรรทัดใหม่
• (?m): เปิดใช้งานโหมดหลายบรรทัด โดยจะ^ตรงกับจุดเริ่มต้นและ$จุดสิ้นสุดของแต่ละบรรทัด ตัวอย่างเช่นjava RegexDemo "(?m)^abc$" abc\nabcค้นหาทั้งสองลำดับในข้อความที่abcป้อน ตามค่าเริ่มต้น จะใช้โหมดบรรทัดเดียว: ^จับคู่จุดเริ่มต้นของข้อความที่ป้อนทั้งหมด และ$จับคู่ส่วนท้ายของข้อความ ตัวอย่างเช่นjava RegexDemo "^abc$" abc\nabcส่งคืนการตอบกลับว่าไม่มีรายการที่ตรงกัน
• (?u): เปิดใช้งานการจัดตำแหน่งตัวพิมพ์ที่ละเอียดอ่อนของ Unicode ธงนี้ เมื่อใช้ร่วมกับ(?i)จะอนุญาตให้มีการจับคู่รูปแบบที่ไม่คำนึงถึงตัวพิมพ์เล็กและตัวพิมพ์ใหญ่ตามมาตรฐาน Unicode การตั้งค่าเริ่มต้นคือการค้นหาอักขระที่คำนึงถึงตัวพิมพ์เล็กและตัวพิมพ์ใหญ่และ US-ASCII เท่านั้น
• (?d): เปิดใช้งานโหมดสตริงสไตล์ Unix โดยที่ตัวจับคู่จะจดจำอักขระเมตาในบริบท.และ^เฉพาะตัว$คั่นบรรทัด\nเท่านั้น ค่าเริ่มต้นคือโหมดสตริงสไตล์ที่ไม่ใช่ Unix: ตัวจับคู่จะจดจำตัวคั่นบรรทัดทั้งหมดในบริบทของอักขระเมตาข้างต้น

นิพจน์แฟล็กที่ซ้อนกันมีลักษณะคล้ายกับกลุ่มที่บันทึกไว้เนื่องจากอักขระของพวกเขาถูกล้อมรอบด้วยอักขระเมตาในวงเล็บ ต่างจากกลุ่มที่บันทึก นิพจน์แฟล็กที่ซ้อนกันเป็นตัวอย่างของกลุ่มที่ไม่ได้บันทึก ซึ่งเป็นโครงสร้างนิพจน์ทั่วไปที่ไม่บันทึกอักขระข้อความ ถูกกำหนดให้เป็นลำดับของอักขระที่ล้อมรอบด้วย meta character ของวงเล็บ

บทสรุป

ดังที่คุณคงทราบแล้วว่านิพจน์ทั่วไปมีประโยชน์อย่างยิ่งและมีประโยชน์มากยิ่งขึ้นเมื่อคุณเชี่ยวชาญความแตกต่างของไวยากรณ์ จนถึงตอนนี้ ฉันได้แนะนำให้คุณรู้จักกับพื้นฐานของนิพจน์ทั่วไปPatternและ ในส่วนที่ 2 เราจะเจาะลึกลงไปใน Regex API และสำรวจวิธีการของPattern, MatcherและPatternSyntaxException. นอกจากนี้ ฉันจะแสดงแอปพลิเคชัน Regex API ที่ใช้งานได้จริงสองแอปพลิเคชันให้คุณดู ซึ่งคุณสามารถใช้ในโปรแกรมของคุณได้ทันที นิพจน์ทั่วไปใน Java ส่วนที่ 3 นิพจน์ทั่วไปใน Java ส่วนที่ 4 นิพจน์ทั่วไปใน Java ส่วนที่ 5