betway必威-betway必威官方网站
做最好的网站

黑马程序员,正则表达式

---------- android培养和训练、java培养和操练、期待与您调换! ---------- 

Java基础柒-正则表明式,java基础正则表达式

概述

顺应一定规则的表达式

特别用来操作字符串

一、概述

Java基础七-正则表明式

特点:

用以一些特定的号子来表示一些代码操作,那样就足以简化书写

因而读书正则表达式,便是在攻读有个别特殊符号的行使

  1、 概念:符合一定规则的表达式。

一、定义:

一定的符号的重组

 

好处:

能够简化对字符串的复杂操作

  二、 功能:用于特意操作字符串。

二、作用:

用来操作字符串数据

 

弊端:

标志定义越来越多,正则越长,阅读性越差

  三、 特点:用一些一定的符号来表示一些代码操作,那样能够简化书写。

三、优缺点

简化代码,可是读书性差

 

规则

上面只是局地粗略的平整,具体详细规则查询API文书档案

Greedy 数量词
X?    X,叁回或二回也从不
X*    X,零次或频仍
X     X,一回或频仍
X{n}    X,恰好 n 次
X{n,}    X,至少 n 次
X{n,m}    X,至少 n 次,可是不超越 m 次
   
字符类
[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    空白字符:[ tnx0Bfr]
S    非空白字符:[^s]
w    单词字符:[a-zA-Z_0-9]
W    非单词字符:[^w]

组和捕获

捕获组可以透过从左到右计算其开括号来编号。比如,在表述式 ((A)(B(C))) 中,存在五个这么的组:

1        ((A)(B(C)))
2        A
3        (B(C))
4        (C)
组零始终代表全体表明式。

  四、 好处:能够简化对字符串的纷繁芜杂操作。

四、引入

Pattern与Matcher

java.util.regex包中定义了正则操作的连带对象

Pattern:正则表明式的编写翻译表现情势,内部封装了种种正则格局

Matcher:正则相称引擎,它是依靠帕特tern产生的,每种Pattern对象可与五个字符串进行相称,所以能够生出五个相称器Matcher

标准的调用顺序是

   1: Pattern p = Pattern.compile("a*b");

   2: Matcher m = p.matcher("aaaaab");

   3: boolean b = m.matches();

  5、 弊端:符合定义越来越多,正则越长,阅读性越差。

4.1 问题

判别3个编号是或不是是QQ号?

不是零方始

6-15位

只含有数字

广阔操作

String类封装的多样字符串操作实际都以基于Pattern与Matcher操作的,只不过封装起来更有益于,可是意义比较单纯

2、常见规则

4.2 代码

 1         int len = qq.length();
 2         
 3         if(len>=5 && len<=15){
 4             
 5             if(!qq.startsWith("0")){
 6                 try {
 7                 long l = Long.parseLong(qq);
 8                 
 9                 System.out.println(l ":正确");
10                 }catch(NumberFormatException e){
11                     System.out.println(qq ":含有非法字符");
12                 }
13                 
14             }else{
15                 System.out.println(qq ":不能0开头");
16             }
17         }else{
18             System.out.println(qq ":长度错误");
19         }
20     }

 

String类中

匹配
boolean matches(String regex)
Tells whether or not this string matches the given regular expression.

切割
String[] split(String regex)
Splits this string around matches of the given regular expression.

替换
String replaceAll(String regex, String replacement)
Replaces each substring of this string that matches the given regular expression with the given replacement.

  1、字符类

4.3 要点

if(!qq.startsWith("0"))

看清不是零始发

long l = Long.parseLong(qq);

判别全部都以数字

 

 

Matcher类中

boolean matches()
Attempts to match the entire region against the pattern.

String replaceAll(String replacement)
Replaces every subsequence of the input sequence that matches the pattern with the given replacement string.

boolean find()
Attempts to find the next subsequence of the input sequence that matches the pattern.

String group()
Returns the input subsequence matched by the previous match.

    [abc]:表示a、b或 c

伍、正则表达式消除引进

实例

    [^abc]:表示其他字符,除了 a、b或 c

5.1 代码

String regex = "[1-9][0-9]{四,1四}";//正则表明式。

boolean b = qq.matches(regex);              

System.out.println(qq ":" b);

 

去叠词

   1: String str = "我我...我我我...我我要..要要要要.要学学.学.学学学..编编编编.编..编编编.程.程程程.程程程程.程程";

   2:         

   3: //去掉字符“.”

   4: str = str.replaceAll("\. ","");

   5: //叠词变单字

   6: str = str.replaceAll("(.)\1 ","$1");

   7:  

   8: System.out.println(str);

    [a-zA-Z]:表示a到 z或 A 到 Z

