java正則語法或

1. java正則表達式中「或」表示

也就是用正則來匹配 fund="數字" stock="數字" 這乎沖些內容，謹岩並且捕捉其中的數字的意思，對吧

varreg=/s+?(?:fund|stock)="(d+)"/gi;

這是親測結果歲晌殲：

可以在這里在線測試：

在線正則表達式測試

2. java正則表達式的寫法

方法/步驟
Java正則表達式正則表達式的語法知識：Java支持Perl 5 正則表達式語法的一個子集。一個重要的問題是Java沒有正則表達式常量,而是使用簡單的老的字元串常量代替的。這就意味著，你需要一個的額外等級的轉換。例如，正則表達式\s+不得不表示為「\\s+」這樣的字元串。轉義序列（Escapesequences）：

\

引用後面的元字元（metacharacter） (例如 \. 匹配.) 。

\Q

引用後面所有的元字元直到遇到 \E 。

\E

停止引用元字元 (和 \Q 開始配合使用)。

\\

一個文字反斜杠\。

\uhhhh

Unicode字元 U+hhhh (16進制)。

\xhh

Unicode字元 U+00hh (16進制)。

\cx

ASCII的控制字元 ^x (比如 \cH 可以是 ^H, U+0008)。

\a

ASCII bell 字元 (U+0007)。

\e

ASCII ESC字元r (U+001b)。

\f
ASCII[size=17.280000686645508px]換頁字元 (U+000c)。
\n

ASCII 換行字元 (U+000a)。

\r

ASCII 回車字元 (U+000d)。

\t

ASCII tab 字元 (U+0009)。

字元類（Characterclasses）使用集合運算來構建字元類是完全可行的：

[abc]

任意 a, b, 或 c字元。(枚舉)

[a-c]

任意a-c范圍的字元，即任意 a, b,或 c。 (范圍)

[^abc]
除了a, b, 或 c以外的任意字元。 (否定)

[[a-f][0-9]]

任意字元，是a-f，或者0-9。 (聯合)

[[a-z]&&[jkl]]

同時滿足兩個范圍的任意字元。 (交叉)

大多數時候，構造的字元類更有用：

\d
任意數字字元。

\D
任意非數字字元。

\s
任意空白字元

\S
任意非空白字元

\w

Any word character.

\W

Any non-word character.

\p{NAME}

Any character in the class with the given NAME.

\P{NAME}

Any character not in the named class.

各種命名的類：
· Unicodecategory names, prefixed by Is. For example \p{IsLu} forall uppercase letters.
· POSIX class names. These are'Alnum', 'Alpha', 'ASCII', 'Blank', 'Cntrl', 'Digit', 'Graph', 'Lower','Print', 'Punct', 'Upper', 'XDigit'.
· Unicode block names, as usedby forName(String) prefixedby In. For example \p{InHebrew} for all characters in the Hebrewblock.
· Character method names. These areall non-deprecated methods from Character whosename starts with is, but with the is replaced by java. Forexample,\p{javaLowerCase}.

定量修飾符（Quantifiers）
定量修飾符匹配一些數量的之前提到的語法表達式。

*

0個或更多

?

0個或1個

+

1個或更多

{n}

確切的n個

{n,}

至少n個

{n,m}

至少n個，不超過m個

定量修飾符默認是貪婪的，意思是它將匹配最長可能的輸入序列。也有不貪婪（又稱懶惰）的定量修飾符，它匹配最小可能性的輸入序列。他們在貪婪方面是一樣的，除了後面的?:

*?

Zero or more (non-greedy).

??

Zero or one (non-greedy).

+?

One or more (non-greedy).

{n}?

Exactly n (non-greedy).

{n,}?

At least n (non-greedy).

{n,m}?

At least n but not more than m (non-greedy).

定量修飾符默認允許回溯。也可以避免定量修飾符的回溯。他們除了在後面的+:外，都是一樣的。

*+

Zero or more (possessive).

?+

