java.util.regex

คลาส Pattern

java.lang.Object

java.util.regex.Pattern

ทุกส่วนที่ทำให้เป็นไปได้:

Serializable

public final class Pattern
extends Object
implements Serializable

การแสดงรูปแบบที่ถูกส่งตัวเลขของสายที่มีความหมายเชิงกฎ

ความคิดเห็นที่มีรูปแบบที่กำหนด ที่กำหนดให้เป็นสตริง ต้องถูกคอมไพล์ก่อนเป็นอินสแตนซ์ของคลาสนี้ก่อน ตามด้วยรูปแบบที่ได้สามารถใช้เพื่อสร้างวัตถุ Matcher ที่สามารถตรวจสอบความตรงกับรูปแบบที่เลือกได้หลากหลาย ตัวเลข ต่อไป คำศัพท์ที่มีความเชื่อมโยงกับการแสดงค่าทั้งหมด ที่เกี่ยวข้องกับการทำงานการตรวจสอบที่อยู่ใน matcher,มี matcher หลายๆ ตัวสามารถแชร์ pattern กันเดียวกันได้

การเรียกใช้งานปกติจึงเป็นดังนี้

 Pattern p = Pattern.compile("a*b");
 Matcher m = p.matcher("aaaaab");
 boolean b = m.matches();

มีการกำหนดวิธีที่ชื่อว่า matches โดยคลาสนี้เป็น ความสะดวกสำหรับการใช้งานตัวเลือกสำหรับการใช้งานตัวเลือกที่ใช้ครั้งเดียว ของวิธีนี้ ส่งตัวเลขเป็นตัวเลือกและตรวจสอบความตรงกับรายการข้อมูลเข้าในในการเรียกเดียวกัน คำอธิบาย

 boolean b = Pattern.matches("a*b", "aaaaab");

เทียบเท่ากับสามคำอธิบายข้างต้น แต่สำหรับการตรวจสอบซ้ำ มันไม่เป็นประสิทธิภาพเพราะมันไม่อนุญาตให้สายที่ถูกส่งตัวเลขใช้งานอีกครั้ง

คลาสนี้มีอินสแตนซ์ที่ไม่สามารถเปลี่ยนแปลงได้และปลอดภัยสำหรับการใช้งานโดยหลายๆ แถวของโปรแกรมเมนตราหรือเทอร์มินอลคอนเครนต์ อินสแตนซ์ของคลาส Matcher ไม่ปลอดภัยสำหรับ การใช้งานแบบนี้.

สรุปโครงสร้างของสายตรวจสอบสำหรับการใช้งานกับสายอักษร

*

