2. 程式人生 > >JAVA 正則表示式 （超詳細）

JAVA 正則表示式 （超詳細）

阿新 • • 發佈：2019-01-24

在Sun的Java JDK 1.40版本中，Java自帶了支援正則表示式的包，本文就拋磚引玉地介紹瞭如何使用java.util.regex包。

　　可粗略估計一下，除了偶爾用Linux的外，其他Linu x使用者都會遇到正則表示式。正則表示式是個極端強大工具，而且在字串模式-匹配和字串模式-替換方面富有彈性。在Unix世界裡，正則表示式幾乎沒有什麼限制，可肯定的是，它應用非常之廣泛。

　　正則表示式的引擎已被許多普通的Unix工具所實現，包括grep，awk，vi和Emacs等。此外，許多使用比較廣泛的指令碼語言也支援正則表示式，比如Python，Tcl，JavaScript，以及最著名的Perl。

　　我很早以前就是個Perl方面的黑客，如果你和我一樣話，你也會非常依賴你手邊的這些強大的text-munging工具。近幾年來，像其他程式開發者一樣，我也越來越關注Java的開發。

　　Java作為一種開發語言，有許多值得推薦的地方，但是它一直以來沒有自帶對正則表示式的支援。直到最近，藉助於第三方的類庫，Java開始支援正則表示式，但這些第三方的類庫都不一致、相容性差，而且維護程式碼起來很糟糕。這個缺點，對我選擇Java作為首要的開發工具來說，一直是個巨大的顧慮之處。

　　你可以想象，當我知道Sun的Java JDK 1.40版本包含了java.util.regex(一個完全開放、自帶的正則表示式包)時，是多麼的高興!很搞笑的說，我花好些時間去挖掘這個被隱藏起來的寶石。我非常驚奇的是，Java這樣的一個很大改進(自帶了java.util.regex包)為什麼不多公開一點呢?!

　　最近，Java雙腳都跳進了正則表示式的世界。java.util.regex包在支援正則表達也有它的過人之處，另外Java也提供詳細的相關說明文件。使得朦朦朧朧的regex神祕景象也慢慢被撥開。有一些正則表示式的構成(可能最顯著的是，在於糅合了字元類庫)在Perl都找不到。

　　在regex包中，包括了兩個類，Pattern(模式類)和Matcher(匹配器類)。Pattern類是用來表達和陳述所要搜尋模式的物件，Matcher類是真正影響搜尋的物件。另加一個新的例外類，PatternSyntaxException，當遇到不合法的搜尋模式時，會丟擲例外。

　　即使對正則表示式很熟悉，你會發現，通過java使用正則表示式也相當簡單。要說明的一點是，對那些被Perl的單行匹配所寵壞的Perl狂熱愛好者來說，在使用java的regex包進行替換操作時，會比他們所以前常用的方法費事些。

　　本文的侷限之處，它不是一篇正則表示式用法的完全教程。如果讀者要對正則表達進一步瞭解的話，推薦閱讀Jeffrey Frieldl的Mastering Regular Expressions，該書由O’Reilly出版社出版。我下面就舉一些例子來教讀者如何使用正則表示式，以及如何更簡單地去使用它。

　　設計一個簡單的表示式來匹配任何電話號碼數字可能是比較複雜的事情，原因在於電話號碼格式有很多種情況。所有必須選擇一個比較有效的模式。比如:(212) 555-1212， 212-555-1212和212 555 1212，某些人會認為它們都是等價的。

　　首先讓我們構成一個正則表示式。為簡單起見，先構成一個正則表示式來識別下面格式的電話號碼數字:(nnn)nnn-nnnn。

　　第一步，建立一個pattern物件來匹配上面的子字串。一旦程式執行後，如果需要的話，可以讓這個物件一般化。匹配上面格式的正則表達可以這樣構成:(/d{3})/s/d{3}-/d{4}，其中/d單字元型別用來匹配從0到9的任何數字，另外{3}重複符號，是個簡便的記號，用來表示有3個連續的數字位，也等效於(/d/d/d)。/s也另外一個比較有用的單字元型別，用來匹配空格，比如Space鍵，tab鍵和換行符。