Zero or one (possessive).

++

One or more (possessive).

{n}+

Exactly n (possessive).

{n,}+

At least n (possessive).

{n,m}+

At least n but not more than m (possessive).

零寬斷言（Zero-widthassertions）

^

At beginning of line.

$

At end of line.

\A

At beginning of input.

\b

At word boundary.

\B

At non-word boundary.

\G

At end of previous match.

\z

At end of input.

\Z

At end of input, or before newline at end.

四處查看斷言（Look-aroundassertions）
四處查看斷言主張does(positive)的子模式或doesn't(negative)匹配在(look-ahead)後面或者(look-behind)前面【也就是從當前位置向前或向後查找】不包括包含的匹配文字。向後查找模式可能匹配的最大長度必須不是不受控制的。

(?=a)

Zero-width positive look-ahead.

(?!a)

Zero-width negative look-ahead.

(?<=a)

Zero-width positive look-behind.

(?<!a)

Zero-width negative look-behind.

分組（Groups）

(a)

A capturing group.

(?:a)

A non-capturing group.

(?>a)

An independent non-capturing group. (The first match of the subgroup is the only match tried.)

\n

The text already matched by capturing group n.

查看group（）的詳細信息來了解如何捕捉分組是有限的和可訪問的。
運算符（Operators）

ab

Expression a followed by expression b.

a|b

Either expression a or expression b.

標記（Flags）

(?dimsux-dimsux:a)

Evaluates the expression a with the given flags enabled/disabled.

(?dimsux-dimsux)

Evaluates the rest of the pattern with the given flags enabled/disabled.

標記：

i

CASE_INSENSITIVE

case insensitive matching

d

UNIX_LINES

only accept '\n' as a line terminator

m

MULTILINE

allow ^ and $ to match beginning/end of any line

s

DOTALL

allow . to match '\n' ("s" for "single line")

u

UNICODE_CASE

enable Unicode case folding

x

COMMENTS

allow whitespace and comments

任何一個flags的集合可能是空的。例如，(?i-m)可能打開字元敏感，可能關閉多線模式，(?i)可能打開字元敏感，(?-m)可能關閉多線模式。
注意，在Android中，UNICODE字元永遠打開：字元不敏感的匹配永遠是unicode的。
還有兩個另外的標記不可設定的機制：CANON_EQ和LITERAL。
在Android中試圖使用CANON_EQ會拋出異常。

實現注釋（Implementationnotes）
在Android中的正則表達式實現是由ICU提供的。正則表達式的符號主要是在其他Java語言實現的超集。這就意味著目前的應用程序將如預期的正常工作。但是也有很小的可能性事，Android 可以接受的正則表達式，不能被其他實現所接受。有時候，Android將識別一個簡單、特例的、能被更有效處理的正則表達式。這對String中的便利的方法和Pattern中的方法都適用。

END
注意事項
認真學習

溫馨提示：親 答題不易解題更難 您的支持是我繼續答題的動力 麻煩採納 謝謝

3. java 正則表達式怎麼用啊

建議自己查J2SE 的 API java.util.regex Pattern
×××××××××××××××××××××××××××××××××××××××××××××
我給你貼出來
×××××××××××××××××××××××××××××××××××××××××××××

public final class Patternextends Objectimplements Serializable正則表達式的編譯表示形式。

指定為字元串的正則表達式必須首先被編譯為此類的實例。然後，可將得到的模式用於創建 Matcher 對象，依照正則表達式，該對象可以與任意字元序列匹配。執行匹配所涉及的所有狀態都駐留在匹配器中，所以多個匹配器可以共享同一模式。