5.2 说明

String regex = "[1-9][0-9]{4,14}";

第一位[1-9]

第二位[0-9]

后面[0-9]{4,14}重复4-14次

中括号表示取值,大括号表示次数,小括号表示组

 

IP排序

   1: String str = "192.168.0.1 10.10.10.10 2.2.2.2 255.255.255.255";

   2:  

   3: //每段都加上2个0

   4: str = str.replaceAll("(\d )","00$1");

   5:  

   6: //每段ip位数对齐成3位

   7: str = str.replaceAll("0 (\d{3})","$1");

   8:  

   9: //分段存放

  10: String[] arr = str.split(" ");

  11:  

  12: //存放到set集合中进行字符串排序

  13: TreeSet<String> ts = new TreeSet<String>();

  14:  

  15: for(String s : arr)

  16: {

  17:     ts.add(s);

  18: }

  19:  

  20: //去掉补齐的0位

  21: for(String s: ts)

  22: {

  23:     s = s.replaceAll("0 ([1-9] )","$1");

  24:     System.out.println(s);

  25: }

  26:  

  27: System.out.println(args.length);

    [a-d[m-p]]:表示a到 d或 m 到 p([a-dm-p](并集))

6、正则表明式的构造摘要

java.util.regex

类 Pattern中

 

 

网页爬虫

   1: public static void getMail() throws Exception

   2: {

   3:     //网络上的url资源

   4:     URL url = new URL("http://www.cnblogs.com/feng-c-x/p/3300060.htm");

   5:     

   6:     //建立连接

   7:     URLConnection conn = url.openConnection();

   8:     

   9:     //封装读取流

  10:     BufferedReader bufr = 

  11:         new BufferedReader(new InputStreamReader(conn.getInputStream()));

  12:  

  13:     

  14:     String line = null;

  15:     

  16:     //定义正则邮箱规则

  17:     String regex = "\w @\w (\.\w ){1,3}";

  18:     

  19:     //编译成正则对象

  20:     Pattern p = Pattern.compile(regex);

  21:     

  22:     //遍历查找邮箱字符串

  23:     while( (line = bufr.readLine()) != null)

  24:     {

  25:         Matcher m = p.matcher(line);

  26:  

  27:         while(m.find())

  28:         {

  29:             System.out.println(m.group());

  30:         }

  31:     }

  32: }

    [a-z&&[def]]:d、e或 f(交集)

7、正则表明式的构造摘要简要介绍

    [a-z&&[^bc]]:表示a到 z,除了 b和 c:[ad-z](减去)

7.1 字符类

[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](减去)

 

    [a-z&&[^m-p]]:表示a到 z,而非 m到 p:[a-lq-z](减去)

7.2 字符

x 字符 x

\ 反斜线字符

 

  2、预订义字符

七.叁 预定义字符类

. 任何字符(与行终止符可能10分也恐怕不相配)

d 数字:[0-9]

D 非数字: [^0-9]

s 空白字符:[ tnx0Bfr]

S 非空白字符:[^s]

w 单词字符:[a-zA-Z_0-9]

W 非单词字符:[^w]

 

    . : 任何字符(与行终止符大概极度也恐怕不相称)

7.4 Greedy 数量词

X? X,三次或三次也未曾

X* X,零次或频仍

X X,一回或频繁

X{n} X,恰好 n 次

X{n,} X,至少 n 次

X{n,m} X,至少 n 次,可是不超越 m 次

 

    d:数字:[0-9]

7.五 边界相称器

^ 行的初步

$ 行的最后

b 单词边界

B 非单词边界

A 输入的发轫

G 上贰个金童玉女的尾声

Z 输入的最后,仅用于最后的甘休符(要是局地话)

z 输入的末尾

 

 

    D:非数字: [^0-9]

8、正则表明式对字符的广大操作

                    * 正则表达式对字符串的周围操作:

                    * 1, 匹配。

                    *             其实使用的便是String类中的matches方法。

                    *

                    * 2,切割。

                    *             其实选用的正是String类中的split方法。

                    *

                    * 3,替换。

                    *             其实采纳的便是String类中的replaceAll()方法。

                    *

                    * 4,获取。

