Java 學習（7）：java 日期時間 & 正則表達式
目錄html
--- 日期時間java
--- 正則表達式程序員
日期時間：java.util 包提供了 Date 類來封裝當前的日期和時間。 Date 類提供兩個構造函數來實例化 Date 對象。
- 構造函數：用於初始化對象，有如下兩種方法：
1. Date( ) //使用當前日期和時間來初始化對象 2. Date(long millisec) //接收一個參數，該參數是從1970年1月1日起的毫秒數
Date 對象創建之後，可調用如下方法：正則表達式
1 boolean after(Date date)：若當調用此方法的Date對象在指定日期以後返回true,不然返回false。 2 boolean before(Date date)：若當調用此方法的Date對象在指定日期以前返回true,不然返回false。 3 Object clone( )：返回此對象的副本。 4 int compareTo(Date date)：比較當調用此方法的Date對象和指定日期。二者相等時候返回0。調用對象在指定日期以前則返回負數。調用對象在指定日期以後則返回正數。 5 int compareTo(Object obj)：若obj是Date類型則操做等同於compareTo(Date) 。不然它拋出ClassCastException。 6 boolean equals(Object date)：當調用此方法的Date對象和指定日期相等時候返回true,不然返回false。 7 long getTime( )：返回自 1970 年 1 月 1 日 00:00:00 GMT 以來此 Date 對象表示的毫秒數。 8 int hashCode( )：返回此對象的哈希碼值。 9 void setTime(long time)：用自1970年1月1日00:00:00 GMT之後time毫秒數設置時間和日期。 10 String toString( )：轉換Date對象爲String表示形式，並返回該字符串。
- 獲取當前時間：
Date date = new Date(); // 初始化 Date 對象 System.out.println(date.toString()); // 使用 toString() 函數顯示日期時間
-
比較兩個日期，有如下三個方法：數組
- 使用 getTime() 方法獲取兩個日期（自1970年1月1日經歷的毫秒數值），而後比較這兩個值。
- 使用方法 before()，after() 和 equals()。例如，一個月的12號比18號早，則 new Date(99, 2, 12).before(new Date (99, 2, 18)) 返回true。
- 使用 compareTo() 方法，它是由 Comparable 接口定義的，Date 類實現了這個接口。
- 日期格式化：
- SimpleDateFormat 是一個以語言環境敏感的方式來格式化和分析日期的類，它容許你選擇任何用戶自定義日期時間格式來運行。
import java.util.*; import java.text.*; public class DateDemo { public static void main(String args[]) { Date dNow = new Date( ); SimpleDateFormat ft = new SimpleDateFormat ("E yyyy.MM.dd 'at' hh:mm:ss a zzz"); /*確立轉換格式，其中 yyyy 是完整的公元年，MM 是月份，dd 是日期，HH:mm:ss 是時、分、秒。HH 是 24 小時制，而 hh 是 12 小時制。 */ System.out.println("Current Date: " + ft.format(dNow)); //結果如： Current Date: Sun 2014.07.18 at 14:14:09 PM PDT
} }時間模式字符串用來指定時間格式。以下：app
日期和時間的格式化編碼字母 描述 示例 G 紀元標記 AD y 四位年份 2001 M 月份 July or 07 d 一個月的日期 10 h A.M./P.M. (1~12)格式小時 12 H 一天中的小時 (0~23) 22 m 分鐘數 30 s 秒數 55 S 毫秒數 234 E 星期幾 Tuesday D 一年中的日子 360 F 一個月中第幾周的周幾 2 (second Wed. in July) w 一年中第幾周 40 W 一個月中第幾周 1 a A.M./P.M. 標記 PM k 一天中的小時(1~24) 24 K A.M./P.M. (0~11)格式小時 10 z 時區 Eastern Standard Time ' 文字定界符 Delimiter " 單引號 `
- printf 方法能夠很輕鬆地格式化時間和日期。使用兩個字母格式，它以 %t 開頭而且如下面表格中的一個字母結尾。
printf 格式化日期
轉換符 說明 示例 c 包括所有日期和時間信息 星期六 十月 27 14:21:20 CST 2007 F "年-月-日"格式 2007-10-27 D "月/日/年"格式 10/27/07 r "HH:MM:SS PM"格式（12時制） 02:25:51 下午 T "HH:MM:SS"格式（24時制） 14:28:16 R "HH:MM"格式（24時制） 14:28
printf 格式化日期 實例import java.util.Date; /** * 使用printf輸出 */ /**關鍵技術點 * 使用java.io.PrintStream的printf方法實現C風格的輸出 * printf 方法的第一個參數爲輸出的格式,第二個參數是可變長的,表示待輸出的數據對象 */ public class Printf { public static void main(String[] args) { /*** 輸出字符串 ***/ // %s表示輸出字符串，也就是將後面的字符串替換模式中的%s System.out.printf("%s", new Integer(1212)); // %n表示換行 System.out.printf("%s%n", "end line"); // 還能夠支持多個參數 System.out.printf("%s = %s%n", "Name", "Zhangsan"); // %S將字符串以大寫形式輸出 System.out.printf("%S = %s%n", "Name", "Zhangsan"); // 支持多個參數時，能夠在%s之間插入變量編號，1$表示第一個字符串，3$表示第3個字符串 System.out.printf("%1$s = %3$s %2$s%n", "Name", "san", "Zhang"); /*** 輸出boolean類型 ***/ System.out.printf("true = %b; false = ", true); System.out.printf("%b%n", false); /*** 輸出整數類型***/ Integer iObj = 342; // %d表示將整數格式化爲10進制整數 System.out.printf("%d; %d; %d%n", -500, 2343L, iObj); // %o表示將整數格式化爲8進制整數 System.out.printf("%o; %o; %o%n", -500, 2343L, iObj); // %x表示將整數格式化爲16進制整數 System.out.printf("%x; %x; %x%n", -500, 2343L, iObj); // %X表示將整數格式化爲16進制整數，而且字母變成大寫形式 System.out.printf("%X; %X; %X%n", -500, 2343L, iObj); /*** 輸出浮點類型***/ Double dObj = 45.6d; // %e表示以科學技術法輸出浮點數 System.out.printf("%e; %e; %e%n", -756.403f, 7464.232641d, dObj); // %E表示以科學技術法輸出浮點數，而且爲大寫形式 System.out.printf("%E; %E; %E%n", -756.403f, 7464.232641d, dObj); // %f表示以十進制格式化輸出浮點數 System.out.printf("%f; %f; %f%n", -756.403f, 7464.232641d, dObj); // 還能夠限制小數點後的位數 System.out.printf("%.1f; %.3f; %f%n", -756.403f, 7464.232641d, dObj); /*** 輸出日期類型***/ // %t表示格式化日期時間類型，%T是時間日期的大寫形式，在%t以後用特定的字母表示不一樣的輸出格式 Date date = new Date(); long dataL = date.getTime(); // 格式化年月日 // %t以後用y表示輸出日期的年份（2位數的年，如99） // %t以後用m表示輸出日期的月份，%t以後用d表示輸出日期的日號 System.out.printf("%1$ty-%1$tm-%1$td; %2$ty-%2$tm-%2$td%n", date, dataL); // %t以後用Y表示輸出日期的年份（4位數的年）， // %t以後用B表示輸出日期的月份的完整名， %t以後用b表示輸出日期的月份的簡稱 System.out.printf("%1$tY-%1$tB-%1$td; %2$tY-%2$tb-%2$td%n", date, dataL); // 如下是常見的日期組合 // %t以後用D表示以 "%tm/%td/%ty"格式化日期 System.out.printf("%1$tD%n", date); //%t以後用F表示以"%tY-%tm-%td"格式化日期 System.out.printf("%1$tF%n", date); /*** 輸出時間類型***/ // 輸出時分秒 // %t以後用H表示輸出時間的時（24進制），%t以後用I表示輸出時間的時（12進制）， // %t以後用M表示輸出時間的分，%t以後用S表示輸出時間的秒 System.out.printf("%1$tH:%1$tM:%1$tS; %2$tI:%2$tM:%2$tS%n", date, dataL); // %t以後用L表示輸出時間的秒中的毫秒 System.out.printf("%1$tH:%1$tM:%1$tS %1$tL%n", date); // %t以後p表示輸出時間的上午或下午信息 System.out.printf("%1$tH:%1$tM:%1$tS %1$tL %1$tp%n", date); // 如下是常見的時間組合 // %t以後用R表示以"%tH:%tM"格式化時間 System.out.printf("%1$tR%n", date); // %t以後用T表示以"%tH:%tM:%tS"格式化時間 System.out.printf("%1$tT%n", date); // %t以後用r表示以"%tI:%tM:%tS %Tp"格式化時間 System.out.printf("%1$tr%n", date); /*** 輸出星期***/ // %t以後用A表示獲得星期幾的全稱 System.out.printf("%1$tF %1$tA%n", date); // %t以後用a表示獲得星期幾的簡稱 System.out.printf("%1$tF %1$ta%n", date); // 輸出時間日期的完整信息 System.out.printf("%1$tc%n", date); } } /** *printf方法中,格式爲"%s"表示以字符串的形式輸出第二個可變長參數的第一個參數值; *格式爲"%n"表示換行;格式爲"%S"表示將字符串以大寫形式輸出;在"%s"之間用"n$"表示 *輸出可變長參數的第n個參數值.格式爲"%b"表示以布爾值的形式輸出第二個可變長參數 *的第一個參數值. */ /** * 格式爲"%d"表示以十進制整數形式輸出;"%o"表示以八進制形式輸出;"%x"表示以十六進制 * 輸出;"%X"表示以十六進制輸出,而且將字母(A、B、C、D、E、F)換成大寫.格式爲"%e"表 * 以科學計數法輸出浮點數;格式爲"%E"表示以科學計數法輸出浮點數,並且將e大寫;格式爲 * "%f"表示以十進制浮點數輸出,在"%f"之間加上".n"表示輸出時保留小數點後面n位. */ /** * 格式爲"%t"表示輸出時間日期類型."%t"以後用y表示輸出日期的二位數的年份(如99)、用m * 表示輸出日期的月份,用d表示輸出日期的日號;"%t"以後用Y表示輸出日期的四位數的年份 * (如1999)、用B表示輸出日期的月份的完整名,用b表示輸出日期的月份的簡稱."%t"以後用D * 表示以"%tm/%td/%ty"的格式輸出日期、用F表示以"%tY-%tm-%td"的格式輸出日期. */ /** * "%t"以後用H表示輸出時間的時(24進制),用I表示輸出時間的時(12進制),用M表示輸出時間 * 分,用S表示輸出時間的秒,用L表示輸出時間的秒中的毫秒數、用P表示輸出時間的是上午仍是 * 下午."%t"以後用R表示以"%tH:%tM"的格式輸出時間、用T表示以"%tH:%tM:%tS"的格式輸出 * 時間、用r表示以"%tI:%tM:%tS %Tp"的格式輸出時間. */ /** * "%t"以後用A表示輸出日期的全稱,用a表示輸出日期的星期簡稱. */
- SimpleDateFormat 是一個以語言環境敏感的方式來格式化和分析日期的類，它容許你選擇任何用戶自定義日期時間格式來運行。
- 若是你須要重複提供日期，那麼利用這種方式來格式化它的每一部分就有點複雜了。所以，能夠利用一個格式化字符串指出要被格式化的參數的索引。
- 索引必須緊跟在%後面，並且必須以$結束。例如：
import java.util.Date; public class DateDemo { public static void main(String args[]) { // 初始化 Date 對象 Date date = new Date(); // 使用 toString() 顯示日期和時間 System.out.printf("%1$s %2$tB %2$td, %2$tY", "Due date:", date); } } // 運行結果：Due date: February 09, 2014
- 能夠使用 < 標誌。它代表先前被格式化的參數要被再次使用。例如：
import java.util.Date; public class DateDemo { public static void main(String args[]) { // 初始化 Date 對象 Date date = new Date(); // 顯示格式化時間 System.out.printf("%s %tB %<te, %<tY", "Due date:", date); } } // 運行結果：Due date: February 09, 2014
- 索引必須緊跟在%後面，並且必須以$結束。例如：
- 定義日期格式的轉換符：可使日期經過指定的轉換符生成新字符串。
import java.util.*; public class DateDemo { public static void main(String args[]) { Date date=new Date(); //b的使用，月份簡稱 String str=String.format(Locale.US,"英文月份簡稱：%tb",date); System.out.println(str); System.out.printf("本地月份簡稱：%tb%n",date); //B的使用，月份全稱 str=String.format(Locale.US,"英文月份全稱：%tB",date); System.out.println(str); System.out.printf("本地月份全稱：%tB%n",date); //a的使用，星期簡稱 str=String.format(Locale.US,"英文星期的簡稱：%ta",date); System.out.println(str); //A的使用，星期全稱 System.out.printf("本地星期的簡稱：%tA%n",date); //C的使用，年前兩位 System.out.printf("年的前兩位數字（不足兩位前面補0）：%tC%n",date); //y的使用，年後兩位 System.out.printf("年的後兩位數字（不足兩位前面補0）：%ty%n",date); //j的使用，一年的天數 System.out.printf("一年中的天數（即年的第幾天）：%tj%n",date); //m的使用，月份 System.out.printf("兩位數字的月份（不足兩位前面補0）：%tm%n",date); //d的使用，日（二位，不夠補零） System.out.printf("兩位數字的日（不足兩位前面補0）：%td%n",date); //e的使用，日（一位不補零） System.out.printf("月份的日（前面不補0）：%te",date); } } /* 輸出結果爲： 英文月份簡稱：May 本地月份簡稱：五月 英文月份全稱：May 本地月份全稱：五月 英文星期的簡稱：Thu 本地星期的簡稱：星期四 年的前兩位數字（不足兩位前面補0）：20 年的後兩位數字（不足兩位前面補0）：17 一年中的天數（即年的第幾天）：124 兩位數字的月份（不足兩位前面補0）：05 兩位數字的日（不足兩位前面補0）：04 月份的日（前面不補0）：4 */
- 解析字符串爲時間：SimpleDateFormat 類有一些附加的方法，特別是parse()，它試圖按照給定的SimpleDateFormat 對象的格式化存儲來解析字符串。
parse 解析時間 實例
import java.util.*; import java.text.*; public class DateDemo { public static void main(String args[]) { SimpleDateFormat ft = new SimpleDateFormat ("yyyy-MM-dd"); String input = args.length == 0 ? "1818-11-11" : args[0]; System.out.print(input + " Parses as "); Date t; try { t = ft.parse(input); System.out.println(t); } catch (ParseException e) { System.out.println("Unparseable using " + ft); } } }
-
休眠 sleep()：使當前線程進入停滯狀態（阻塞當前線程），讓出CPU的使用、目的是不讓當前線程獨自霸佔該進程所獲的CPU資源，以留必定時間給其餘線程執行的機會。ide
休眠 3秒 實例import java.util.*; public class SleepDemo { public static void main(String args[]) { try { System.out.println(new Date( ) + "\n"); Thread.sleep(1000*3); // 休眠3秒 System.out.println(new Date( ) + "\n"); } catch (Exception e) { System.out.println("Got an exception!"); } } }
- 測量時間：
測量時間（以毫秒記）
import java.util.*; public class DiffDemo { public static void main(String args[]) { try { long start = System.currentTimeMillis( ); System.out.println(new Date( ) + "\n"); Thread.sleep(5*60*10); System.out.println(new Date( ) + "\n"); long end = System.currentTimeMillis( ); long diff = end - start; System.out.println("Difference is : " + diff); } catch (Exception e) { System.out.println("Got an exception!"); } } }
Calendar類
- 如何才能設置和獲取日期數據的特定部分呢，好比說小時，日，或者分鐘? 咱們又如何在日期的這些部分加上或者減去值呢? 答案是使用 Calendar 類。
- Calendar類是一個抽象類，在實際使用時實現特定的子類的對象，建立對象的過程對程序員來講是透明的，只須要使用getInstance方法 建立便可。
- 建立指定日期的 Calendar 類
Calendar c = Calendar.getInstance();//默認是當前日期 c.set(2009, 6-1, 12); //建立一個表明2009年6月12日的Calendar對象
- Calendar 類對象 字段類型：Calendar 類中用一下這些常量表示不一樣的意義，jdk內的不少類其實都是採用的這種思想。
-
Calendar 類對象字段類型
常量 描述 Calendar.YEAR 年份 Calendar.MONTH 月份 Calendar.DATE 日期 Calendar.DAY_OF_MONTH 日期，和上面的字段意義徹底相同 Calendar.HOUR 12小時制的小時 Calendar.HOUR_OF_DAY 24小時制的小時 Calendar.MINUTE 分鐘 Calendar.SECOND 秒 Calendar.DAY_OF_WEEK 星期幾 -
Calendar 類對象 信息的設置函數
set 設置：
利用年月日： public final void set(int year,int month,int date) /* eg：Calendar c1 = Calendar.getInstance(); // 建立一個 Calender 對象 c1.set(2009, 6 - 1, 12); //設置 c1 的年月日 分別設這爲：200九、六、12 */ 利用字段設置：public void set(int field,int value) /* eg: c1.set(Calendar.DATE, 10); // 日期爲： 10號，其它全部的數值會被從新計算
c1.set(Calendar.YEAR,2008); // 年份爲： 2008， 其餘全部數值會被從新計算 */Add 設置:Calendar c1 = Calendar.getInstance(); c1.add(Calendar.DATE, 10); /*把c1對象的日期加上10，也就是c1也就表示爲10天后的日期，其它全部的數值會被從新計算*/ c1.add(Calendar.DATE, -10); /*把c1對象的日期減去10，也就是c1也就表示爲10天前的日期，其它全部的數值會被從新計算*/
-
Calendar類對象信息的得到： get 得到信息post
Calendar c1 = Calendar.getInstance(); int year = c1.get(Calendar.YEAR); // 得到年份 int month = c1.get(Calendar.MONTH) + 1; // 得到月份 int date = c1.get(Calendar.DATE); // 得到日期 int hour = c1.get(Calendar.HOUR_OF_DAY); // 得到小時 int minute = c1.get(Calendar.MINUTE); // 得到分鐘 int second = c1.get(Calendar.SECOND); // 得到秒 int day = c1.get(Calendar.DAY_OF_WEEK); // 得到星期幾（注意（這個與Date類是不一樣的）：1表明星期日、2表明星期一、3表明星期二，以此類推）
- 建立指定日期的 Calendar 類
GregorianCalendar類
- Calendar 類實現了公曆日曆，GregorianCalendar 是 Calendar 類 的一個具體實現。
- Calendar 的 getInstance（）方法返回一個默認用當前的語言環境和時區初始化的 GregorianCalendar對象。
- GregorianCalendar 定義了兩個字段：AD和BC。這是表明公曆定義的兩個時代。
1 GregorianCalendar() ：在具備默認語言環境的默認時區內使用當前時間構造一個默認的 GregorianCalendar。 2 GregorianCalendar(int year, int month, int date)：在具備默認語言環境的默認時區內構造一個帶有給定日期設置的 GregorianCalendar 3 GregorianCalendar(int year, int month, int date, int hour, int minute) ：爲具備默認語言環境的默認時區構造一個具備給定日期和時間設置的 GregorianCalendar。 4 GregorianCalendar(int year, int month, int date, int hour, int minute, int second) ：爲具備默認語言環境的默認時區構造一個具備給定日期和時間設置的 GregorianCalendar。 5 GregorianCalendar(Locale aLocale) ：在具備給定語言環境的默認時區內構造一個基於當前時間的 GregorianCalendar。 6 GregorianCalendar(TimeZone zone)：在具備默認語言環境的給定時區內構造一個基於當前時間的 GregorianCalendar。 7 GregorianCalendar(TimeZone zone, Locale aLocale)：在具備給定語言環境的給定時區內構造一個基於當前時間的 GregorianCalendar。
1 void add(int field, int amount)：根據日曆規則，將指定的（有符號的）時間量添加到給定的日曆字段中。 2 protected void computeFields()：轉換UTC毫秒值爲時間域值 3 protected void computeTime()：覆蓋Calendar ，轉換時間域值爲UTC毫秒值 4 boolean equals(Object obj)：比較此 GregorianCalendar 與指定的 Object。 5 int get(int field)：獲取指定字段的時間值 6 int getActualMaximum(int field)：返回當前日期，給定字段的最大值 7 int getActualMinimum(int field)：返回當前日期，給定字段的最小值 8 int getGreatestMinimum(int field)：返回此 GregorianCalendar 實例給定日曆字段的最高的最小值。 9 Date getGregorianChange()：得到格里高利曆的更改日期。 10 int getLeastMaximum(int field)：返回此 GregorianCalendar 實例給定日曆字段的最低的最大值 11 int getMaximum(int field)：返回此 GregorianCalendar 實例的給定日曆字段的最大值。 12 Date getTime()：獲取日曆當前時間。 13 long getTimeInMillis()：獲取用長整型表示的日曆的當前時間 14 TimeZone getTimeZone()：獲取時區。 15 int getMinimum(int field)：返回給定字段的最小值。 16 int hashCode()：重寫hashCode. 17 boolean isLeapYear(int year)：肯定給定的年份是否爲閏年。 18 void roll(int field, boolean up)：在給定的時間字段上添加或減去（上/下）單個時間單元，不更改更大的字段。 19 void set(int field, int value)：用給定的值設置時間字段。 20 void set(int year, int month, int date)：設置年、月、日的值。 21 void set(int year, int month, int date, int hour, int minute)：設置年、月、日、小時、分鐘的值。 22 void set(int year, int month, int date, int hour, int minute, int second)：設置年、月、日、小時、分鐘、秒的值。 23 void setGregorianChange(Date date)：設置 GregorianCalendar 的更改日期。 24 void setTime(Date date)：用給定的日期設置Calendar的當前時間。 25 void setTimeInMillis(long millis)：用給定的long型毫秒數設置Calendar的當前時間。 26 void setTimeZone(TimeZone value)：用給定時區值設置當前時區。 27 String toString()：返回表明日曆的字符串。
import java.util.*; public class GregorianCalendarDemo { public static void main(String args[]) { String months[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"}; int year; // 初始化 Gregorian 日曆 // 使用當前時間和日期 // 默認爲本地時間和時區 GregorianCalendar gcalendar = new GregorianCalendar(); // 顯示當前時間和日期的信息 System.out.print("Date: "); System.out.print(months[gcalendar.get(Calendar.MONTH)]); System.out.print(" " + gcalendar.get(Calendar.DATE) + " "); System.out.println(year = gcalendar.get(Calendar.YEAR)); System.out.print("Time: "); System.out.print(gcalendar.get(Calendar.HOUR) + ":"); System.out.print(gcalendar.get(Calendar.MINUTE) + ":"); System.out.println(gcalendar.get(Calendar.SECOND)); // 測試當前年份是否爲閏年 if(gcalendar.isLeapYear(year)) { System.out.println("當前年份是閏年"); } else { System.out.println("當前年份不是閏年"); } } }
正則表達式：正則表達式能夠用來搜索、編輯或處理文本
| 正則表達式學習 |
描述 |
|---|---|
| this is text |
匹配字符串 "this is text" |
| this\s+is\s+text |
注意字符串中的 \s+，能夠匹配多個空格。 匹配單詞 "this" 後面的 \s+ 能夠匹配多個空格，以後匹配 is 字符串，再以後 \s+ 匹配多個空格而後再跟上 text 字符串。 能夠匹配這個實例：this is text |
| ^\d+(\.\d+)? |
^ 定義了 以什麼開始 \d+ 匹配 一個或多個數字 ? 設置 括號內的選項是可選的 \. 匹配 "." 該例含義： 以 數字開頭 的 數據， 能夠匹配的實例："5", "1.5" 和 "2.21"。 |
java.util.regex 包主要包括如下三個類：
- Pattern 類：
pattern 對象是一個正則表達式的編譯表示。Pattern 類沒有公共構造方法。要建立一個 Pattern 對象，你必須首先調用其公共靜態編譯方法，它返回一個 Pattern 對象。該方法接受一個正則表達式做爲它的第一個參數。
- Matcher 類：
Matcher 對象是對輸入字符串進行解釋和匹配操做的引擎。與Pattern 類同樣，Matcher 也沒有公共構造方法。你須要調用 Pattern 對象的 matcher 方法來得到一個 Matcher 對象。
- PatternSyntaxException：
PatternSyntaxException 是一個非強制異常類，它表示一個正則表達式模式中的語法錯誤。如下實例中使用了正則表達式 .*runoob.* 用於查找字符串中是否包了 runoob 子串：
查找字符串中是否包了 runoob 子串import java.util.regex.*; class RegexExample1{ public static void main(String args[]){ String content = "I am noob " + "from runoob.com."; String pattern = ".*runoob.*"; boolean isMatch = Pattern.matches(pattern, content); System.out.println("字符串中是否包含了 'runoob' 子字符串? " + isMatch); } } /* 實例輸出結果爲： 字符串中是否包含了 'runoob' 子字符串? true */
捕獲組
捕獲組是把多個字符當一個單獨單元進行處理的方法，它經過對 括號內的字符 分組 來建立。
例如，正則表達式 (dog) 建立了單一分組，組裏包含"d"，"o"，和"g"。
捕獲組是經過從左至右計算其開括號來編號。例如，在表達式（（A）（B（C））），有四個這樣的組：
- ((A)(B(C)))
- (A)
- (B(C))
- (C)
能夠經過調用 matcher 對象的 groupCount 方法來查看錶達式有多少個分組。groupCount 方法返回一個 int 值，表示matcher對象當前有多個捕獲組。
還有一個特殊的組（group(0)），它老是表明整個表達式。該組不包括在 groupCount 的返回值中。
下面的例子說明如何從一個給定的字符串中找到數字串：
import java.util.regex.Matcher; import java.util.regex.Pattern; public class RegexMatches { public static void main( String args[] ){ // 按指定模式在字符串查找 String line = "This order was placed for QT3000! OK?"; String pattern = "(\\D*)(\\d+)(.*)"; // 建立 Pattern 對象 Pattern r = Pattern.compile(pattern); // 如今建立 matcher 對象 Matcher m = r.matcher(line); if (m.find( )) { System.out.println("Found value: " + m.group(0) ); System.out.println("Found value: " + m.group(1) ); System.out.println("Found value: " + m.group(2) ); System.out.println("Found value: " + m.group(3) ); } else { System.out.println("NO MATCH"); } } } /** 以上實例編譯運行結果以下： Found value: This order was placed for QT3000! OK? Found value: This order was placed for QT Found value: 3000 Found value: ! OK? **/
字符 說明 \ 將下一字符標記爲特殊字符、文本、反向引用或八進制轉義符。例如，"n"匹配字符"n"。"\n"匹配換行符。序列"\\"匹配"\"，"\("匹配"("。 ^ 匹配輸入字符串開始的位置。若是設置了 RegExp 對象的 Multiline 屬性，^ 還會與"\n"或"\r"以後的位置匹配。 $ 匹配輸入字符串結尾的位置。若是設置了 RegExp 對象的 Multiline 屬性，$ 還會與"\n"或"\r"以前的位置匹配。 * 零次或屢次匹配前面的字符或子表達式。例如，zo* 匹配"z"和"zoo"。* 等效於 {0,}。 + 一次或屢次匹配前面的字符或子表達式。例如，"zo+"與"zo"和"zoo"匹配，但與"z"不匹配。+ 等效於 {1,}。 ? 零次或一次匹配前面的字符或子表達式。例如，"do(es)?"匹配"do"或"does"中的"do"。? 等效於 {0,1}。 {n} n 是非負整數。正好匹配 n 次。例如，"o{2}"與"Bob"中的"o"不匹配，但與"food"中的兩個"o"匹配。 {n,} n 是非負整數。至少匹配 n 次。例如，"o{2,}"不匹配"Bob"中的"o"，而匹配"foooood"中的全部 o。"o{1,}"等效於"o+"。"o{0,}"等效於"o*"。 {n,m} M 和 n 是非負整數，其中 n <= m。匹配至少 n 次，至多 m 次。例如，"o{1,3}"匹配"fooooood"中的頭三個 o。'o{0,1}' 等效於 'o?'。注意：您不能將空格插入逗號和數字之間。 ? 當此字符緊隨任何其餘限定符（*、+、?、{n}、{n,}、{n,m}）以後時，匹配模式是"非貪心的"。"非貪心的"模式匹配搜索到的、儘量短的字符串，而默認的"貪心的"模式匹配搜索到的、儘量長的字符串。例如，在字符串"oooo"中，"o+?"只匹配單個"o"，而"o+"匹配全部"o"。 . 匹配除"\r\n"以外的任何單個字符。若要匹配包括"\r\n"在內的任意字符，請使用諸如"[\s\S]"之類的模式。 (pattern) 匹配 pattern 並捕獲該匹配的子表達式。可使用 $0…$9 屬性從結果"匹配"集合中檢索捕獲的匹配。若要匹配括號字符 ( )，請使用"\("或者"\)"。 (?:pattern) 匹配 pattern 但不捕獲該匹配的子表達式，即它是一個非捕獲匹配，不存儲供之後使用的匹配。這對於用"or"字符 (|) 組合模式部件的狀況頗有用。例如，'industr(?:y|ies) 是比 'industry|industries' 更經濟的表達式。 (?=pattern) 執行正向預測先行搜索的子表達式，該表達式匹配處於匹配 pattern 的字符串的起始點的字符串。它是一個非捕獲匹配，即不能捕獲供之後使用的匹配。例如，'Windows (?=95|98|NT|2000)' 匹配"Windows 2000"中的"Windows"，但不匹配"Windows 3.1"中的"Windows"。預測先行不佔用字符，即發生匹配後，下一匹配的搜索緊隨上一匹配以後，而不是在組成預測先行的字符後。 (?!pattern) 執行反向預測先行搜索的子表達式，該表達式匹配不處於匹配 pattern 的字符串的起始點的搜索字符串。它是一個非捕獲匹配，即不能捕獲供之後使用的匹配。例如，'Windows (?!95|98|NT|2000)' 匹配"Windows 3.1"中的 "Windows"，但不匹配"Windows 2000"中的"Windows"。預測先行不佔用字符，即發生匹配後，下一匹配的搜索緊隨上一匹配以後，而不是在組成預測先行的字符後。 x|y 匹配 x 或 y。例如，'z|food' 匹配"z"或"food"。'(z|f)ood' 匹配"zood"或"food"。 [xyz] 字符集。匹配包含的任一字符。例如，"[abc]"匹配"plain"中的"a"。 [^xyz] 反向字符集。匹配未包含的任何字符。例如，"[^abc]"匹配"plain"中"p"，"l"，"i"，"n"。 [a-z] 字符範圍。匹配指定範圍內的任何字符。例如，"[a-z]"匹配"a"到"z"範圍內的任何小寫字母。 [^a-z] 反向範圍字符。匹配不在指定的範圍內的任何字符。例如，"[^a-z]"匹配任何不在"a"到"z"範圍內的任何字符。 \b 匹配一個字邊界，即字與空格間的位置。例如，"er\b"匹配"never"中的"er"，但不匹配"verb"中的"er"。 \B 非字邊界匹配。"er\B"匹配"verb"中的"er"，但不匹配"never"中的"er"。 \cx 匹配 x 指示的控制字符。例如，\cM 匹配 Control-M 或回車符。x 的值必須在 A-Z 或 a-z 之間。若是不是這樣，則假定 c 就是"c"字符自己。 \d 數字字符匹配。等效於 [0-9]。 \D 非數字字符匹配。等效於 [^0-9]。 \f 換頁符匹配。等效於 \x0c 和 \cL。 \n 換行符匹配。等效於 \x0a 和 \cJ。 \r 匹配一個回車符。等效於 \x0d 和 \cM。 \s 匹配任何空白字符，包括空格、製表符、換頁符等。與 [ \f\n\r\t\v] 等效。 \S 匹配任何非空白字符。與 [^ \f\n\r\t\v] 等效。 \t 製表符匹配。與 \x09 和 \cI 等效。 \v 垂直製表符匹配。與 \x0b 和 \cK 等效。 \w 匹配任何字類字符，包括下劃線。與"[A-Za-z0-9_]"等效。 \W 與任何非單詞字符匹配。與"[^A-Za-z0-9_]"等效。 \xn 匹配 n，此處的 n 是一個十六進制轉義碼。十六進制轉義碼必須正好是兩位數長。例如，"\x41"匹配"A"。"\x041"與"\x04"&"1"等效。容許在正則表達式中使用 ASCII 代碼。 \num 匹配 num，此處的 num 是一個正整數。到捕獲匹配的反向引用。例如，"(.)\1"匹配兩個連續的相同字符。 \n 標識一個八進制轉義碼或反向引用。若是 \n 前面至少有 n 個捕獲子表達式，那麼 n 是反向引用。不然，若是 n 是八進制數 (0-7)，那麼 n 是八進制轉義碼。 \nm 標識一個八進制轉義碼或反向引用。若是 \nm 前面至少有 nm 個捕獲子表達式，那麼 nm 是反向引用。若是 \nm 前面至少有 n 個捕獲，則 n 是反向引用，後面跟有字符 m。若是兩種前面的狀況都不存在，則 \nm 匹配八進制值 nm，其中 n 和 m 是八進制數字 (0-7)。 \nml 當 n 是八進制數 (0-3)，m 和 l 是八進制數 (0-7) 時，匹配八進制轉義碼 nml。 \un 匹配 n，其中 n 是以四位十六進制數表示的 Unicode 字符。例如，\u00A9 匹配版權符號 (©)。
根據 Java Language Specification 的要求，Java 源代碼的字符串中的反斜線被解釋爲 Unicode 轉義或其餘字符轉義。所以必須在字符串字面值中使用兩個反斜線，表示正則表達式受到保護，不被 Java 字節碼編譯器解釋。例如，當解釋爲正則表達式時，字符串字面值 "\b" 與單個退格字符匹配，而 "\\b" 與單詞邊界匹配。字符串字面值 "\(hello\)" 是非法的，將致使編譯時錯誤；要與字符串 (hello) 匹配，必須使用字符串字面值 "\\(hello\\)"。
Matcher 類 的方法
- 索引方法 提供了有用的索引值，精確代表輸入字符串中在哪能找到匹配：
索引方法
public int start(): 返回之前匹配的初始索引。 public int start(int group): 返回在之前的匹配操做期間，由給定組所捕獲的子序列的初始索引 public int end(): 返回最後匹配字符以後的偏移量。 public int end(int group): 返回在之前的匹配操做期間，由給定組所捕獲子序列的最後字符以後的偏移量。
- 研究方法 用來檢查輸入字符串並返回一個布爾值，表示是否找到該模式：
研究方法
public boolean lookingAt():嘗試將從區域開頭開始的輸入序列與該模式匹配。 public boolean find() : 嘗試查找與該模式匹配的輸入序列的下一個子序列。 public boolean find(int start）: 重置此匹配器，而後嘗試查找匹配該模式、從指定索引開始的輸入序列的下一個子序列。 public boolean matches() : 嘗試將整個區域與模式匹配。
- 替換方法 是替換輸入字符串裏文本的方法：
替換方法
public Matcher appendReplacement(StringBuffer sb, String replacement):實現非終端添加和替換步驟。 public StringBuffer appendTail(StringBuffer sb): 實現終端添加和替換步驟。 public String replaceAll(String replacement) : 替換模式與給定替換字符串相匹配的輸入序列的每一個子序列。 public String replaceFirst(String replacement): 替換模式與給定替換字符串匹配的輸入序列的第一個子序列。 public static String quoteReplacement(String s): 返回指定字符串的字面替換字符串。這個方法返回一個字符串，就像傳遞給Matcher類的appendReplacement 方法一個字面字符串同樣工做。
start 和 end 方法
下面是一個對單詞 "cat" 出如今輸入字符串中出現次數進行計數的例子：
import java.util.regex.Matcher; import java.util.regex.Pattern; public class TestHello { private static final String REGEX = "\\bcat\\b"; private static final String INPUT = "cat cat cat cattie cat"; public static void main( String args[] ){ Pattern p = Pattern.compile(REGEX); Matcher m = p.matcher(INPUT); // 獲取 matcher 對象 int count = 0; while(m.find()) { count++; System.out.println("Match number "+count); System.out.println("位置： start(): "+ m.start() + " end(): " + m.end() + "\n"); } } }
/* 運行結果：
Match number 1
位置： start(): 0 end(): 3
Match number 2
位置： start(): 4 end(): 7
Match number 3
位置： start(): 8 end(): 11
Match number 4
位置： start(): 19 end(): 22
其中 Start 方法返回在之前的匹配操做期間，由給定組所捕獲的子序列的初始索引，end 方法最後一個匹配字符的索引加 1。 */
matches 和 lookingAt 方法
matches 和 lookingAt 方法都用來嘗試匹配一個輸入序列模式。它們的不一樣是 matcher 要求整個序列都匹配，而lookingAt 不要求。
lookingAt 方法雖然不須要整句都匹配，可是需從第一個字符開始匹配。
這兩個方法常常在輸入字符串的開始使用。 咱們經過下面這個例子，來解釋這個功能：
import java.util.regex.Matcher; import java.util.regex.Pattern; public class RegexMatches { private static final String REGEX = "foo"; private static final String INPUT = "fooooooooooooooooo"; private static final String INPUT2 = "ooooofoooooooooooo"; private static Pattern pattern; private static Matcher matcher; private static Matcher matcher2; public static void main( String args[] ){ pattern = Pattern.compile(REGEX); matcher = pattern.matcher(INPUT); matcher2 = pattern.matcher(INPUT2); System.out.println("Current REGEX is: "+REGEX); System.out.println("Current INPUT is: "+INPUT); System.out.println("Current INPUT2 is: "+INPUT2); System.out.println("lookingAt(): "+matcher.lookingAt()); //lookingAt(): 從第一個字符匹配，不要求整句匹配 System.out.println("matches(): "+matcher.matches()); //matches(): 整句匹配 System.out.println("lookingAt(): "+matcher2.lookingAt()); } } /* 以上實例編譯運行結果以下： Current REGEX is: foo Current INPUT is: fooooooooooooooooo Current INPUT2 is: ooooofoooooooooooo lookingAt(): true matches(): false lookingAt(): false */
replaceFirst 和 replaceAll 方法
replaceFirst 和 replaceAll 方法用來替換匹配正則表達式的文本。不一樣的是，replaceFirst 替換首次匹配，replaceAll 替換全部匹配。
下面的例子來解釋這個功能：
import java.util.regex.Matcher; import java.util.regex.Pattern; public class RegexMatches { private static String REGEX = "dog"; private static String INPUT = "The dog says meow. " + "All dogs say meow."; private static String REPLACE = "cat"; public static void main(String[] args) { Pattern p = Pattern.compile(REGEX);
// get a matcher object Matcher m = p.matcher(INPUT); // 找尋 字符串INPUT 中的 詞段p INPUT = m.replaceAll(REPLACE); // 使用 REPLACE 替換掉 詞段p System.out.println(INPUT); } } /* 以上實例編譯運行結果以下： The cat says meow. All cats say meow. */
appendReplacement 和 appendTail 方法
Matcher 類也提供了appendReplacement 和 appendTail 方法用於文本替換：
看下面的例子來解釋這個功能：
import java.util.regex.Matcher; import java.util.regex.Pattern; public class RegexMatches { private static String REGEX = "a*b"; private static String INPUT = "aabfooaabfooabfoob"; private static String REPLACE = "-"; public static void main(String[] args) { Pattern p = Pattern.compile(REGEX);
// 獲取 matcher 對象 Matcher m = p.matcher(INPUT); StringBuffer sb = new StringBuffer(); while(m.find()){ m.appendReplacement(sb,REPLACE); } m.appendTail(sb); System.out.println(sb.toString()); } } /* 以上實例編譯運行結果以下： -foo-foo-foo- */
PatternSyntaxException 類的方法
PatternSyntaxException 是一個非強制異常類，它指示一個正則表達式模式中的語法錯誤。
PatternSyntaxException 類提供了下面的方法來幫助咱們查看發生了什麼錯誤。
public String getDescription(): 獲取錯誤的描述。 public int getIndex() : 獲取錯誤的索引。 public String getPattern(): 獲取錯誤的正則表達式模式。 public String getMessage() : 返回多行字符串，包含語法錯誤及其索引的描述、錯誤的正則表達式模式和模式中錯誤索引的可視化指示。
Pre-article：Java 學習（6）：java Number & Math & String & 數組...經常使用類型
Next：Java 學習（8）：java 方法
相關文章
- 1. 日期正則表達式
- 2. java正則表達式學習筆記
- 3. java正則表達式的學習
- 4. java學習之正則表達式
- 5. JAVA學習筆記--正則表達式
- 6. java正則表達式學習
- 7. Java學習（17）--正則表達式
- 8. java正則表達式學習（二）
- 9. Java正則表達式
- 10. java正則表達式《-》
- 更多相關文章...
- • SQLite 日期 & 時間 - SQLite教程
- • Scala 正則表達式 - Scala教程
- • Tomcat學習筆記（史上最全tomcat學習筆記）
- • Kotlin學習（一）基本語法
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. 日期正則表達式
- 2. java正則表達式學習筆記
- 3. java正則表達式的學習
- 4. java學習之正則表達式
- 5. JAVA學習筆記--正則表達式
- 6. java正則表達式學習
- 7. Java學習（17）--正則表達式
- 8. java正則表達式學習（二）
- 9. Java正則表達式
- 10. java正則表達式《-》