因此，典型的調用順序是

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
\\ 反斜線字元
\0n 帶有八進制值 0 的字元 n (0 <= n <= 7)
\0nn 帶有八進制值 0 的字元 nn (0 <= n <= 7)
\0mnn 帶有八進制值 0 的字元 mnn（0 <= m <= 3、0 <= n <= 7）
\xhh 帶有十六進制值 0x 的字元 hh
\uhhhh 帶有十六進制值 0x 的字元 hhhh
\t 製表符 ('\u0009')
\n 新行（換行）符 ('\u000A')
\r 回車符 ('\u000D')
\f 換頁符 ('\u000C')
\a 報警 (bell) 符 ('\u0007')
\e 轉義符 ('\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} 空格或製表符：[ \t]
\p{Cntrl} 控制字元：[\x00-\x1F\x7F]
\p{XDigit} 十六進制數字：[0-9a-fA-F]
\p{Space} 空白字元：[ \t\n\x0B\f\r]

java.lang.Character 類（簡單的 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{InGreek} Greek 塊（簡單塊）中的字元
\p{Lu} 大寫字母（簡單類別）
\p{Sc} 貨幣符號
\P{InGreek} 所有字元，Greek 塊中的除外（否定）
[\p{L}&&[^\p{Lu}]] 所有字母，大寫字母除外（減去）

邊界匹配器
^ 行的開頭
$ 行的結尾
\b 單詞邊界
\B 非單詞邊界
\A 輸入的開頭
\G 上一個匹配的結尾
\Z 輸入的結尾，僅用於最後的結束符（如果有的話）
\z 輸入的結尾

Greedy 數量詞
X? X，一次或一次也沒有
X* X，零次或多次
X+ X，一次或多次
X{n} X，恰好 n 次
X{n,} X，至少 n 次
X{n,m} X，至少 n 次，但是不超過 m 次

Reluctant 數量詞
X?? X，一次或一次也沒有
X*? X，零次或多次
X+? X，一次或多次
X{n}? X，恰好 n 次
X{n,}? X，至少 n 次
X{n,m}? X，至少 n 次，但是不超過 m 次

Possessive 數量詞
X?+ X，一次或一次也沒有
X*+ X，零次或多次
X++ X，一次或多次
X{n}+ X，恰好 n 次
X{n,}+ X，至少 n 次
X{n,m}+ X，至少 n 次，但是不超過 m 次

Logical 運算符
XY X 後跟 Y
X|Y X 或 Y
(X) X，作為捕獲組

Back 引用
\n 任何匹配的 nth 捕獲組

引用
\ Nothing，但是引用以下字元
\Q Nothing，但是引用所有字元，直到 \E
\E Nothing，但是結束從 \Q 開始的引用

特殊構造（非捕獲）
(?:X) X，作為非捕獲組
(?idmsux-idmsux) Nothing，但是將匹配標志由 on 轉為 off
(?idmsux-idmsux:X) X，作為帶有給定標志 on - off 的非捕獲組
(?=X) X，通過零寬度的正 lookahead
(?!X) X，通過零寬度的負 lookahead
(?<=X) X，通過零寬度的正 lookbehind
(?<!X) X，通過零寬度的負 lookbehind
(?>X) X，作為獨立的非捕獲組

--------------------------------------------------------------------------------

反斜線、轉義和引用
反斜線字元 ('\') 用於引用轉義構造，如上表所定義的，同時還用於引用其他將被解釋為非轉義構造的字元。因此，表達式 \\ 與單個反斜線匹配，而 \{ 與左括弧匹配。

在不表示轉義構造的任何字母字元前使用反斜線都是錯誤的；它們是為將來擴展正則表達式語言保留的。可以在非字母字元前使用反斜線，不管該字元是否非轉義構造的一部分。

根據 Java Language Specification 的要求，Java 源代碼的字元串中的反斜線被解釋為 Unicode 轉義或其他字元轉義。因此必須在字元串字面值中使用兩個反斜線，表示正則表達式受到保護，不被 Java 位元組碼編譯器解釋。例如，當解釋為正則表達式時，字元串字面值 "\b" 與單個退格字元匹配，而 "\\b" 與單詞邊界匹配。字元串字面值 "\(hello\)" 是非法的，將導致編譯時錯誤；要與字元串 (hello) 匹配，必須使用字元串字面值 "\\(hello\\)"。

字元類
字元類可以出現在其他字元類中，並且可以包含並集運算符（隱式）和交集運算符 (&&)。並集運算符表示至少包含其某個操作數類中所有字元的類。交集運算符表示包含同時位於其兩個操作數類中所有字元的類。

字元類運算符的優先順序如下所示，按從最高到最低的順序排列：

1 字面值轉義 \x
2 分組 [...]
3 范圍 a-z
4 並集 [a-e][i-u]
5 交集 [a-z&&[aeiou]]

注意，元字元的不同集合實際上位於字元類的內部，而非字元類的外部。例如，正則表達式 . 在字元類內部就失去了其特殊意義，而表達式 - 變成了形成元字元的范圍。

行結束符
行結束符 是一個或兩個字元的序列，標記輸入字元序列的行結尾。以下代碼被識別為行結束符：

新行（換行）符 ('\n')、
後面緊跟新行符的回車符 ("\r\n")、
單獨的回車符 ('\r')、
下一行字元 ('\u0085')、
行分隔符 ('\u2028') 或
段落分隔符 ('\u2029)。
如果激活 UNIX_LINES 模式，則新行符是惟一識別的行結束符。

如果未指定 DOTALL 標志，則正則表達式 . 可以與任何字元（行結束符除外）匹配。

默認情況下，正則表達式 ^ 和 $ 忽略行結束符，僅分別與整個輸入序列的開頭和結尾匹配。如果激活 MULTILINE 模式，則 ^ 在輸入的開頭和行結束符之後（輸入的結尾）才發生匹配。處於 MULTILINE 模式中時，$ 僅在行結束符之前或輸入序列的結尾處匹配。

組和捕獲
捕獲組可以通過從左到右計算其開括弧來編號。例如，在表達式 ((A)(B(C))) 中，存在四個這樣的組：

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

組零始終代表整個表達式。

之所以這樣命名捕獲組是因為在匹配中，保存了與這些組匹配的輸入序列的每個子序列。捕獲的子序列稍後可以通過 Back 引用在表達式中使用，也可以在匹配操作完成後從匹配器檢索。

與組關聯的捕獲輸入始終是與組最近匹配的子序列。如果由於量化的緣故再次計算了組，則在第二次計算失敗時將保留其以前捕獲的值（如果有的話）例如，將字元串 "aba" 與表達式 (a(b)?)+ 相匹配，會將第二組設置為 "b"。在每個匹配的開頭，所有捕獲的輸入都會被丟棄。

以 (?) 開頭的組是純的非捕獲 組，它不捕獲文本，也不針對組合計進行計數。

4. java 正則表達式是什麼

不同情況下的正則表達式：

• 匹配首尾空格的正則表達式：(^s*)|(s*$)。

• 匹配html標簽的正則表達式：<(.*)>(.*)</(.*)>|<(.*)/>。

• 配空行的正則表達式： [s| ]* 。

• 整數或者小數：^[0-9]+.{0,1}[0-9]{0,2}$。

• 只能輸入數字："^[0-9]*$"。

• 只能輸入n位的數字："^d{n}$"。

• 只能輸入至少n位的數字："^d{n,}$"。

• 只能輸入m~n位的數字：。"^d{m,n}$"

• 只能輸入零和非零開頭的數字："^(0|[1-9][0-9]*)$"。

• 只能輸入有兩位小數的正實數："^[0-9]+(.[0-9]{2})?$"。

• 只能輸入有1~3位小數的正實數："^[0-9]+(.[0-9]{1,3})?$"。

• 只能輸入非零的正整數："^+?[1-9][0-9]*$"。

• 只能輸入非零的負整數："^-[1-9][]0-9"*$。

• 只能輸入長度為3的字元："^.{3}$"。

• 只能輸入由26個英文字母組成的字元串："^[A-Za-z]+$"。

• 只能輸入由26個大寫英文字母組成的字元串："^[A-Z]+$"。

• 只能輸入由26個小寫英文字母組成的字元串："^[a-z]+$"。

• 只能輸入由數字和26個英文字母組成的字元串："^[A-Za-z0-9]+$"。

• 只能輸入由數字、26個英文字母或者下劃線組成的字元串："^w+$"。

• 驗證用戶密碼："^[a-zA-Z]w{5,17}$"正確格式為：以字母開頭，長度在6~18之間，只能包含字元、數字和下劃線。

• 驗證是否含有^%&',;=?$"等字元："[^%&',;=?$x22]+"。

• 只能輸入漢字："^[u4e00-u9fa5]{0,}$"。

• 驗證Email地址："^w+([-+.]w+)*@w+([-.]w+)*.w+([-.]w+)*$"。

• 驗證一年的12個月："^(0?[1-9]|1[0-2])$"正確格式為："01"～"09"和"1"～"12"。

• 驗證一個月的31天："^((0?[1-9])|((1|2)[0-9])|30|31)$"正確格式為；"01"～"09"和"1"～"31"。

• 匹配中文字元的正則表達式： [u4e00-u9fa5]。

• 匹配雙位元組字元(包括漢字在內)：[^x00-xff]。

• 應用：計算字元串的長度（一個雙位元組字元長度計2，ASCII字元計1）String.prototype.len=function(){returnthis.replace(/[^x00-xff]/g,"aa").length;}。

5. java正則表達式

1、Java 正則表達式：

正則表達式定義了字元串的模式。正則表達式可以用來搜索、編輯或處理文本。正則表達式並不僅限於某一種語言，但是在困桐每種語言中有細微的差別。

2、正則表達式實例

一個字元串其實就是一個簡單的正則表達式，例如 Hello World 正則表達式匹配 Hello World 字元串。.（點號）也是一個正則表達式，它匹配任何一個字元如：a 或 1。

3、java.util.regex 包主要包括以下三個類：

（1）Pattern 類：

pattern 對象是一個正則表達式的編譯表示。Pattern 類沒有公共構造方法。要創建一個 Pattern 對象，你必須首先調用其公共靜態編譯方法，它返回一個 Pattern 對象。該方法接受一個正則表達式作為它的第一個參數。

（2）Matcher 類頌汪：

Matcher 對象是對輸入字元串進行解釋和匹配操作的引擎。與Pattern 類一樣，Matcher 也沒有公野尺仔共構造方法。你需要調用 Pattern 對象的 matcher 方法來獲得一個 Matcher 對象。

（3）PatternSyntaxException：

PatternSyntaxException 是一個非強制異常類，它表示一個正則表達式模式中的語法錯誤。

6. 請問JAVA中正則表達式匹配怎麼實現的!

Java中正則表達式匹配的語法規則：

packageorg.luosijin.test;
importjava.util.regex.Matcher;
importjava.util.regex.Pattern;

/**
*正則表達式
*@versionV5.0
*@authorAdmin
*@date2015-7-25
*/
publicclassRegex{

/**
*@paramargs
*@authorAdmin
*@date2015-7-25
*/

publicstaticvoidmain(String[]args){
Patternpattern=Pattern.compile("b*g");
Matchermatcher=pattern.matcher("bbg");
System.out.println(matcher.matches());
System.out.println(pattern.matches("b*g","bbg"));
//驗證郵政編碼
System.out.println(pattern.matches("[0-9]{6}","200038"));
System.out.println(pattern.matches("//d{6}","200038"));
//驗證電話號碼
System.out.println(pattern.matches("[0-9]{3,4}//-?[0-9]+","02178989799"));
getDate("Nov10,2009");
charReplace();
//驗證身份證:判斷一個字元串是不是身份證號碼，即是否是15或18位數字。
System.out.println(pattern.matches("^//d{15}|//d{18}$","123456789009876"));
getString("D:/dir1/test.txt");
getChinese("welcometochina,江西奉新,welcome,你!");
validateEmail("[email protected]");
}
/**
*日期提取:提取出月份來
*@paramstr
*@authorAdmin
*@date2015-7-25
*/
publicstaticvoidgetDate(Stringstr){
StringregEx="([a-zA-Z]+)|//s+[0-9]{1,2},//s*[0-9]{4}";
Patternpattern=Pattern.compile(regEx);
Matchermatcher=pattern.matcher(str);
if(!matcher.find()){
System.out.println("日期格式錯誤!");
return;
}
System.out.println(matcher.group(1));//分組的索引值是從1開始的，所以取第一個分組的方法是m.group(1)而不是m.group(0)。
}
/**
*字元替換:本實例為將一個字元串中所有包含一個或多個連續的「a」的地方都替換成「A」。
*
*@authorAdmin
*@date2015-7-25
*/
publicstaticvoidcharReplace(){
Stringregex="a+";
Patternpattern=Pattern.compile(regex);
Matchermatcher=pattern.matcher("okaaaaLetmeAseeaaaaabooa");
Strings=matcher.replaceAll("A");
System.out.println(s);
}
/**
*字元串提取
*@paramstr
*@authorAdmin
*@date2015-7-25
*/
publicstaticvoidgetString(Stringstr){
Stringregex=".+/(.+)$";
Patternpattern=Pattern.compile(regex);
Matchermatcher=pattern.matcher(str);
if(!matcher.find()){
System.out.println("文件路徑格式不正確！");
return;
}
System.out.println(matcher.group(1));
}
/**
*中文提取
*@paramstr
*@authorAdmin
*@date2015-7-25
*/
publicstaticvoidgetChinese(Stringstr){
Stringregex="[//u4E00-//u9FFF]+";//[//u4E00-//u9FFF]為漢字
Patternpattern=Pattern.compile(regex);
Matchermatcher=pattern.matcher(str);
StringBuffersb=newStringBuffer();
while(matcher.find()){
sb.append(matcher.group());
}
System.out.println(sb);
}
/**
*驗證Email
*@paramemail
*@authorAdmin
*@date2015-7-25
*/
publicstaticvoidvalidateEmail(Stringemail){
Stringregex="[0-9a-zA-Z]+@[0-9a-zA-Z]+//.[0-9a-zA-Z]+";
Patternpattern=Pattern.compile(regex);
Matchermatcher=pattern.matcher(email);
if(matcher.matches()){
System.out.println("這是合法的Email");
}else{
System.out.println("這是非法的Email");
}
}
}

7. java正則表達式語法中的標簽是什麼呢是類似\\S,\\d這樣的東西嗎

標簽是什麼,在我的理解里;標簽是一個功能實現的最小單位工具;
比如html里的一系列標簽,功能具體化就是標簽
那在java正則表達式語法中的標簽是什麼呢?
各種各樣樣的定義就是標簽,它們組合起來就是正則表達式;
舉個例子,字元類

[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]（減去）
這裡面[],字母,^,-,&&就是標簽,也是元素;當然[]相當於房子,裡面的組合體相當於一個人,它們整體就是人住在房子里,標簽是什麼就用看你是怎麼理解的了

8. java 中怎麼用正則表達式刪除"[ " 或 " ]" 一些特殊字元 先謝了

例子如下：
String pattern = "([-+*/^()\\]\\[])";
String test = "1237019830+32[89-234]234";
System.out.println("------test1=["+test+"]");
test = test.replaceAll(pattern, "");
System.out.println("------test2=["+test+"]");
這個應該能夠滿足你的要求，已測試。
運行結果為：
------test1=[1237019830+32[89-234]234]
------test2=[12370198303289234234]

9. Java 兩個正則表達式 取 或應該怎麼寫

Pattern pattern = Pattern.compile ("(levelsource=000000000_0&pvareaid=[0-9]{6}|greylink)\脊碼畝模氏">(.*?)<櫻森/a>");