　　是不是很簡單?但是，如果把這個正則表示式的模式用在java程式中，還要做兩件事。對java的直譯器來說，在反斜線字元(/)前的字元有特殊的含義。在java中，與regex有關的包，並不都能理解和識別反斜線字元(/)，儘管可以試試看。但為避免這一點，即為了讓反斜線字元(/)在模式物件中被完全地傳遞，應該用雙反斜線字元(/)。此外圓括號在正則表達中兩層含義，如果想讓它解釋為字面上意思(即圓括號)，也需要在它前面用雙反斜線字元(/)。也就是像下面的一樣:

　　//(//d{3}//)//s//d{3}-//d{4}

　　現在介紹怎樣在java程式碼中實現剛才所講的正則表示式。要記住的事，在用正則表示式的包時，在你所定義的類前需要包含該包，也就是這樣的一行:

　　import java.util.regex.*;

　　下面的一段程式碼實現的功能是，從一個文字檔案逐行讀入，並逐行搜尋電話號碼數字，一旦找到所匹配的，然後輸出在控制檯。

　　BufferedReader in;

　　Pattern pattern = Pattern.compile("//(//d{3}//)//s//d{3}-//d{4}");

　　in = new BufferedReader(new FileReader("phone"));

　　String s;

　　while ((s = in.readLine()) != null)

　　{

　　Matcher matcher = pattern.matcher(s);

　　if (matcher.find())

　　{

　　System.out.println(matcher.group());

　　}

　　}

　　in.close();

　　對那些熟悉用Python或Javascript來實現正則表示式的人來說，這段程式碼很平常。在Python和Javascript這些語言中，或者其他的語言，這些正則表示式一旦明確地編譯過後，你想用到哪裡都可以。與Perl的單步匹配相比，看起來多多做了些工作，但這並不很費事。

　　find()方法，就像你所想象的，用來搜尋與正則表示式相匹配的任何目標字串，group()方法，用來返回包含了所匹配文字的字串。應注意的是，上面的程式碼，僅用在每行只能含有一個匹配的電話號碼數字字串時。可以肯定的說，java的正則表示式包能用在一行含有多個匹配目標時的搜尋。本文的原意在於舉一些簡單的例子來激起讀者進一步去學習java自帶的正則表示式包，所以對此就沒有進行深入的探討。

　　這相當漂亮吧! 但是很遺憾的是，這僅是個電話號碼匹配器。很明顯，還有兩點可以改進。如果在電話號碼的開頭，即區位號和本地號碼之間可能會有空格。我們也可匹配這些情況，則通過在正則表示式中加入/s?來實現，其中?元字元表示在模式可能有0或1個空格符。

　　第二點是，在本地號碼位的前三位和後四位數字間有可能是空格符，而不是連字號，更有勝者，或根本就沒有分隔符，就是7位數字連在一起。對這幾種情況，我們可以用(-|)?來解決。這個結構的正則表示式就是轉換器，它能匹配上面所說的幾種情況。在()能含有管道符|時，它能匹配是否含有空格符或連字元，而尾部的?元字元表示是否根本沒有分隔符的情況。

　　最後，區位號也可能沒有包含在圓括號內，對此可以簡單地在圓括號後附上?元字元，但這不是一個很好的解決方法。因為它也包含了不配對的圓括號，比如"(555" 或 "555)"。相反，我們可以通過另一種轉換器來強迫讓電話號碼是否帶有有圓括號:(/(/d{3}/)|/d{3})。如果我們把上面程式碼中的正則表示式用這些改進後的來替換的話，上面的程式碼就成了一個非常有用的電話號碼數字匹配器:

　　Pattern pattern =

　　Pattern.compile("(//(//d{3}//)|//d{3})//s?//d{3}(-|)?//d{4}");

