ดังที่เราทุกคนรู้ในการพัฒนาโปรแกรมมันเป็นสิ่งที่หลีกเลี่ยงไม่ได้ที่จะเผชิญกับสถานการณ์ที่จำเป็นต้องมีการจับคู่, ค้นหา, แทนที่และตัดสิน บางครั้งสถานการณ์เหล่านี้ซับซ้อนกว่า หากแก้ไขในการเข้ารหัสที่บริสุทธิ์มักจะเสียเวลาและพลังงานของโปรแกรมเมอร์ ดังนั้นการเรียนรู้และการใช้การแสดงออกอย่างสม่ำเสมอจึงกลายเป็นวิธีหลักในการแก้ไขข้อขัดแย้งนี้
อย่างที่เราทราบกันดีว่าการแสดงออกปกติเป็นข้อกำหนดที่สามารถใช้สำหรับการจับคู่รูปแบบและการเปลี่ยน นิพจน์ทั่วไปเป็นรูปแบบตัวอักษรที่ประกอบด้วยอักขระธรรมดา (เช่นอักขระ A ถึง Z) และอักขระพิเศษ (Metacharacters) มันถูกใช้เพื่ออธิบายหนึ่งหรือมากกว่านั้นที่จะจับคู่เมื่อค้นหาร่างของตัวอักษร นิพจน์ทั่วไปทำหน้าที่เป็นเทมเพลตเพื่อให้ตรงกับรูปแบบอักขระกับสตริงที่ค้นหา
ตั้งแต่ JDK1.4 เปิดตัวแพ็คเกจ java.util.regex ทำให้เรามีแพลตฟอร์มแอปพลิเคชันนิพจน์ทั่วไปของ Java ที่ดี
เนื่องจากการแสดงออกปกติเป็นระบบที่ซับซ้อนมากฉันจะให้ตัวอย่างของแนวคิดเบื้องต้นเท่านั้น สำหรับข้อมูลเพิ่มเติมโปรดดูหนังสือที่เกี่ยวข้องและสำรวจพวกเขาด้วยตัวเอง
// backslash
ช่วงเวลา/t ('/u0009')
/N LINE BREAK ('/U000A')
/r Enter ('/u000d')
/d หมายเลขเทียบเท่ากับ [0-9]
/d non-non-digit เทียบเท่ากับ [^0-9]
สัญลักษณ์ว่างเปล่า [/t/n/x0b/f/r]
/s สัญลักษณ์ที่ไม่ใช่การบล็อก [^/t/n/x0b/f/r]
/W ตัวละครแต่ละตัว [A-ZA-Z_0-9]
/W ตัวละครที่ไม่ใช่บุคคล [^A-ZA-Z_0-9]
/f เพจหยุดพัก
/E หลบหนี
/b ขอบเขตของคำ
/b ขอบเขตที่ไม่ใช่คำ
/g สิ้นสุดการแข่งขันก่อนหน้านี้
^ เริ่มต้นด้วยขีด จำกัด
ขีด จำกัด เงื่อนไขของ Java คือตัวละครเริ่มต้นด้วย java
$ คือจุดสิ้นสุดของขีด จำกัด
ขีด จำกัด เงื่อนไข Java $ คืออักขระ java-end
- จำกัด เงื่อนไขใด ๆ อักขระเดียวยกเว้น /n
Java .. หลังจากขีด จำกัด เงื่อนไขคือ Java ตัวละครสองตัวใด ๆ ยกเว้นสายใหม่
เพิ่มข้อ จำกัด เฉพาะ "[]"
[AZ] เงื่อนไขถูก จำกัด ไว้ที่อักขระในช่วงตัวพิมพ์เล็ก A ถึง Z
[AZ] เงื่อนไขถูก จำกัด ไว้ที่ตัวละครหนึ่งตัวในช่วงตัวพิมพ์ใหญ่ A ถึง Z
เงื่อนไข [a-za-z] ถูก จำกัด ไว้ที่อักขระในช่วงล่าง A ถึง Z หรือตัวพิมพ์ใหญ่ A ถึง Z
[0-9] เงื่อนไขถูก จำกัด ไว้ที่หนึ่งอักขระในช่วงล่าง 0 ถึง 9 ช่วง
[0-9A-Z] เงื่อนไขถูก จำกัด อยู่ที่ช่วงล่าง 0 ถึง 9 หรือ A ถึง Z ช่วง
[0-9 [AZ]] เงื่อนไขถูก จำกัด อยู่ที่ตัวพิมพ์เล็ก 0 ถึง 9 หรือ A ถึง Z (แยก)
[] และเพิ่มเงื่อนไขการ จำกัด "[^]" อีกครั้ง
[^az] เงื่อนไขถูก จำกัด ไว้ที่ตัวละครในช่วงของ Non-Lowercase A ถึง Z
[^az] เงื่อนไข จำกัด ตัวละครหนึ่งตัวในช่วงที่ไม่ใช่แคป a ถึง z
[^a-za-z] เงื่อนไขถูก จำกัด อยู่ที่ตัวละครในช่วงของ non-lowercase A ถึง Z หรือตัวพิมพ์ใหญ่ A ถึง Z
[^0-9] เงื่อนไขถูก จำกัด ไว้ที่ตัวละครหนึ่งตัวในช่วงของ Non-Lowercase 0 ถึง 9
[^0-9a-z] เงื่อนไขถูก จำกัด ไว้ที่ตัวละครในช่วงของ non-lowercase 0 ถึง 9 หรือ A ถึง Z
[^0-9 [AZ]] เงื่อนไขถูก จำกัด ไว้ที่อักขระในช่วงของ Non-Lowercase 0 ถึง 9 หรือ A ถึง Z (สี่แยก)
เมื่อเงื่อนไขการ จำกัด คืออักขระเฉพาะปรากฏมากกว่า 0 ครั้งคุณสามารถใช้ "*"
J* มากกว่า 0 J
.* อักขระใด ๆ ด้านบน 0
J.*DJ และ D ใด ๆ
เมื่อเงื่อนไขการ จำกัด คืออักขระเฉพาะปรากฏมากกว่าหนึ่งครั้งคุณสามารถใช้ "+"
J+ 1 หรือมากกว่า J
.+ 1 ตัวหรือมากกว่าอักขระโดยพลการ
J.+1 ตัวอักษรขึ้นไประหว่าง DJ และ D
เมื่อเงื่อนไขการ จำกัด นั้นเป็นอักขระเฉพาะปรากฏขึ้น 0 หรือมากกว่านั้น "?" สามารถใช้งานได้
จา? J หรือ JA ปรากฏขึ้น
จำกัด การเกิดขึ้นอย่างต่อเนื่องของอักขระหมายเลขที่ระบุ "{a}"
j {2} jj
j {3} jjj
มากกว่าข้อความและ "{a,}"
j {3,} jjj, jjjjj, jjjjj, ??? (J อยู่ร่วมกันมากกว่า 3 ครั้ง)
มากกว่าหนึ่งข้อความน้อยกว่า b "{a, b}"
j {3,5} jjj หรือ jjjj หรือ jjjjj
ใช้หนึ่งในสอง
J | AJ หรือ A
Java | สวัสดี Java หรือ Hello
"()" ระบุประเภทชุดค่าผสมตัวอย่างเช่นถ้าฉันสอบถามข้อมูลระหว่าง <a href =/"index.html/"> ดัชนี </a> ฉันสามารถเขียน <a.*href =/".*/"> (.+?) </a>
เมื่อใช้ pattern.compile function คุณสามารถเพิ่มพารามิเตอร์ที่ควบคุมพฤติกรรมการจับคู่ของนิพจน์ทั่วไป:
รูปแบบรูปแบบ compile (string regex, int flag)
ช่วงของค่าของธงมีดังนี้:
pattern.canon_eq การจับคู่จะถูกกำหนดหากและเฉพาะในกรณีที่ "การสลายตัวของ canonical" ของอักขระทั้งสองนั้นเหมือนกันทุกประการ ตัวอย่างเช่นหลังจากใช้ธงนี้นิพจน์ "a/u030a" จะจับคู่ "?" โดยค่าเริ่มต้น "ความเท่าเทียมกันที่ยอมรับได้" ไม่ได้รับการพิจารณา
pattern.case_insensitive (? i) โดยค่าเริ่มต้นการจับคู่ที่ไม่ระบุตัวเรือนมีให้เฉพาะชุดอักขระ US-ASCII เท่านั้น ธงนี้ช่วยให้การแสดงออกสามารถละเว้นกรณีสำหรับการจับคู่ เพื่อให้ตรงกับอักขระ Unicode ที่มีขนาดที่ไม่รู้จักเพียงแค่รวม unicode_case เข้ากับธงนี้
pattern.comments (? x) ในโหมดนี้อักขระอวกาศ (ในนิพจน์ปกติ) จะถูกละเว้นเมื่อจับคู่ (หมายเหตุของนักแปล: ไม่ได้อ้างถึง "// s" ในนิพจน์ แต่หมายถึงช่องว่างแท็บการคืนรถ ฯลฯ ) ในนิพจน์ ความคิดเห็นเริ่มต้นที่ # และสิ้นสุดที่บรรทัดนี้ โหมด UNIX สามารถเปิดใช้งานผ่านธงฝังตัว
pattern.dotall (? s) ในโหมดนี้นิพจน์ ' สามารถจับคู่อักขระใด ๆ รวมถึงอักขระสุดท้ายที่แสดงถึงบรรทัด โดยค่าเริ่มต้นนิพจน์ '.' ไม่ตรงกับอักขระสุดท้ายของบรรทัด
pattern.multiline
(? m) ในโหมดนี้ '^' และ '$' ตรงกับจุดเริ่มต้นและจุดสิ้นสุดของแถวตามลำดับ นอกจากนี้ '^' ยังคงตรงกับจุดเริ่มต้นของสตริงและ '$' ก็ตรงกับจุดสิ้นสุดของสตริง โดยค่าเริ่มต้นนิพจน์ทั้งสองนี้ตรงกับจุดเริ่มต้นและจุดสิ้นสุดของสตริง
pattern.unicode_case
(? u) ในโหมดนี้หากคุณเปิดใช้งานการตั้งค่าสถานะ CASE_INSENSITITY มันจะตรงกับอักขระ Unicode กับเคสที่ไม่ปรากฏชื่อ โดยค่าเริ่มต้นการจับคู่แบบไม่อ่อนไหวเป็นกรณีสำหรับชุดอักขระ US-ASCII เท่านั้น
pattern.unix_lines (? d) ในโหมดนี้มีเพียง '/n' เท่านั้นที่ถือว่าเป็นการยกเลิกบรรทัดและการจับคู่ '.', '^' และ '$'
การละทิ้งแนวคิดที่ว่างเปล่าต่อไปนี้เป็นกรณีการใช้งานปกติของ Java อย่างง่าย ๆ :
◆ตัวอย่างเช่นเมื่อสตริงมีการยืนยัน
// ค้นหาสตริงที่เริ่มต้นด้วย Java และสิ้นสุดที่รูปแบบ Will Pattern = pattern.compile ("^Java.*"); matcher matcher = pattern.matcher ("Java ไม่ใช่มนุษย์"); บูลีน b = matcher.matches (); // เมื่อเงื่อนไขเป็นที่พอใจมันจะส่งคืนจริงมิฉะนั้น system.out.out.println (b); ◆เมื่อแยกสตริงที่มีหลายเงื่อนไข
รูปแบบรูปแบบ = pattern.compile ("[, |]+"); string [] strs = pattern.split ("Java Hello World Java, Hello ,, World | Sun"); สำหรับ (int i = 0; i <strs.length; ◆การเปลี่ยนข้อความ (อักขระปรากฏเป็นครั้งแรก)
รูปแบบรูปแบบ = รูปแบบ compile ("นิพจน์ปกติ"); matcher matcher = pattern.matcher ("Expression ปกติ Hello World, Expression ปกติ Hello World"); // แทนที่ข้อมูลแรกที่สอดคล้องกับระบบสม่ำเสมอ. ◆การเปลี่ยนข้อความ (ทั้งหมด)
รูปแบบรูปแบบ = รูปแบบ compile ("นิพจน์ปกติ"); matcher matcher = pattern.matcher ("Expression ปกติ Hello World, Expression ปกติ Hello World"); // แทนที่ข้อมูลแรกที่สอดคล้องกับระบบสม่ำเสมอ. ◆การเปลี่ยนข้อความ (แทนที่อักขระ)
รูปแบบรูปแบบ = รูปแบบ compile ("นิพจน์ปกติ"); matcher matcher = pattern.matcher ("Expression ปกติ Hello World, Expression World ปกติ"); StringBuffer SBR = new StringBuffer (); ในขณะที่ (matcher.find ()) {matcher.appendreplacement (sbr, "java");} matcher.appendtail (sbr); system.out.println (sbr.toString ());◆ตรวจสอบว่าเป็นที่อยู่อีเมลหรือไม่
string str = "[email protected]"; รูปแบบรูปแบบ = pattern.compile ("[// w //.//-like+@( [outy// w //-- เหมือนนั้นขึ้นไป
◆ลบแท็ก HTML
รูปแบบรูปแบบ = pattern.compile ("<.+?>", pattern.dotall); matcher matcher = pattern.matcher ("<a href =/" index.html/"> home </a>"); String.replaceall (""); system.out.println (สตริง); ◆ค้นหาสตริงเงื่อนไขที่สอดคล้องกันใน HTML
รูปแบบรูปแบบ = pattern.compile ("href =/" (.+?)/""); matcher matcher = pattern.matcher ("<a href =/" index.html/"> home </a>"); if (matcher.find ()) system.out.out.println ◆สกัดกั้น http: // ที่อยู่
// intercept urlpattern pattern = pattern.compile ("(http: // | https: //) {1} [//w//.//-//-/:]+"); matcher = pattern.matcher ("dsdsds <http: // dsds // gfgffdd ในขณะที่ (matcher.find ()) {buffer.append (matcher.group ()); buffer.append ("/r/n"); System.out.println (buffer.toString ());}◆แทนที่อักขระ {} ที่ระบุ
string str = "ประวัติการพัฒนาปัจจุบันของ java มาจาก {0} ปี - {1} ปี"; string [] [] object = {สตริงใหม่ [] {"// {0 //}", "1995"}, สตริงใหม่ [] {"// {1 //}", "2007" Sourcestring, Object [] Object) {String temp = sourcestring; สำหรับ (int i = 0; i <object.length; i ++) {string [] result = (string []) วัตถุ [i]; รูปแบบรูปแบบ = รูปแบบ compile (ผลลัพธ์ [0]); matcher matcher = pattern.matcher (temp); temp = matcher.replaceall (ผลลัพธ์ [1]); } return temp;}◆คำถามแบบสอบถามในไดเรกทอรีที่กำหนดด้วยเงื่อนไขปกติ
// ใช้ในการแคชรายการไฟล์ไฟล์ ArrayList ส่วนตัว = new ArrayList (); // ใช้ในการโฮสต์พา ธ ไฟล์ส่วนตัว _path; // ใช้เพื่อโฮสต์สูตรส่วนตัวที่ไม่ได้รับการแก้ไขสตริงส่วนตัว _regexp; คลาส MyFileFilter ใช้ FileFilter { / *** จับคู่ชื่อไฟล์* / Public Boolean Accept (ไฟล์ไฟล์) {ลอง {รูปแบบรูปแบบ = pattern.compile (_regexp); matcher match = pattern.matcher (file.getName ()); Return Match.matches (); } catch (exception e) {return true; }}} / *** วิเคราะห์อินพุตสตรีม* @param อินพุต* / filesAnalyze (พา ธ สตริง, สตริง regexp) {getFileName (พา ธ , regexp); } /** * วิเคราะห์ชื่อไฟล์และเพิ่มไฟล์ * @param อินพุต * /โมฆะส่วนตัว getFileName (พา ธ สตริง, สตริง regexp) {// directory_path = path; _regexp = regexp; ไดเรกทอรีไฟล์ = ไฟล์ใหม่ (_path); ไฟล์ [] filesfile = directory.listfiles (ใหม่ myFileFilter ()); if (filesfile == null) ส่งคืน; สำหรับ (int j = 0; j <filesfile.length; j ++) {files.add (filesfile [j]); } กลับ; } / *** แสดงข้อมูลเอาต์พุต* @param out* / public void print (printstream out) {iterator leements = files.iterator (); ในขณะที่ (elements.hasNext ()) {file file = (ไฟล์) องค์ประกอบ. next (); out.println (file.getPath ()); }} เอาต์พุตโมฆะคงที่สาธารณะ (เส้นทางสตริง, สตริง regexp) {filesAnalyze fileGroup1 = ใหม่ filesAnalyze (พา ธ , regexp); filegroup1.print (System.out); } โมฆะคงที่สาธารณะหลัก (สตริง [] args) {เอาท์พุท ("c: //", "[az |.]*"); -มีฟังก์ชั่นมากมายของความสม่ำเสมอของชวา ในความเป็นจริงตราบใดที่การประมวลผลตัวละครไม่มีอะไรที่ความสม่ำเสมอไม่สามารถทำได้ (แน่นอนว่าต้องใช้เวลานานมากในการอธิบายอย่างสม่ำเสมอ ||| ... )
ข้างต้นคือข้อมูลที่แยกแยะการแสดงออกของ Java ปกติ เราจะยังคงเพิ่มข้อมูลที่เกี่ยวข้องในอนาคต ขอบคุณสำหรับการสนับสนุนเว็บไซต์นี้!