* 将正则规则举行对象的包装。
* Pattern p = Pattern.compile("a*b");
* //通过正则对象的matcher方法字符串相关联。获取要对字符串操作的相称器对象Matcher .
* Matcher m = p.matcher("aaaaab");
* //通过Matcher相配器对象的主意对字符串进行操作。
* boolean b = m.matches();

    s:空白字符:[ tnx0Bfr]

8.1 匹配

//相称手提式有线电话机号码是或不是科学。

String tel = "15800001111";

String regex = "1[358]\d{9}";  

boolean b = tel.matches(regex);

System.out.println(tel ":" b);

 

    S:非空白字符:[^s]

8.2 切割

将字符串中的人名分割开

String str = "zhangsanttttxiaoqiangmmmmmmzhaoliu";

String[] names = str.split("(.)\1 ");//str.split("\.");

for(String name : names){

         System.out.println(name);

}

小括号是组,(.)是首先组,\1是1,代表第二组,也正是复用, 号表示相继或频仍

“ ”以空格切

“#”以#号切

比方字符串中有五个空格“ ”,多少个空格

 

 

    w:单词字符:[a-zA-Z_0-9]

8.3 替换

将多少个假名替换到3个

String str = "zhangsanttttxiaoqiangmmmmmmzhaoliu";

str = str.replaceAll("(.)\1 ", "$1");

System.out.println(str);

将电话号码中间3位用*号代替

String tel = "15800001111";//158****1111;

tel = tel.replaceAll("(\d{3})\d{4}(\d{4})", "$1****$2");

System.out.println(tel);

 

("(.)\壹 ", "$一") $一是用第3个参数的首先组数据,$是引用上1参数

那样能够将八个t和四个m换到2个

 

("(\d{3})\d{4}(\d{4})", "$1****$二")保留电话号码的头和尾,中间我直接用6个*号代替就好了

(\d{三})将数字再次二遍并且把它座落第2组里面

 

    W:非单词字符:[^w]

8.4 获取

将字符串中多个字符的单词寻觅来

 

String str = "da jia hao,ming tian bu fang jia!";

String regex = "\b[a-z]{3}\b";

//一,将正则封装成对象。

Pattern p = Pattern.compile(regex);

//2, 通过正则对象得到相称器对象。

Matcher m = p.matcher(str);

//使用Matcher对象的主意对字符串进行操作。

//既然要拿走四个假名组成的单词

//查找。 find();

System.out.println(str);

while(m.find()){

         System.out.println(m.group());//获取相配的子种类

         System.out.println(m.start() ":" m.end());

}

 

"\b[a-z]{3}\b", \b代表字符边界 ,[a-z]{三}代表多少个小写字母

获得的多个步骤

 

 

  三、边界相称符

九、正则表达式实例

                    * 壹,医治口吃:笔者自家...小编自家...作者自家自家要...要要要要...要要要要..学学学学学...学学编编...编编编编..编..程程...程程...程程程

必威官方网站,                    * 二,对ip地址排序。

                    * 三,对邮件地址校验。

 

    ^:行的始发

九.一 医治口吃

String str = "作者本人...作者本人...作者本身本身要...要要要要...要要要要..学学学学学...学学编编...编编编编..编..程程...程程...程程程";

 

//一,将字符串中.去掉。 用替换。

str = str.replaceAll("\. ", "");

System.out.println(str);

                  

//二,替换叠词。

str = str.replaceAll("(.)\1 ", "$1");

System.out.println(str);

 

    $ :行的末尾

玖.2 对ip地址排序

String ip_str = "192.168.10.34  127.0.0.1  3.3.3.3  105.70.11.55";

//一,为了让ip能够根据字符串顺序相比较,只要让ip的每1段的位数一样。

//所以,补零,遵照种种人所需做多0开始展览增加补充。每一段都加五个0.

ip_str = ip_str.replaceAll("(\d )", "00$1");

System.out.println(ip_str);

 

//然后每1段保留数字4位。

ip_str = ip_str.replaceAll("0*(\d{3})", "$1");

System.out.println(ip_str);

 

 

//一,将ip地址切出。

String[] ips = ip_str.split(" ");

 

TreeSet<String> ts = new TreeSet<String>();

                  

for(String  ip : ips){

//      System.out.println(ip);

         ts.add(ip);

}

 

for(String ip : ts){

         System.out.println(ip.replaceAll("0*(\d )", "$1"));

}

 

本文由betway必威发布于网页设计,转载请注明出处:黑马程序员,正则表达式

Ctrl+D 将本页面保存为书签,全面了解最新资讯,方便快捷。