โครงสร้าง	การเข้ารหัส
ตัวอักษร
x	ตัวอักษร x
\\	ตัวอักษร backslash
\0n	ตัวอักษรที่มีค่าเซกเท็นตัวเลขแปด 0 n (0 <= n <= 7)
\0nn	ตัวอักษรที่มีค่าเซกเท็นตัวเลขแปด 0 nn (0 <= n <= 7)
\0mnn	ตัวอักษรที่มีค่าเซกเท็นตัวเลขแปด 0 mnn (0 <= m <= 3, 0 <= n <= 7)
\xhh	ตัวอักษรที่มีค่า 16 หน้าที่ 0x hh
\uhhhh	ตัวอักษรที่มีค่าหนึ่งตัวเลขฐาน 16 คือ 0x hhhh
\x{h...h}	ตัวอักษรที่มีค่าหนึ่งตัวเลขฐาน 16 คือ 0x h...h (Character.MIN_CODE_POINT <= 0x h...h <= Character.MAX_CODE_POINT)
\t	ตัวอักษร tab ( '\u0009' )
\n	ตัวอักษร newline (line feed) ( '\u000A' )
\r	อักษร carriage-return ( '\u000D' )
\f	อักษร form-feed ( '\u000C' )
\a	อักษร alert (bell) ( '\u0007' )
\e	อักษร escape ( '\u001B' )
\cx	ตัวควบคุมที่สอดคล้องกับ x
คลาสตัวอักษร
[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] (ลบ)
คลาสตัวอักษรที่กำหนดไว้ล่วงละเอียด
.	ตัวอักษรใดก็ตาม (อาจหรืออาจไม่ตรงกับ ตัวเลือกสิ้นสุดบรรทัด)
\d	รักษาตัวเลข: [0-9]
\D	ไม่ใช่ตัวเลข: [^0-9]
\s	ตัวเลือกว่าง: [ \t\n\x0B\f\r]
\S	ไม่ใช่ตัวเลือกว่าง: [^\s]
\w	คำที่มีตัวเลือก: [a-zA-Z_0-9]
\W	ตัวเลือกที่ไม่มีตัวเลือก: [^\w]
กลุ่มตัวอักษร POSIX (เท่านั้น US-ASCII)
\p{Lower}	ตัวอักษรตัวเล็ก: [a-z]
\p{Upper}	อักษรตัวใหญ่: [A-Z]
\p{ASCII}	ทุกอักษร ASCII: [\x00-\x7F]
\p{Alpha}	อักษรตัว: [\p{Lower}\p{Upper}]
\p{Digit}	ตัวเลขทศนิยม: [0-9]
\p{Alnum}	อักษรตัวเลข: [\p{Alpha}\p{Digit}]
\p{Punct}	ตัวเลือกตรวจสอบ: !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
\p{Graph}	ตัวอักษรที่มองเห็นได้: [\p{Alnum}\p{Punct}]
\p{Print}	ตัวอักษรที่สามารถพิมพ์ได้: [\p{Graph}\x20]
\p{Blank}	ช่องว่างหรือ tab: [ \t]
\p{Cntrl}	ตัวควบคุม: [\x00-\x1F\x7F]
\p{XDigit}	ตัวเลขฐาน 16: [0-9a-fA-F]
\p{Space}	ตัวอักษรว่าง: [ \t\n\x0B\f\r]
คลาส Character ใน java.lang (ประเภทตัวเลือกง่าย ประเภทตัวเลือก java)
\p{javaLowerCase}	เทียบเท่ากับ java.lang.Character.isLowerCase()
\p{javaUpperCase}	เทียบเท่ากับ java.lang.Character.isUpperCase()
\p{javaWhitespace}	เทียบเท่ากับ java.lang.Character.isWhitespace()
\p{javaMirrored}	เทียบกับ java.lang.Character.isMirrored()
คลาสสำหรับตัวเลือก Unicode, บล็อค, หมวดหมู่ และ คุณสมบัติทางไบนารี
\p{IsLatin}	ตัวเลือกเขียนแบบ Latin (script)
\p{InGreek}	ตัวเลือกในบล็อค Greek (block)
\p{Lu}	กล่องเลขตัวใหญ่ (ประเภท)
\p{IsAlphabetic}	ตัวเลขอักษร (คุณสมบัติบนสอง)
\p{Sc}	สัญลักษณ์เงิน
\P{InGreek}	ตัวอักษรทุกตัวเว้นแต่ตัวหนึ่งในกล่องกรีก (การปฏิเสธ)
[\p{L}&&[^\p{Lu}]]	อักษรใดก็ตามที่ไม่ใช่ตัวใหญ่ (ลบ)
ตัวเลือกเชิงเส้นรูป
^	ต้นบรรทัด
$	สุดบรรทัด
\b	สิ่งที่แยกคำ
\B	สิ่งที่ไม่แยกคำ
\A	ต้นของการส่งข้อมูล
\G	สิ้นสุดการตรวจจับก่อนหน้า
\Z	สิ้นสุดของการส่งออกแต่ไม่รวมสุดท้าย ตัวสิ้นสุด,หากมี
\z	สิ้นสุดของการส่งออก
Quantifiersที่คิดว่าเต็มที่
X?	X, หนึ่งครั้งหรือไม่เคย
X*	X, ซ้ำได้หลายครั้ง
ตัวเลข +	ตัวเลข, หรือมากกว่าครั้งเดียว
X{n}	X, ตรงกับ n ครั้ง
X{n,}	X, อย่างน้อย n ครั้ง
ตัวเลข { ตัวเลือก , ครั้ง }	ตัวเลข, อย่างน้อย ตัวเลือก แต่ไม่เกิน ครั้ง
คำถามที่ไม่ยืนยัน
ตัวเลข ??	X, หนึ่งครั้งหรือไม่เคย
X*?	X, ศูนย์ครั้งหรือมากกว่า
X+?	X หรือมากกว่าหนึ่งครั้ง
X{n}?	X และแท้จำนวน n
X{n,}?	X, อย่างน้อย n ครั้ง
X{n,m}?	X, อย่างน้อย n ครั้ง แต่ไม่เกิน m ครั้ง
ตัวเลขความเป็นเจ้าของ
X?+	X, หนึ่งครั้งหรือไม่เคย
X*+	X, หรือมากกว่าศูนย์ครั้ง
ตัวเลือก ++	ตัวเลือก, หลายครั้งหรือมากกว่านั้น
ตัวเลือก { n }+	ตัวเลือก, และตรงกับ n ครั้ง
X{n,}+	X,อย่างน้อย nครั้ง
X{n,m}+	X,อย่างน้อย nครั้งแต่ไม่เกิน mครั้ง
Logical operators
XY	X ตามด้วย Y
X|Y	ทั้ง X หรือ Y
(X)	X เป็น กลุ่มจับที่กำหนด
การอ้างอิงกลับ
\n	Whatever the nthgroupที่กำหนดให้ที่ตรงกับ
\ k<ชื่อ>	Whatever the groupที่กำหนดให้ "ชื่อ"ที่ตรงกับ
คำฟังก์ชันคำอ้างอิง
\	ไม่มีอะไรแต่จะอ้างอิงตัวอักษรต่อไปนี้
\Q	ไม่มีอะไรแต่จะอ้างอิงตัวอักษรทุกตัวจนถึง \E
\E	ไม่มีอะไรแต่จะสิ้นสุดการอ้างอิงที่เริ่มต้นด้วย \Q
สร้างที่มีความพิเศษ (กลุ่มการจับที่มีชื่อและกลุ่มการจับที่ไม่มีชื่อ)
(?<name>X)	X, ในฐานะกลุ่มการจับที่มีชื่อ
(?:X)	X, เป็นกลุ่มที่ไม่จับค่า
(?idmsuxU-idmsuxU)	ไม่มีอะไร แต่เปลี่ยนสถานะตัวเลือก dmsuxU เปิด - ปิด
(?idmsux-idmsux:X)	X, ในการใช้งานเป็น กลุ่มที่ไม่จับคู่ พร้อมด้วยตัวเลือก dmsux ในการเปิดและปิด
(?=X)	X, ผ่านการสำรวจทางบวกที่มีความกว้างเป็นศูนย์
(?!X)	X, ผ่าน zero-width negative lookahead
(?<= จำนวน )	X, ผ่าน zero-width positive lookbehind
(?<! จำนวน )	X, ผ่าน negative lookbehind แบบ zero-width
(?>X)	X, ในฐานะกลุ่มอิสระ ที่ไม่มีการคัดลอก

Backslashes, escapes, และ quoting