　　可以確定的是，你可以自己試著進一步改進上面的程式碼。

　　現在看看第二個例子，它是從Friedl的中改編過來的。其功能是用來檢查文字檔案中是否有重複的單詞，這在印刷排版中會經常遇到，同樣也是個語法檢查器的問題。

　　匹配單詞，像其他的一樣，也可以通過好幾種的正則表示式來完成。可能最直接的是/b/w+/b，其優點在於只需用少量的regex元字元。其中/w元字元用來匹配從字母a到u的任何字元。+元字元表示匹配匹配一次或多次字元，/b元字元是用來說明匹配單詞的邊界，它可以是空格或任何一種不同的標點符號(包括逗號，句號等)。

　　現在，我們怎樣來檢查一個給定的單詞是否被重複了三次?為完成這個任務，需充分利用正則表示式中的所熟知的向後掃描。如前面提到的，圓括號在正則表示式中有幾種不同的用法，一個就是能提供組合型別，組合型別用來儲存所匹配的結果或部分匹配的結果(以便後面能用到)，即使遇到有相同的模式。在同樣的正則表達中，可能(也通常期望)不止有一個組合型別。在第n個組合型別中匹配結果可以通過向後掃描來獲取到。向後掃描使得搜尋重複的單詞非常簡單:/b(/w+)/s+/1/b。

　　圓括號形成了一個組合型別，在這個正則表示中它是第一組合型別(也是僅有的一個)。向後掃描/1，指的是任何被/w+所匹配的單詞。我們的正則表示式因此能匹配這樣的單詞，它有一個或多個空格符，後面還跟有一個與此相同的單詞。注意的是，尾部的定位型別(/b)必不可少，它可以防止發生錯誤。如果我們想匹配"Paris in the the spring"，而不是匹配"Java's regex package is the theme of this article"。根據java現在的格式，則上面的正則表示式就是:Pattern pattern =Pattern.compile("//b(//w+)//s+//1//b");

　　最後進一步的修改是讓我們的匹配器對大小寫敏感。比如，下面的情況:"The the theme of this article is the Java's regex package."，這一點在regex中能非常簡單地實現，即通過使用在Pattern類中預定義的靜態標誌CASE_INSENSITIVE :

　　Pattern pattern =Pattern.compile("//b(//w+)//s+//1//b",

　　Pattern.CASE_INSENSITIVE);

　　有關正則表示式的話題是非常豐富，而且複雜的，用Java來實現也非常廣泛，則需要對regex包進行的徹底研究，我們在這裡所講的只是冰山一角。即使你對正則表示式比較陌生，使用regex包後會很快發現它強大功能和可伸縮性。如果你是個來自Perl或其他語言王國的老練的正則表示式的黑客，使用過regex包後，你將會安心地投入到java的世界，而放棄其他的工具，並把java的regex包看成是手邊必備的利器。 

CharSequence

JDK 1.4定義了一個新的介面，叫CharSequence。它提供了String和StringBuffer這兩個類的字元序列的抽象：

interface CharSequence {
  charAt(int i);
  length();
  subSequence(int start, int end);
  toString();
}

為了實現這個新的CharSequence介面，String，StringBuffer以及CharBuffer都作了修改。很多正則表示式的操作都要拿CharSequence作引數。

Pattern和Matcher

先給一個例子。下面這段程式可以測試正則表示式是否匹配字串。第一個引數是要匹配的字串，後面是正則表示式。正則表示式可以有多個。在Unix/Linux環境下，命令列下的正則表示式還必須用引號。