อักษร backslash ( '\' ) ใช้เพื่อเริ่มต้นโครงสร้างที่ถูกหลบหนีตามที่กำหนดในตารางข้างต้น รวมทั้งใช้ในการอ้างอิงตัวอักษรที่อาจจะถูกตีความว่าเป็นโครงสร้างที่ไม่ถูกหลบหนี ดังนั้นสมาการ \\ จะตรงกับอักษร backslash แต่ละตัว และ \{ จะตรงกับ ตัวเลือกซ้าย

การใช้อักษร backslash ก่อนตัวอักษรอัลฟาเบตที่ไม่แสดงถึงโครงสร้างที่ถูกหลบหนีเป็นผิดพลาด; ตัวอักษรเหล่านี้ถูกจัดเก็บไว้สำหรับการขยายในอนาคตของภาษาวิทยาศาสตร์ความรู้สึก อักษร backslash สามารถใช้ก่อนตัวอักษรที่ไม่ได้เป็นอัลฟาเบต ไม่ว่าจะเป็นส่วนหนึ่งของโครงสร้างที่ไม่ถูกหลบหนีหรือไม่

การอ่านค่า backslashes ภายใน literal ของ string ในโค้ด Java จะถูกตีความตามที่กำหนด ตาม กำหนดเงื่อนไขภาษา Java™ เป็น Unicode escapes (บท 3.3) หรืออีกแบบอื่นของการ escape ตัวเลือก (บท 3.10.6) ต้องขยับเส้นลงตัวสองครั้งในสตริง ตัวแปรที่แทนรูปแบบที่มีความหมายเฉพาะเพื่อปกป้องมันจาก การแปลงโดยคอมไพเลอร์ Java bytecode. ตัวแปรคำภาษาอักษร "\b" เช่น ตัวเลือกนี้จะตรงกับตัวอักษร backspace ตัวเดียวเมื่อถูกอ่านในฐานะสายอักษร ขณะที่ "\\b" จะตรงกับเส้นแบ่งของคำ สายอักษร "\(hello\)" ไม่ถูกอนุญาต และนำไปสู่ข้อผิดพลาดในขณะคอมไพล์; เพื่อที่จะตรงกับรูปแบบข้อความ (hello) ข้อความแบบตรงจริง "\\(hello\\)" ต้องใช้งานก่อนเท่านั้น

คลาสต์ตัวเลือก

คลาสตัวเลขอาจปรากฏในคลาสตัวเลขอื่นๆ และอาจประกอบด้วยตัวเลขผสาน (อัตโนมัติ) และตัวเลขประกอบ ( && ) ตัวเชื่อมรวมหมายถึงคลาสที่มีทุกตัวอักษรที่ ในอย่างน้อยหนึ่งในคลาสที่มีอยู่ในโอปเจอร์ ผู้ใช้งานผสานตัวเลข ตัวเลข บ่งถึงคลาสที่มีทุกตัวอักษรที่อยู่ในทั้งสองของมัน คลาสตัวดำเนินการ

ความสำคัญของตัวเลือกที่มีความเชื่อมโยงกับตัวเลือกตัวอักษรคือดังนี้ ตั้งแต่สูงที่สุดไปยังต่ำที่สุด:

1	ตัวอักษรที่มีการเข้ารหัส	\x
2	กลุ่ม	[...]
3	เขตระหว่าง	a-z
4	สมาชิกรวม	[a-e][i-u]
5	สมาชิกร่วม	[a-z&&[aeiou]]

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

ตัวเลือกสำหรับการจบบรรทัด

ตัวเลือกสำหรับการจบบรรทัด คือ เป็นลำดับตัวอักษรหนึ่งหรือสองตัวที่ระบุ สิ้นสุดของบรรทัดที่มีตัวอักษรในลำดับของการเข้าถึง ต่อไปนี้เป็น ตัวที่รู้จักว่าเป็นตัวจบบรรทัด:

• ตัวอักษร newline (line feed) ( '\n' ),
• ตัวอักษร carriage-return ตามด้วยตัวอักษร newline ทันที ( "\r\n" ),
• อักษรข้างเคียงของการขึ้นบรรทัด ( '\r' ),
• อักษรการขึ้นบรรทัดถัดไป ( '\u0085' ),
• อักษรการแยกบรรทัด ( '\u2028' ), หรือ
• อักษรการแยกบทความ ( '\u2029 ).

ถ้าUNIX_LINES mode ถูกเปิดใช้งาน แล้วเท่านั้นจะมีตัวสิ้นสุดบรรทัดที่ถูกรู้จัก ที่เป็นตัวแทนของบรรทัดใหม่

สายความคิดเห็น . จะตรงกับตัวอักษรทุกตัวเว้นแต่ตัวสิ้นสุดบรรทัด หากไม่มีการกำหนดตัวเลือก DOTALL

โดยปกติ สายความคิดเห็น ^ และ $ จะปฏิเสธตัวสิ้นสุดบรรทัด และเท่านั้นจะตรงกับที่เริ่มต้นและสิ้นสุดตามลำดับ ตามตัวเลือกที่ให้ไว้ หาก MULTILINE mode ถูกเปิดใช้งานแล้ว ^ ตรงกับต้นเข้าถึงและหลังตัวเลือกที่มีบรรทัดที่ไม่เป็นสุดของเข้าถึง แต่ไม่เป็นสุดของเข้าถึง ในระหว่างที่อยู่ใน MULTILINE mode $ ตรงกับก่อนบรรทัดที่จบหรือสุดของคอลเลกชันของเข้าถึง

กลุ่มและการจับค่า

ตัวเลขกลุ่ม

กลุ่มการจับจำเป็นจำนวนโดยนับวงเล็บที่เปิดจากซ้ายไปขวา ในสมการ ((A)(B(C))) ตัวอย่างเช่น มีกลุ่มที่เช่นนี้สี่กลุ่ม:

1	((A)(B(C)))
2	(A)
3	(B(C))
4	(C)

กลุ่มฐานเลขฐาน 0 มักเป็นตัวแทนทั้งหมดของสมาชิกที่มีอยู่ในสายส่วนที่มีความหมายเดียวกัน

Capturing groups มีชื่อเรียกตามนี้เพราะในระหว่างการตรวจสอบว่าตรงกับรูปแบบ แต่ละส่วนของคำสั่งภาษาที่ตรงกับกลุ่มนี้จะถูกเก็บไว้ ส่วนที่ถูกเก็บอาจใช้ในตอนต่อๆ ไปในคำสั่งภาษาผ่านการอ้างอิงกลับ และยังสามารถดึงมาจาก matcher หลังจากที่การตรวจสอบเสร็จสิ้น

ชื่อกลุ่ม

กลุ่มที่สามารถเก็บรักษาสามารถถูกกำหนดให้มี "ชื่อ" หรือ " named-capturing group " และจะสามารถอ้างอิงกลับมาในตอนต่อๆ ไปด้วย "ชื่อ" กลุ่มชื่อประกอบด้วยตัวเลือกต่อไปนี้ ตัวเลือกแรกต้องเป็น " letter "

• ตัวเลือกใหญ่ " 'A' " จนถึง " 'Z' " ( '\u0041' ถึง '\u005a' ),
• ตัวอักษรตัวเล็ก 'a' ถึง 'z' ( '\u0061' ถึง '\u007a' ),
• '0' ถึง '9' ( '\u0030' ถึง '\u0039' ),

A named-capturing group ยังถูกจัดเรียงเป็นกลุ่มตามที่กำหนดใน Group number.

ค่าที่ถูกจับตัวมาจากกลุ่มจะเป็นลำดับย่อยเสมอ ที่กลุ่มที่เร็วๆ นี้ตรงกับ ถ้ากลุ่มถูกประเมินครั้งที่สอง เนื่องจากการวัด ดังนั้น ค่าที่ถูกจับตัวไว้ก่อนหน้า หากมี จะ ถ้าการประเมินครั้งที่สองไม่สำเร็จ จะคงอยู่ การเปรียบเทียบสายอักษร "aba" ต่อต้านสมการ (a(b)?)+ ตัวอย่างเช่น ทำให้กลุ่มสองมีค่าเป็น "b" ทั้งหมดที่ถูกจับได้จาก input จะถูกทิ้งไป สิ้นสุดของแต่ละการเปิดใหม่

กลุ่มที่ขึ้นต้นด้วย (? คือกลุ่มที่เป็น ไม่มีการจับตัว ที่ไม่จับข้อความและไม่ถูกนับเป็นส่วนหนึ่งของกลุ่ม, หรือ กลุ่มที่มีการจับตัวด้วยชื่อ

Unicode support

คลาสนี้สอดคล้องกับระดับ 1ของ มาตรฐาน Unicode Technical Standard #18: Unicode Regular Expression มากกว่า RL2.1 ตัวเลขเหมือนกัน (Canonical Equivalents).

รายการเติมเต็ม Unicode เช่น \u2014 ในโค้ด Java คำที่จะถูกประมวลผลตามที่กล่าวในส่วน 3.3 ของ รายการกำหนดเงื่อนไขภาษา Java™ ตัวอย่างเช่น escape sequences ที่นี้ถูกประมวลผลโดยตรงโดยเรขาคณิตวิทยาภาษาทำให้สามารถใช้ Unicode escapes ในสมการที่อ่านจากไฟล์หรือจากคีย์บอร์ดได้ ดังนั้นตัวแปร "\u2014" และ "\\u2014" ถึงแม้จะไม่เท่ากัน ก็จะถูกคอมไพล์เป็นรูปแบบ pattern ที่เดียวกัน ซึ่งจะตรวจสอบตัวอักษรที่มีค่าหนึ่งตามหนึ่งที่มีค่าฐาน 16 เท่ากับ 0x2014

ตัวอักษร Unicode สามารถแสดงในเรขาคณิตวิทยาภาษาได้โดยใช้ การแสดงในรูปแบบหนึ่งตามหนึ่ง(ค่าจุดโดยตรงของหนึ่งตามหนึ่งที่มีค่าฐาน 16)ตามที่กล่าวในโครงสร้าง \x{...} , เช่น ตัวเลือกตัวเลือก U+2011F สามารถกำหนดได้เป็น \x{2011F} แทนที่จะเป็นสองตัวเลือกติดกัน สายอักษรหนี้ Unicode ของคู่สำหรับ surrogate \uD840 \uDD1F .

สร้างสำนวน Unicode, บล็อค, หมวดหมู่ และ คุณสมบัติบนบาเธอร์เขียนด้วยโครงสร้าง \p และ \P ตามต้นฉบับของ Perl \p{ prop } ตรงกับว่ามีคุณสมบัติ prop ในอินพุต ขณะที่ \P{ prop } ไม่ตรงกับหากมีคุณสมบัตินี้ในอินพุต

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

โค้ดสคริปต์ จะถูกกำหนดโดยการใช้คำหน้ารูปแบบ Is เช่น IsHiragana หรือโดยใช้คำศัพท์ script (หรือรูปแบบสั้น sc) เช่น script=Hiragana หรือ sc=Hiragana

ชื่อโค้ดที่ Pattern สนับสนุนคือชื่อโค้ดที่ถูกต้องและถูกกำหนดโดย UnicodeScript.forName.

โครงสร้าง ถูกกำหนดด้วยคำขั้นต้น In เช่น InMongolian หรือโดยใช้คำศัพท์ block (หรือรูปแบบสั้น blk) เช่น block=Mongolian หรือ blk=Mongolian.

ชื่อโครงสร้างที่ Pattern สนับสนุนคือชื่อโครงสร้างที่ถูกต้องและถูกตั้งค่าโดย UnicodeBlock.forName.

ประเภท อาจถูกกำหนดด้วยคำขั้นต้นที่เลือกใช้งานได้ Is: ทั้ง \p{L} และ \p{IsL} ก็หมายถึงประเภทตัวเลือก Unicode ตัวเลือกเดียวกันกับรูปแบบและโครงสร้าง ประเภทสามารถถูกกำหนดได้โดยใช้คำศัพท์ general_category (หรือรูปแบบสั้น gc) เหมือน general_category=Lu หรือ gc=Lu.

ประเภทที่รองรับคือประเภทของ มาตรฐาน Unicodeในเวอร์ชันที่กำหนดไว้ Character class. ชื่อกลุ่มนี้คือ ถูกกำหนดใน Standard, ทั้งที่เป็นกฎหมายและข้อมูลเชิงอุปกรณ์

คุณสมบัติบนสองกำหนดด้วยคำขึ้นต้นIs ตามตัวอย่าง IsAlphabetic คุณสมบัติบนสองที่รองรับโดยPattern คือ

• Alphabetic
• อักษรวัตถุดิบ
• อักษร
• ตัวเล็ก
• ตัวใหญ่
• Titlecase
• Punctuation
• Control
• White_Space
• ตัวเลข
• ตัวเลขฐานหก
• จุดโค้ดที่ไม่มีตัวเลข
• ถูกกำหนด

กลุ่มตัวเลือกตัวอักษรที่กำหนดเอง และ กลุ่มตัวอักษร POSIX ตรงกับข้อเสนอแนะของ หน้าที่ C: คุณสมบัติความเข้ากันได้ ของ Unicode Regular Expression เมื่อ UNICODE_CHARACTER_CLASS flag ถูกกำหนด.

คลาส	การตรงกับ
\p{Lower}	ตัวเล็ก: \p{IsLowercase}
\p{Upper}	ตัวใหญ่: \p{IsUppercase}
\p{ASCII}	ทุกอักษร ASCII: [\x00-\x7F]
\p{Alpha}	ตัวอักษร: \p{IsAlphabetic}
\p{Digit}	อักษรตัวเลขทศนิยม: p{IsDigit}
\p{Alnum}	อักษรตัวเลข: [\p{IsAlphabetic}\p{IsDigit}]
\p{Punct}	อักษรตัวเลือก: p{IsPunctuation}
\p{Graph}	ตัวอักษรที่มองเห็นได้: [^\p{IsWhite_Space}\p{gc=Cc}\p{gc=Cs}\p{gc=Cn}]
\p{Print}	ตัวอักษรที่สามารถพิมพ์ได้: [\p{Graph}\p{Blank}&&[^\p{Cntrl}]]
\p{Blank}	ช่องว่างหรือ Tab: [\p{IsWhite_Space}&&[^\p{gc=Zl}\p{gc=Zp}\x0a\x0b\x0c\x0d\x85]]
\p{Cntrl}	อักษรตัวควบคุม: \p{gc=Cc}
\p{XDigit}	ตัวเลขฐาน 16: [\p{gc=Nd}\p{IsHex_Digit}]
\p{Space}	อักษรว่าง: \p{IsWhite_Space}
\d	รักษาตัวเลข: \p{IsDigit}
\D	ไม่ใช่ตัวเลข: [^\d]
\s	อักษรว่าง: \p{IsWhite_Space}
\S	อักษรที่ไม่ได้เป็นว่าง: [^\s]
\w	อักษรที่มีความหมาย: [\p{Alpha}\p{gc=Mn}\p{gc=Me}\p{gc=Mc}\p{Digit}\p{gc=Pc}]
\W	อักษรที่ไม่ใช่คำ: [^\w]

ประเภทที่มีความเป็นไปได้เหมือนวิธีการ boolean ที่ java.lang.Character methodname (ยกเว้นที่ถูกถอดออกใช้งาน) สามารถใช้ได้ผ่านรูปแบบ \p{ prop } ที่โฆษณาชื่อที่กำหนดมีชื่อเป็น javamethodname .

การเปรียบเทียบกับ Perl 5

เครื่องมือ Pattern ทำงานการเปรียบเทียบแบบเดิมที่ใช้ NFA-based กับการเปลี่ยนลำดับตามที่เกิดขึ้นใน Perl 5.

โครงสร้าง Perl ที่ไม่ได้รองรับโดยคลาสนี้:

• คลาสตัวเลือกที่กำหนดเอง (ตัวเลือก Unicode)

  \h ช่องว่างตัวเลือกแนวนอน

  \H ช่องว่างที่ไม่เป็นแนวนอน

  \v ระยะว่างแนวตั้ง

  \V ระยะว่างที่ไม่ได้แนวตั้ง

  \R หนึ่งในความคิดเห็นที่มีรูปแบบการแบ่งบรรทัด Unicode ใดก็ตาม \u000D\u000A|[\u000A\u000B\u000C\u000D\u0085\u2028\u2029]

  \X ตรวจสอบ Unicode กลุ่มตัวเลขที่ขยาย

• โครงสร้างการอ้างอิงที่กลับมา ( \g{ n } ) สำหรับกลุ่มคัดลอกที่ n^{เท่ากับ}กลุ่มคัดลอกที่มีชื่อ และ \g{ ชื่อ } สำหรับ กลุ่มคัดลอกที่มีชื่อ.

• การสร้างตัวเลือกตัวเลือกที่มีชื่อ, \N{ ชื่อ } สำหรับตัวเลือก Unicode โดยใช้ชื่อของมัน.

• โครงสร้างเงื่อนไข (?( เงื่อนไข ) X ) และ (?( เงื่อนไข ) X | Y ) ,

• โค้ดที่แทรกเข้ามาสร้าง (?{ โค้ด }) และ (??{ โค้ด }) ,

• รูปแบบคอมเมนต์ที่แทรกเข้ามา (?#comment) , และ

• การดำเนินงานก่อนหน้า \l \u , \L , และ \U .

โครงสร้างที่สนับสนุนโดยคลาสนี้แต่ไม่ได้สนับสนุนโดย Perl:

• การรวมกับการผสานของคลาสตัวเลือกและคลาสตัวเลือกตามที่กล่าว บน.

ความแตกต่างที่เห็นได้จาก Perl:

• ใน Perl, \1 ถึง \9 ถูกอ่านตามเป็นการอ้างอิงล่าสุด; ตัวเลขที่ซ่อนอยู่ด้วยการขึ้นต้นด้วยตัวเลือกมากกว่า 9 จะ ถูกบริหารในฐานะการอ้างอิงล่าสุดหากมีส่วนประกอบของสาขาอย่างน้อยนั้น แต่ถ้าไม่ได้ จะถูกอ่านตามเป็นการอ้างอิงสำหรับหน่วยเลขแปด ถ้าเป็นไปได้ ในกรณีนี้ คลาสการอ้างอิงเลขฐาน 8 ต้องเริ่มด้วยเลข 0 ในคลาสนี้ \1 ถึง \9 จะถูกอ่านตามตัวเลขเสมอ ตัวอย่างการอ้างอิง และมีจำนวนมากกว่านี้จะถูกอนุมัติในการอ้างอิงกลับมา น้อยที่สุดที่มี subexpressions แค่นั้นบริเวณนั้นใน regular expression คำสำคัญ หรือไม่ก็ตาม แต่จะถูกดูดมาจนกว่าจะเป็น น้อยกว่าหรือเท่ากับจำนวนกลุ่มที่มีอยู่แล้ว หรือมีหนึ่งตัวเลข

• Perl ใช้ตัวเลือก ` g ` เพื่อขอการตรวจสอบที่เริ่มต้นจากจุดที่การตรวจสอบล่าสุดเสร็จสิ้นไป ฟังก์ชันนี้จะได้รับการ cung cấpอย่างอัตโนมัติโดยคลาส `Matcher`: การเรียกใช้วิธี `find` หลายครั้งจะเริ่มต้นจากจุดที่การตรวจสอบล่าสุดเสร็จสิ้นไป หากไม่มีการรีเซ็ตตัวเลือกตรวจสอบนี้

• ใน Perl คำสั่งตั้งค่า flag ที่อยู่ในระดับสูงสุดของสมการจะต่อ tác độngต่อทั้งสมการนี้ ในคลาสนี้คำสั่งตั้งค่า flag จะมีผลในตอนที่มีอยู่ไม่ว่าจะอยู่ในระดับสูงสุดหรืออยู่ในกลุ่ม ในกรณีที่อยู่ในกลุ่ม คำสั่งตั้งค่า flag จะถูกกำหนดให้คืนค่าตามเดิมที่สิ้นสุดของกลุ่มเหมือนใน Perl

สำหรับการอธิบายเกี่ยวกับพฤติกรรมของโครงสร้างสมการที่มีความเป็นระบบกว่านี้โปรดดูที่ Mastering Regular Expressions, 3rd Edition, Jeffrey E. F. Friedl, O'Reilly and Associates, 2006.

ตั้งแต่

1.4

See Also:

String.split(String, int), String.split(String), Serialized Form

สรุปคอลัมน์ Field

คอลัมน์ Field

Modifier และ Type	Field และคำอธิบาย
static int	CANON_EQ ทำให้การเทียบเท่าทางมาตรฐานเป็นไปได้
static int	CASE_INSENSITIVE ทำให้การเทียบเท่าไม่สนใจตัวใหญ่ตัวเล็กเป็นไปได้
static int	COMMENTS อนุญาตให้มีช่องว่างและคอมเมนต์ในรูปแบบ
static int	DOTALL ทำให้รูปแบบเป็น dotall mode
static int	LITERAL สามารถแปลงตัวเลขเป็นตัวเลือกตามต้นฉบับได้
static int	MULTILINE สามารถใช้โหมดหลายบรรทัดได้
static int	UNICODE_CASE สามารถใช้การยืดหยุ่นตัวเลือกตาม Unicode ได้
static int	UNICODE_CHARACTER_CLASS สามารถใช้คลาสตัวเลือกที่กำหนดเองตาม Unicode ได้ คลาสตัวเลือก POSIX.
static int	UNIX_LINES เปิดใช้งานโหมดบรรทัด Unix

สรุปวิธี

วิธีการ

Modifier และ Type	วิธีและคำอธิบาย
static Pattern	compile(String regex) เข้ารหัสสายตรวจสอบที่กำหนดเป็นรูปแบบ
static Pattern	compile(String regex, int flags) ประมวลผลตัวเลขที่กำหนดให้เป็นรูปแบบด้วยส่วนหนึ่งที่กำหนด
int	flags() คืนค่าตัวเลขการเป็นตัวเลือกของรูปแบบนี้
Matcher	matcher(CharSequence input) สร้าง matcher ที่จะเป็นตัวเลือกในการใช้งานตามรูปแบบที่กำหนด
static boolean	matches(String regex, CharSequence input) ประมวลผลตัวเลขที่กำหนดให้เป็นรูปแบบและพยายามเป็นตัวเลือกในการใช้งานตามตัวเลขที่กำหนด
String	pattern() คืนค่ารูปแบบที่ใช้ในการประมวลผลจากการสร้างรูปแบบนี้
static String	quote(String s) คืนค่ารูปแบบที่เป็นตัวเลือก String สำหรับตัวเลือกที่กำหนด String.
String[]	split(CharSequence input) แยกลำดับข้อความที่กำหนดตามรูปแบบนี้
String[]	split(CharSequence input, int limit) แยกลำดับอินพุตที่กำหนดออกเป็นส่วนๆ ตามการเป็นไปตรงกับรูปแบบนี้
String	toString() คืนค่ารูปแบบตัวเลือกของรูปแบบนี้

วิธีที่สืบทอดมาจากคลาส java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

รายละเอียดฟิลด์

UNIX_LINES

public static final int UNIX_LINES

เปิดใช้งานโหมดบรรทัด Unix

ในโหมดนี้ มีการระบุเพียงแค่ตัวเลือกสำหรับการสิ้นสุดบรรทัด '\n' ในการทำงานของ . ^ และ $

โหมดบรรทัด Unix สามารถเปิดใช้งานได้ผ่านการระบุตัวเลือกซ่อนไว้ (?d)

See Also:

ค่าคงที่ของ Field

CASE_INSENSITIVE

public static final int CASE_INSENSITIVE

ทำให้การเปรียบเทียบรูปแบบโดยไม่แสดงถึงตัวเล็กหรือตัวใหญ่

โดยที่เริ่มต้น การเปรียบเทียบโดยไม่แสดงถึงตัวเล็กหรือตัวใหญ่จะถือว่ามีการเปรียบเทียบตัวเลือกเพียงแค่ตัวอักษรในชุดตัวอักษร US-ASCII แต่สามารถเปิดใช้การเปรียบเทียบโดยไม่แสดงถึงตัวเล็กหรือตัวใหญ่ที่รู้จัก Unicode ได้โดยกำหนดตัวเลือก UNICODE_CASE ร่วมกับตัวเลือกนี้

การเปรียบเทียบโดยไม่คำนึงถึงตัวใหญ่ตัวเล็กสามารถเปิดใช้งานได้ผ่านการระบุตัวเลือกตัวเลือก (?i)

การกำหนดตัวเลือกนี้อาจนำไปสู่การชำระค่าที่น้อยนิดเล็ก

See Also:

ค่าคงที่ของฟิลด์

คอมเมนต์

public static final int COMMENTS

อนุญาตให้มีช่องว่างและคอมเมนต์ในรูปแบบ

ในโหมดนี้จะไม่เน้นการสนับสนุนช่องว่าง และคอมเมนต์ที่ซ่อนไว้ที่ขึ้นต้นด้วย # จะถูกไม่เน้นจนจบบรรทัด

โหมดการแสดงคอมเมนต์สามารถเปิดใช้งานได้ผ่านการระบุสัญญาณตัวเลข (?x)

See Also:

ค่าคงที่ของฟิลด์

บรรทัดหลายบรรทัด

public static final int MULTILINE

สามารถใช้โหมดหลายบรรทัดได้

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

รูปแบบการทำงานแบบมากกว่าหนึ่งบรรทัดสามารถเปิดใช้งานได้ผ่านการระบุตัวเลือกที่ซ่อนไว้ (?m)

See Also:

ค่าคงที่ของฟิลด์

ตัวเลข

public static final int LITERAL

ทำให้การแปลงตัวเลขเป็นตัวอย่างของรูปแบบ

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

ตัวเลือก CASE_INSENSITIVE และ UNICODE_CASE ยังคงมีผลกระทบต่อการเปรียบเทียบเมื่อใช้ร่วมกับตัวเลือกนี้ ตัวเลือกอื่นๆ กลายเป็นเป็นเรียบง่าย

ไม่มีตัวเลือกตัวเลือกที่ซ่อนไว้สำหรับการเปิดใช้การแปลงตัวเลขเป็นตัวอย่าง

ตั้งแต่

1.5

See Also:

ค่าคงที่ของฟิลด์

DOTALL

public static final int DOTALL

เปิดโหมด dotall mode

ในโหมด dotall mode ตัวเลือก . จะตรงกับตัวอักษรใดก็ตาม รวมถึงตัวสะสมบรรทัด โดยปกติตัวเลือกนี้จะไม่ตรง บรรทัดที่จบลง

รูปแบบ Dotall mode สามารถเปิดใช้งานได้ผ่านการใช้งานตัวเลือกที่ซ่อนไว้ (?s) (ตัวเลือก s เป็นสัญญาณที่ใช้เรียก "รูปแบบเดียวบรรทัด" ซึ่งเป็นสิ่งที่เรียกใน Perl)

See Also:

ค่าคงที่ของฟิลด์

UNICODE_CASE

public static final int UNICODE_CASE

สามารถใช้การยืดหยุ่นตัวเลือกตาม Unicode ได้

เมื่อตั้งค่าตัวเลือกนี้ การเปรียบเทียบที่ไม่แสดงถึงตัวเล็กหรือตัวใหญ่จะดำเนินการในรูปแบบที่เปิดใช้งานโดยตัวเลือก `CASE_INSENSITIVE` ตรงกับมาตรฐาน Unicode โดยค่าเริ่มต้นเป็นการไม่แตกต่างระหว่างตัวใหญ่ตัวเล็ก การเปรียบเทียบนั้นเชื่อว่ามีตัวเลือกเพียงแค่ตัวอักษรในชุดตัวอักษร US-ASCII เท่านั้น ตรงกับกัน。

การเลือกใช้งานการย่อข้อความตามตัวเลือก Unicode สามารถเปิดได้ผ่านการใช้งานตัวเลือกที่แนบมาพร้อม (?u) 。

การกำหนดตัวเลือกนี้อาจทำให้เกิดความล่าช้าในการทำงานได้。

See Also:

ค่าคงที่ของฟิลด์

CANON_EQ

public static final int CANON_EQ

สามารถใช้ความเท่ากันของแบบแผนทางเทคนิค (canonical equivalence)

เมื่อตั้งค่าตัวเลือกนี้ ตัวอักษรสองตัวจะถูกมองว่าตรงกัน เมื่อ และเพียงเมื่อ การแปลงเต็มของรูปแบบมาตรฐานของมันตรงกัน ตัวอย่างเช่น ความเท่ากัน "a\u030A" จะตรงกับสายอักษร "\u00E5" เมื่อตั้งค่าตัวเลือกนี้ โดยค่าเริ่มต้น การเท่ากันนี้ไม่คำนึงถึงความเท่ากันตามมาตรฐาน

ไม่มีตัวอักษรสายติดอยู่เพื่อเปิดการเทียบเท่าทางมาตรฐาน

การกำหนดตัวเลือกนี้อาจส่งผลกระทบต่อความเร็วของการทำงานได้

See Also:

ค่าคงที่ของฟิลด์

UNICODE_CHARACTER_CLASS

public static final int UNICODE_CHARACTER_CLASS

เปิดใช้งานรูปแบบ Unicode ของ กลุ่มตัวเลือกตัวอักษรที่กำหนดเอง และ กลุ่มตัวเลือกตัวอักษร POSIX.

เมื่อตั้งค่าตัวเลือกนี้ จะใช้ (US-ASCII เท่านั้น) กลุ่มตัวเลือกตัวอักษรที่กำหนดเอง และ กลุ่มตัวเลือกตัวอักษร POSIX ตรงกับ มาตรฐาน Unicode Technical #18: Unicode Regular Expressionเขตที่ C: คุณสมบัติความสอดคล้อง.

รูปแบบ UNICODE_CHARACTER_CLASS สามารถเปิดใช้งานได้ผ่านการระบุตัวเลือกที่ซ่อนไว้ (?U)

การตั้งค่าตัวเลือกนี้หมายความว่ามีการใช้ Unicode_CASE ซึ่งหมายถึงมีการเปิดใช้งานการเล่นงานสำหรับ Unicode-aware case folding

การกำหนดตัวเลือกนี้อาจทำให้เกิดความล่าช้าในการทำงาน

ตั้งแต่

1.7

See Also:

ค่าคงที่ของฟิลด์

เมธอดรายละเอียด

เข้ารหัส

public static Pattern compile(String regex)

เข้ารหัสสายตรวจสอบที่กำหนดเป็นรูปแบบ

Parameters:

regex - ค่าที่จะถูกประมวลผล

Throws:

PatternSyntaxException - หากความรูปแบบของค่าไม่ถูกต้อง

compile

public static Pattern compile(String regex,
              int flags)

ประมวลผลตัวเลขที่กำหนดให้เป็นรูปแบบด้วยส่วนหนึ่งที่กำหนด

Parameters:

regex - ค่าตัวเลือกที่จะถูกประมวลผล

flags - ตัวเลือกการตรวจสอบ คือการผสานที่อาจมีรวม CASE_INSENSITIVE, MULTILINE, DOTALL, UNICODE_CASE, CANON_EQ, UNIX_LINES, LITERAL, UNICODE_CHARACTER_CLASS และ COMMENTS

ส่งคืน:

IllegalArgumentException - หากมีค่าบิตที่ไม่เป็นตัวเลขที่สอดคล้องกับตัวเลือกที่กำหนดให้มากกว่าใน flags

PatternSyntaxException - ถ้ารูปแบบที่ใช้ไม่ถูกต้อง

แบบแผน

public String pattern()

คืนค่ารูปแบบที่ใช้ในการประมวลผลจากการสร้างรูปแบบนี้

Returns:

แหล่งที่มาของรูปแบบนี้

toString

public String toString()

คืนค่าการแปลงเป็นตัวแปรสตริงของรูปแบบนี้ นี่คือรูปที่ใช้ในการสร้างรูปแบบนี้จากสายที่มีกำหนด

เข้าถึงภายนอก:

toString ในคลาส Object

Returns:

การแสดงผลลัพธ์เป็นตัวเลขของรูปแบบนี้

ตั้งแต่

1.5

matcher

public Matcher matcher(CharSequence input)

สร้าง matcher ที่จะเป็นตัวเลือกในการใช้งานตามรูปแบบที่กำหนด

Parameters:

input - รูปแบบตัวเลือกที่จะตรงกับตัวเลือกนี้

Returns:

ผู้ตรวจสอบใหม่สำหรับรูปแบบนี้

flags

public int flags()

คืนค่าตัวเลขการเป็นตัวเลือกของรูปแบบนี้

Returns:

ตัวเลือกการเข้ารหัสที่ระบุไว้เมื่อรูปแบบนี้ถูกเข้ารหัส

เท็ษ

public static boolean matches(String regex,
              CharSequence input)

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

การเรียกใช้วิธีที่สะดวกนี้แบบ

 Pattern.matches(regex, input);

สมมติว่ามันมีพฤติกรรมเหมือนกับสมาการที่

 Pattern.compile(regex).matcher(input).matches()

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

Parameters:

regex - ความคิดเห็นที่จะถูกคอมไพล์

input - รูปแบบตัวเลือกที่จะตรงกับตัวเลือกนี้

ส่งคืน:

PatternSyntaxException - ถ้ารูปแบบที่ใช้ไม่ถูกต้อง

split

public String[] split(CharSequence input,
             int limit)

แยกลำดับข้อความที่กำหนดตามรูปแบบนี้

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

พารามิเตอร์ limit ควบคุมจำนวนครั้งที่รูปแบบถูกใช้งาน ดังนั้นจึงส่งผลต่อความยาวของอายุที่ได้ หาก limit n มากกว่าศูนย์ รูปแบบจะถูกใช้งานเพียงไม่เกิน n - 1 ครั้ง ความยาวของอายุจะไม่มากกว่า n และส่วนสุดของอายุจะมีส่วนที่เหลือของลำดับเข้ามา หลังจากที่มีการตรงกับเส้นแยกสุดท้าย หาก n ถ้ามีค่าต่ำกว่าหรือเท่ากับศูนย์ จะใช้รูปแบบตามต่อไปนี้เป็นจำนวนครั้งที่เท่ากับ ทำได้และอาเรย์สามารถมีความยาวใดก็ได้ หาก n เป็นศูนย์ รูปแบบจะถูกใช้งานเพียงใดเพียงนั้น ตัวเลือกสามารถ มีความยาวใดก็ได้ และสามารถข้ามสายสตริงว่างที่อยู่ต่อท้ายได้

การส่งออก "boo:and:foo" ตัวอย่างนี้จะให้ผลลัพธ์ดังต่อไป ด้วยค่าพารามิเตอร์เหล่านี้:

Regex	Limit	ผลลัพธ์
:	2	{ "boo", "and:foo" }
:	5	{ "boo", "and", "foo" }
:	-2	{ "boo", "and", "foo" }
o	5	{ "b", "", ":and:f", "", "" }
o	-2	{ "b", "", ":and:f", "", "" }
o	0	{ "b", "", ":and:f" }

Parameters:

input - เรียงข้อความที่จะแยก

limit - ที่เรียกร้องตามที่กล่าวไป

Returns:

อาเรย์ของสตริงที่คำนวณได้จากการแยกเรียงข้อความตามตัวอย่างที่กำหนดในโมเดลนี้

แยก

public String[] split(CharSequence input)

แยกลำดับข้อความที่กำหนดตามรูปแบบนี้

วิธีนี้ทำงานเหมือนเมื่อเรียกวิธี split ที่มีสองพารามิเตอร์โดยใช้คอลเลกชันข้อมูลที่กำหนดและพารามิเตอร์ limit เป็นศูนย์ ดังนั้น สตริงว่างที่อยู่ต่อท้ายจึงไม่ถูกนำเสนอในอาเรย์ผลลัพธ์

การ輸入 "boo:and:foo" ตัวอย่างนี้จะให้ผลลัพธ์ดังต่อไป ด้วยสมการเหล่านี้:

Regex	ผลลัพธ์
:	{ "boo", "and", "foo" }
o	{ "b", "", ":and:f" }

Parameters:

input - เรียงข้อความที่จะถูกแยก

Returns:

อาเรย์ของสตริงที่คำนวณได้จากการแยกเรียงข้อความดังกล่าวตามการเปิดปิดที่ตรงกับรูปแบบนี้

quote

public static String quote(String s)

คืนค่ารูปแบบที่เป็นตัวเลือก String สำหรับตัวเลือกที่กำหนด String.

วิธีนี้สร้าง String ที่สามารถใช้เพื่อสร้าง Pattern ที่จะตรงกับคำที่มีตัวเลือกในตัวเมาตรวางแผน s ตามที่เป็นรูปแบบตรงตัว

ตัวเลือกหรือรูปแบบการหนีหน้าในคำที่ใส่เข้ามาจะไม่มีความหมายพิเศษ

Parameters:

s - ตัวเลือกที่จะถูกตั้งค่าให้เป็นตัวเลือกที่เป็นคำศัพท์จริง

Returns:

การแทนที่ตัวเลือกที่เป็นคำศัพท์จริง

ตั้งแต่

1.5