//: c12:TestRegularExpression.java
// Allows you to easly try out regular expressions.
// {Args: abcabcabcdefabc "abc+" "(abc)+" "(abc){2,}" }
import java.util.regex.*;
publicclass TestRegularExpression {
publicstaticvoid main(String[] args) {
if(args.length < 2) {
      System.out.println("Usage:/n" +
"java TestRegularExpression " +
"characterSequence regularExpression+");
      System.exit(0);
    }
    System.out.println("Input: /"" + args[0] + "/"");
for(int i = 1; i < args.length; i++) {
      System.out.println(
"Regular expression: /"" + args[i] + "/"");
      Pattern p = Pattern.compile(args[i]);
      Matcher m = p.matcher(args[0]);
while(m.find()) {
        System.out.println("Match /"" + m.group() +
"/" at positions " +
          m.start() + "-" + (m.end() - 1));
      }
    }
  }
} ///:~

Java的正則表示式是由java.util.regex的Pattern和Matcher類實現的。Pattern物件表示經編譯的正則表示式。靜態的compile( )方法負責將表示正則表示式的字串編譯成Pattern物件。正如上述例程所示的，只要給Pattern的matcher( )方法送一個字串就能獲取一個Matcher物件。此外，Pattern還有一個能快速判斷能否在input裡面找到regex的

staticboolean matches(?regex, ?input)

以及能返回String陣列的split( )方法，它能用regex把字串分割開來。

只要給Pattern.matcher( )方法傳一個字串就能獲得Matcher物件了。接下來就能用Matcher的方法來查詢匹配的結果了。

boolean matches()
boolean lookingAt()
boolean find()
boolean find(int start)

matches( )的前提是Pattern匹配整個字串，而lookingAt( )的意思是Pattern匹配字串的開頭。

find( )

Matcher.find( )的功能是發現CharSequence裡的，與pattern相匹配的多個字元序列。例如：

//: c12:FindDemo.java
import java.util.regex.*;
import com.bruceeckel.simpletest.*;
import java.util.*;
publicclass FindDemo {
privatestatic Test monitor = new Test();
publicstaticvoid main(String[] args) {
    Matcher m = Pattern.compile("//w+")
      .matcher("Evening is full of the linnet's wings");
while(m.find())
      System.out.println(m.group());
int i = 0;
while(m.find(i)) {
      System.out.print(m.group() + " ");
      i++;
    }
    monitor.expect(new String[] {
"Evening",
"is",
"full",
"of",
"the",
"linnet",
"s",
"wings",
"Evening vening ening ning ing ng g is is s full " +
"full ull ll l of of f the the he e linnet linnet " +
"innet nnet net et t s s wings wings ings ngs gs s "
    });
  }
} ///:~

"//w+"的意思是"一個或多個單詞字元"，因此它會將字串直接分解成單詞。find( )像一個迭代器，從頭到尾掃描一遍字串。第二個find( )是帶int引數的，正如你所看到的，它會告訴方法從哪裡開始找——即從引數位置開始查詢。

Groups

Group是指裡用括號括起來的，能被後面的表示式呼叫的正則表示式。Group 0 表示整個表示式，group 1表示第一個被括起來的group，以此類推。所以；

A(B(C))D

裡面有三個group：group 0是ABCD， group 1是BC，group 2是C。

你可以用下述Matcher方法來使用group：

public int groupCount( )返回matcher物件中的group的數目。不包括group0。

public String group( ) 返回上次匹配操作(比方說find( ))的group 0(整個匹配)

public String group(int i)返回上次匹配操作的某個group。如果匹配成功，但是沒能找到group，則返回null。

public int start(int group)返回上次匹配所找到的，group的開始位置。

public int end(int group)返回上次匹配所找到的，group的結束位置，最後一個字元的下標加一。

//: c12:Groups.java
import java.util.regex.*;
import com.bruceeckel.simpletest.*;
publicclass Groups {
privatestatic Test monitor = new Test();
staticpublicfinal String poem =
"Twas brillig, and the slithy toves/n" +
"Did gyre and gimble in the wabe./n" +
"All mimsy were the borogoves,/n" +
"And the mome raths outgrabe./n/n" +
"Beware the Jabberwock, my son,/n" +
"The jaws that bite, the claws that catch./n" +
"Beware the Jubjub bird, and shun/n" +
"The frumious Bandersnatch.";
publicstaticvoid main(String[] args) {
    Matcher m =
      Pattern.compile("(?m)(//S+)//s+((//S+)//s+(//S+))___FCKpd___6quot;)
        .matcher(poem);
while(m.find()) {
for(int j = 0; j <= m.groupCount(); j++)
        System.out.print("[" + m.group(j) + "]");
      System.out.println();
    }
    monitor.expect(new String[]{
"[the slithy toves]" +
"[the][slithy toves][slithy][toves]",
"[in the wabe.][in][the wabe.][the][wabe.]",
"[were the borogoves,]" +
"[were][the borogoves,][the][borogoves,]",
"[mome raths outgrabe.]" +
"[mome][raths outgrabe.][raths][outgrabe.]",
"[Jabberwock, my son,]" +
"[Jabberwock,][my son,][my][son,]",
"[claws that catch.]" +
"[claws][that catch.][that][catch.]",
"[bird, and shun][bird,][and shun][and][shun]",
"[The frumious Bandersnatch.][The]" +
"[frumious Bandersnatch.][frumious][Bandersnatch.]"
    });
  }
} ///:~

這首詩是Through the Looking Glass的，Lewis Carroll的"Jabberwocky"的第一部分。可以看到這個正則表示式裡有很多用括號括起來的group，它是由任意多個連續的非空字元('/S+')和任意多個連續的空格字元('/s+')所組成的，其最終目的是要捕獲每行的最後三個單詞；'$'表示一行的結尾。但是'$'通常表示整個字串的結尾，所以這裡要明確地告訴正則表示式注意換行符。這一點是由'(?m)'標誌完成的(模式標誌會過一會講解)。

start( )和end( )

如果匹配成功，start( )會返回此次匹配的開始位置，end( )會返回此次匹配的結束位置，即最後一個字元的下標加一。如果之前的匹配不成功(或者沒匹配)，那麼無論是呼叫start( )還是end( )，都會引發一個IllegalStateException。下面這段程式還演示了matches( )和lookingAt( )：

//: c12:StartEnd.java
import java.util.regex.*;
import com.bruceeckel.simpletest.*;
publicclass StartEnd {
privatestatic Test monitor = new Test();
publicstaticvoid main(String[] args) {
    String[] input = new String[] {
"Java has regular expressions in 1.4",
"regular expressions now expressing in Java",
"Java represses oracular expressions"
    };
    Pattern
      p1 = Pattern.compile("re//w*"),
      p2 = Pattern.compile("Java.*");
for(int i = 0; i < input.length; i++) {
      System.out.println("input " + i + ": " + input[i]);
      Matcher
        m1 = p1.matcher(input[i]),
        m2 = p2.matcher(input[i]);
while(m1.find())
        System.out.println("m1.find() '" + m1.group() +
"' start = "+ m1.start() + " end = " + m1.end());
while(m2.find())
        System.out.println("m2.find() '" + m2.group() +
"' start = "+ m2.start() + " end = " + m2.end());
if(m1.lookingAt()) // No reset() necessary
        System.out.println("m1.lookingAt() start = "
          + m1.start() + " end = " + m1.end());
if(m2.lookingAt())
        System.out.println("m2.lookingAt() start = "
          + m2.start() + " end = " + m2.end());
if(m1.matches()) // No reset() necessary
        System.out.println("m1.matches() start = "
          + m1.start() + " end = " + m1.end());
if(m2.matches())
        System.out.println("m2.matches() start = "
          + m2.start() + " end = " + m2.end());
    }
    monitor.expect(new String[] {
"input 0: Java has regular expressions in 1.4",
"m1.find() 'regular' start = 9 end = 16",
"m1.find() 'ressions' start = 20 end = 28",
"m2.find() 'Java has regular expressions in 1.4'" +
" start = 0 end = 35",
"m2.lookingAt() start = 0 end = 35",
"m2.matches() start = 0 end = 35",
"input 1: regular expressions now " +
"expressing in Java",
"m1.find() 'regular' start = 0 end = 7",
"m1.find() 'ressions' start = 11 end = 19",
"m1.find() 'ressing' start = 27 end = 34",
"m2.find() 'Java' start = 38 end = 42",
"m1.lookingAt() start = 0 end = 7",
"input 2: Java represses oracular expressions",
"m1.find() 'represses' start = 5 end = 14",
"m1.find() 'ressions' start = 27 end = 35",
"m2.find() 'Java represses oracular expressions' " +
"start = 0 end = 35",
"m2.lookingAt() start = 0 end = 35",
"m2.matches() start = 0 end = 35"
    });
  }
} ///:~

注意，只要字串裡有這個模式，find( )就能把它給找出來，但是lookingAt( )和matches( )，只有在字串與正則表示式一開始就相匹配的情況下才能返回true。matches( )成功的前提是正則表示式與字串完全匹配，而lookingAt( )成功的前提是，字串的開始部分與正則表示式相匹配。

匹配的模式(Pattern flags)

compile( )方法還有一個版本，它需要一個控制正則表示式的匹配行為的引數：

Pattern Pattern.compile(String regex, int flag)
flag的取值範圍如下：
編譯標誌 效果
Pattern.CANON_EQ 當且僅當兩個字元的"正規分解(canonical decomposition)"都完全相同的情況下，才認定匹配。比如用了這個標誌之後，表示式"a/u030A"會匹配"?"。預設情況下，不考慮"規範相等性(canonical equivalence)"。
Pattern.CASE_INSENSITIVE
(?i)		 預設情況下，大小寫不明感的匹配只適用於US-ASCII字符集。這個標誌能讓表示式忽略大小寫進行匹配。要想對Unicode字元進行大小不明感的匹配，只要將UNICODE_CASE與這個標誌合起來就行了。
Pattern.COMMENTS
(?x)		 在這種模式下，匹配時會忽略(正則表示式裡的)空格字元(注：不是指表示式裡的"//s"，而是指表示式裡的空格，tab，回車之類)。註釋從#開始，一直到這行結束。可以通過嵌入式的標誌來啟用Unix行模式。
Pattern.DOTALL
(?s)		 在這種模式下，表示式'.'可以匹配任意字元，包括表示一行的結束符。預設情況下，表示式'.'不匹配行的結束符。
Pattern.MULTILINE
(?m)		 在這種模式下，'^'和'$'分別匹配一行的開始和結束。此外，'^'仍然匹配字串的開始，'$'也匹配字串的結束。預設情況下，這兩個表示式僅僅匹配字串的開始和結束。
Pattern.UNICODE_CASE
(?u)		 在這個模式下，如果你還啟用了CASE_INSENSITIVE標誌，那麼它會對Unicode字元進行大小寫不明感的匹配。預設情況下，大小寫不明感的匹配只適用於US-ASCII字符集。
Pattern.UNIX_LINES
(?d)		 在這個模式下，只有'/n'才被認作一行的中止，並且與'.'，'^'，以及'$'進行匹配。

在這些標誌裡面，Pattern.CASE_INSENSITIVE，Pattern.MULTILINE，以及Pattern.COMMENTS是最有用的(其中Pattern.COMMENTS還能幫我們把思路理清楚，並且/或者做文件)。注意，你可以用在表示式裡插記號的方式來啟用絕大多數的模式。這些記號就在上面那張表的各個標誌的下面。你希望模式從哪裡開始啟動，就在哪裡插記號。

可以用"OR" ('|')運算子把這些標誌合使用：

//: c12:ReFlags.java
import java.util.regex.*;
import com.bruceeckel.simpletest.*;
publicclass ReFlags {
privatestatic Test monitor = new Test();
publicstaticvoid main(String[] args) {
    Pattern p =  Pattern.compile("^java",
      Pattern.CASE_INSENSITIVE | Pattern.MULTILINE);
    Matcher m = p.matcher(
"java has regex/nJava has regex/n" +
"JAVA has pretty good regular expressions/n" +
"Regular expressions are in Java");
while(m.find())
      System.out.println(m.group());
    monitor.expect(new String[] {
"java",
"Java",
"JAVA"
    });
  }
} ///:~

這樣創建出來的正則表示式就能匹配以"java"，"Java"，"JAVA"...開頭的字串了。此外，如果字串分好幾行，那它還會對每一行做匹配(匹配始於字元序列的開始，終於字元序列當中的行結束符)。注意，group( )方法僅返回匹配的部分。

split( )

所謂分割是指將以正則表示式為界，將字串分割成String陣列。

String[] split(CharSequence charseq)
String[] split(CharSequence charseq, int limit)

這是一種既快又方便地將文字根據一些常見的邊界標誌分割開來的方法。

//: c12:SplitDemo.java
import java.util.regex.*;
import com.bruceeckel.simpletest.*;
import java.util.*;
publicclass SplitDemo {
privatestatic Test monitor = new Test();
publicstaticvoid main(String[] args) {
    String input =
"This!!unusual use!!of exclamation!!points";
    System.out.println(Arrays.asList(
      Pattern.compile("!!").split(input)));
// Only do the first three:
    System.out.println(Arrays.asList(
      Pattern.compile("!!").split(input, 3)));
    System.out.println(Arrays.asList(
"Aha! String has a split() built in!".split(" ")));
    monitor.expect(new String[] {
"[This, unusual use, of exclamation, points]",
"[This, unusual use, of exclamation!!points]",
"[Aha!, String, has, a, split(), built, in!]"
    });
  }
} ///:~

第二個

相關推薦

JAVA 正則表示式 （超詳細）

在Sun的Java JDK 1.40版本中，Java自帶了支援正則表示式的包，本文就拋磚引玉地介紹瞭如何使用java.util.regex包。 　　可粗略估計一下，除了偶爾用Linux的外，其他Linu x使用者都會遇到正則表示式。正則表示式是個極端強大工具，而且在字串模式-匹配和字串模式-替換方面富有

Java正則表示式（筆記歸納）

public class Regex { //1、正則表示式：是有規則的一種表示式 // 我們常用regex來表示正則表示式 // 主要作用： // 通過一種有規則的字元模式，對 目標字串進行查詢、提取、替換、分割的作用 // 典型的應用場景：校驗相關字元是否匹配規則：使用者名稱

java正則表示式（不定期更新）

自己編寫使用過的以及網路蒐集整理的正則表示式備份，只在java中測試過，其餘可參考，歡迎討論、指正。 匹配數字（包含負數、小數）： ^[-\\+]?[0-9]+[.]?[0-9]+$   匹配網頁中圖片連結（圖片格式可修改、新增）： (?<=<img

python3.6-正則表示式（附錄詳細用法）

正則表示式1：python使用re模組來實現正則表示式，方法如下： （1）正則表示式也有所謂的萬用字元，這裡是使用點號（.），它可以匹配除了換行符以外的任何字元：   匹配到了字串中的'I'字元  這裡點號（.）就匹配到了'e'，然後正則表

一個匹配數字的正則表示式（帶詳細解釋）

數字可能由一個整數部分加上一個可選的負號、一個可選的小數部分和一個可選的指數部分組成。下面是一個匹配數字的正則表示式例子： var parse_number = /^-?\d+(?:\.\d*)?(?:e[+\-]?\d+)?$/i; var testN

正則表示式（Regular Expression）高階使用（文字編輯器，資料庫，Java）

一、開發環境和文字編輯器中使用正則表示式 eclipse Notepad++ EditPlus UltraEdit 二、資料庫中也可以使用正則表示式 Mysq15.5以上 Oracle10g以上 例如： SELECT prod_name

JAVA中的正則表示式（pattern/match）

正則表示式概念 所謂正則表示式就是處理字串的特殊字串 用途 字串匹配(字元匹配) 字串查詢(是建立在匹配之上的查詢) 字串替換(是建立在查詢的結果之後的替換) 例如 IP地址是否正確 從網頁中揪出Email地址 從網頁揪出連結 類 java.lang.Stri

Java 正則表示式（來自菜鳥教程）

正則表示式定義了字串的模式。 正則表示式可以用來搜尋、編輯或處理文字。 正則表示式並不僅限於某一種語言，但是在每種語言中有細微的差別。 正則表示式例項 一個字串其實就是一個簡單的正則表示式，例如 Hello World 正則表示式匹配 "Hello World" 字串。 .（

【轉】Python之正則表示式（re模組）

【轉】Python之正則表示式（re模組） 本節內容 re模組介紹 使用re模組的步驟 re模組簡單應用示例 關於匹配物件的說明 說說正則表示式字串前的r字首 re模組綜合應用例項 參考文件 提示： 由於該站對MARKDOWN的表格支援的不是很好，所以本文中的表

LINUX學習—grep和正則表示式（LINUX三劍客）

grep, egrep, fgrep grep（GLOBAL RESEARCH) 是一種強大的文字搜尋工具，它能使用正則表示式搜尋文字，並把匹配的行打印出來。根據模式，搜尋文字，並將符合模式的文字行顯示出來。只能使用基本正則表示式 要使用擴充套件正則表示式需要-E pattern

正則表示式（re模組）

正則表示式，用來處理什麼的呢？它有什麼作用？ 正則表示式是用來處理字串匹配的！   講正題之前我們先來看一個例子：：https://reg.jd.com/reg/person?ReturnUrl=https%3A//www.jd.com/ 這是京東的註冊頁面，開啟頁面我們就看到這些要求輸入個

常用的正則表示式（匹配數字）

正則表示式用於字串處理、表單驗證等場合，實用高效。現將一些常用的表示式收集於此，以備不時之需。 匹配中文字元的正則表示式： [\u4e00-\u9fa5] 評註：匹配中文還真是個頭疼的事，有了這個表示式就好辦了 匹配雙位元組字元(包括漢字在內)：[^\x00-\xff]

正則表示式（十五）——統計程式碼中的程式碼行、註釋行和空白行

package com.wy.regular; import java.io.BufferedReader; import java.io.File; import java.io.FileNotFo

正則表示式（十七）——不捕獲分組

package com.wy.regular; import java.util.regex.Matcher; import java.util.regex.Pattern; public clas

正則表示式（十八）——向前引用

package com.wy.regular; import java.util.regex.Matcher; import java.util.regex.Pattern; public clas

正則表示式（十二）——字串的替換

1、查詢字串中的字串 package com.wy.regular; import java.util.regex.Matcher; import java.util.regex.Pattern;

python中的正則表示式（re模組）

一、簡介 正則表示式本身是一種小型的、高度專業化的程式語言，而在python中，通過內嵌整合re模組，程式媛們可以直接呼叫來實現正則匹配。正則表示式模式被編譯成一系列的位元組碼，然後由用C編寫的匹配引擎執行。 二、正則表示式中常用的字元含義 1、普通字元和11個元字

JS正則表示式（火星文）

<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>正則表示式（火星文）</title> </head>

正則表示式（基礎2）

從左到右進行計算，並遵循優先順序順序，這與算術表示式非常類似。 相同優先順序的從左到右進行運算，不同優先順序的運算先高後低。下表從最高到最低說明了各種正則表示式運算子的優先順序順序： 運算子 描述 \ 轉義符 (), (?:), (?=), []

[轉]python中的正則表示式（re模組）

轉自:https://www.cnblogs.com/tina-python/p/5508402.html 一、簡介 正則表示式本身是一種小型的、高度專業化的程式語言，而在python中，通過內嵌整合re模組，程式媛們可以直接呼叫來實現正則匹配。正則表示式模式被編譯成一系列的位元組碼