1.简单认识正则:      

public class Test {

    public static void main(String[] args) {
//简单认识正则
p("abc".matches("..."));
p("a8729a".replaceAll("\\d", "-"));
} public static void p(Object o){
System.out.println(o);
} }

一个.代表一个字母

true
a----a

2.简单认识Pattern和Matcher:                

     /**
* 比下面一句话的好处:
* 1.Pattern.compile将正则表达式先编译了,速度更快;
* 2.Pattern 和Matcher有更多的方法,是String.matches所没有的;
*/
Pattern p = Pattern.compile("[a-z]{3}");
Matcher m = p.matcher("fgh");
p(m.matches()); p("fgh".matches("[a-z]{3}")); //相当于上面三句话

true
true

解释:

/**
* Pattern:模式,[a-z]{3}的这种模式。
* Matcher:匹配器;[a-z]{3}的这种模式去匹配"fgh"这个字符串;
* 匹配这个字符串的过程之中,要注意有可能产生多个结果,匹配的结果会保留在Matcher对象m里面。
* 这个结果是匹配还是不匹配呢?调用m.matches();
*/

3.初步认识. * + ?                              

        /**
* 初步认识 . * +
* . 任意一个字符
* * 0个或多个
* + 1个或多个
* ? 0个或1个,可有可无。
*/
p("a".matches(".")); //true
p("aa".matches("aa")); //true
p("aaaa".matches("a*")); //true
p("aaaa".matches("a+")); //true
p("".matches("a*")); //true
p("aaaa".matches("a?")); //false
p("".matches("a?")); //true
p("a".matches("a?")); //true
p("214523145234532".matches("\\d{3,100}")); //true
p("192.168.0.aaa".matches("\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}")); //false
p("192".matches("[0-2][0-9][0-9]")); //true

解释:

.是一个特殊的字符,用转义字符,所以写\.       可是\在正则表达式里面确实是\,但是在java里面比较特殊,用两个\\。

所以\\.代表.这个字符。

4.范围:

/**
* 范围
* []里面匹配一个字符。中括号里面写的再长,也是匹配一个字符
*/
p("a".matches("[abc]"));
p("a".matches("[^abc]")); //取反,除了abc之外的内容
p("A".matches("[a-zA-Z]")); //大写字母或小写字母
p("A".matches("[a-z]|[A-Z]")); //这种写法和上面写法一样
p("A".matches("[a-z[A-Z]]")); //也是a-z或者A-Z的意思
p("R".matches("[A-Z&&[RFG]]")); //A-Z中的,并且是RFG之一的

true
false
true
true
true
true

5.认识 \s  \w   \d   \

     /**
* 认识 \s \w \d \
* \s 空白字符,包含空格,tab、换行、制表符、回车
* \w 构成单词的字符[a-zA-Z_0-9]
* 在java里面字符串\\代表的是一个反斜线\;用正则表达式去匹配一个反斜线\:
* 正则表达式本身要匹配一个反斜线的话,需要用两个反斜线;
* 然后你要用字符串把这个正则表达式表现出来的时候,每一个反斜线都要用两个反斜线替代;
* 在java里面一个反斜线\和后面的字符会合在一起,构成一个转义字符;所以在java里面一个反斜线\必须用两个反斜线来替代;
*/
p(" \n\r\t".matches("\\s{4}"));
p(" ".matches("\\S"));
p("a_8".matches("\\w{3}"));
p("abc888&^%".matches("[a-z]{1,3}\\d+[&^#%]+"));
p("\\".matches("\\\\")); //如果写:p("\\".matches("\\"))的话:
//matches("\\")里的\\会被正则表达式认为成它是一个反斜线;
//在正则表达式里面,一个\也会是一个特殊字符,它会和后面的字符合在一起,那第一个双引号"又没有配对的了;
//所以要在正则表达式里,匹配一个\,要写成:\\\\

true
false
true
true
true

解释:

/**
* 怎么用正则表达式匹配一个反斜线呢?
* 在java里面 一个\必须用两个\\来替代。
* 正则表达式本身要匹配一个反斜线,使用\\来匹配的,然后你要用字符串把这个正则表达式表现出来的时候,每一个\都要用两个\\替代;
* 所以要在正则表达式里面匹配一个反斜线,写4个\
*/

6.POSIX Style风格:

     //POSIX Style
//参考API \p{Lower} A lower-case alphabetic character: [a-z]
p("a".matches("\\p{Lower}")); //true

6.boundary  边界匹配:

     /**
* boundary 边界匹配
* ^ 位于[]外面,代表开头
* \b 一个单词的边界;单词边界:空格、空白字符、各种各样的特殊字符、换行的时候等等,都算单词边界;
*/
p("hello sir".matches("^h.*")); //true
p("hello sir".matches(".*ir$")); //true
p("hello sir".matches("^h[a-z]{1,3}o\\b.*")); //true
p("hellosir".matches("^h[a-z]{1,3}o\\b.*")); //false

7.匹配空白行:

     /**
* white lines空白行:
*/
//以空白字符开头的并且不是换行符,紧跟0个或多个,以换行符结尾;
p(" \n".matches("^[\\s&&[^\\n]]*\\n$")); //true

8.匹配Email地址:

     /**
* 匹配Email地址的正则表达式
* 构成单词的字符或者是.- 出现1次或多次 @ 单词字符或.- 1次或多次 . 单词字符或.- 1次或多次
* 注意.是元字符代表任意字符,这里表示.要用 \\. 代表
*/
p("asdfasdfsafsf@dsdfsdf.com".matches("[\\w[.-]]+@[\\w[.-]]+\\.[\\w]+")); //true

.写在[ ]里面表示.          [.-]表示.或者-

例子:

p("ab4com".matches("[a-z]{2}[.]{1}\\w{3}"));      ——false,因为要求两个a-z的字母后面紧接的是.   所以false

9.matches()、find()、lookingAt():

     /**
* matches find lookingAt
* matches 是否匹配 matches()永远是匹配整个字符串
* m.find(): 找一个和模式相匹配的子串;是找子串,而不是匹配整个字符串;
* 找着一个之后,正则引擎会将找到的子串截掉,然后从剩下的字符串里再找;
* lookingAt(): 每次找,都是从开头位置找;
*/
Pattern p = Pattern.compile("\\d{3,5}");
String s = "123-34345-234-00";
Matcher m = p.matcher(s);
p(m.matches()); //false p(m.find()); //true
p(m.find()); //true
p(m.find()); //false
p(m.find()); //false //上面的结果解释:
//m.matches()运行时,开始分析"123-34345-234-00",分析到123-发现已经不匹配了,停止,返回false;
//m.find()执行,继续从34345-234-00开始找,find第一个34345返回true;find第二个234返回true,后面两个false
 /**
* start():找到的字符串的起始位置;
* end(): 找到的字符串的结束位置;是找到的字符的后面一个位置;
* 必须能够找到,否则打印会报错;
*/
Pattern p = Pattern.compile("\\d{3,5}");
String s = "123-34345-234-00";
Matcher m = p.matcher(s);
p(m.matches()); //false
m.reset();
p(m.find()); //true
p(m.start() + "-" + m.end()); //0-3 p(m.find()); //true
p(m.start() + "-" + m.end()); //4-9 p(m.find()); //true
p(m.start() + "-" + m.end()); //10-13 p(m.find()); //false p(m.lookingAt());
p(m.lookingAt());
p(m.lookingAt());
p(m.lookingAt()); //上面结果解释:
//m.matches()执行,分析到123-发现已经不匹配了,停止,返回false;
//m.reset()执行,m又回到了"123-34345-234-00"的开头位置。从头开始分析(回到初始的状态);
//m.lookingAt():每次从开头位置找,每次找到123,就都返回true

10.replacement:

 /**
* replacement
* group(): 输出匹配到的子串;整个的正则表达式可以看作组号为0的一个组;
*/
//将下面的字符串中java全都替换成大写的:
Pattern p = Pattern.compile("java", Pattern.CASE_INSENSITIVE);
Matcher m = p.matcher("java Java JAVa JaVa IloveJAVA you hateJava");
p(m.replaceAll("JAVA"));

JAVA JAVA JAVA JAVA IloveJAVA you hateJAVA

 //将下面字符串中,找到的java,第奇数个替换成JAVA,第偶数个替换成java
Pattern p = Pattern.compile("java", Pattern.CASE_INSENSITIVE);
Matcher m = p.matcher("java Java JAVa JaVa IloveJAVA you hateJava afasdfasdf");
StringBuffer buf = new StringBuffer();
int count = 0;
while(m.find()){
count++;
if(count%2 == 0){
m.appendReplacement(buf, "java");
}else{
m.appendReplacement(buf, "JAVA");
}
}
m.appendTail(buf);
p(buf);

JAVA java JAVA java IloveJAVA you hatejava afasdfasdf

11.分组:group:

         /**
* group 分组
* group(): 返回整个正则表达式所匹配的子串;
*/
Pattern p = Pattern.compile("\\d{3,5}[a-z]{2}");
String s = "123aa-34345bb-234cc-00";
Matcher m = p.matcher(s);
while(m.find()) {
p(m.group());
}

123aa
34345bb
234cc

         //将上面字符串中,匹配的3-5位的数字拿出来:
//要知道第几组:数左边的小括号,第一个小括号为第1组,第二个小括号为第2组...
Pattern p = Pattern.compile("(\\d{3,5})([a-z]{2})");
String s = "123aa-34345bb-234cc-00";
Matcher m = p.matcher(s);
while(m.find()){
p(m.group(1));
}

123
34345
234

12.抓取网页Email地址的例子:

 package com.cy.regexp;

 import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.regex.Matcher;
import java.util.regex.Pattern; public class EmailSpider { @SuppressWarnings("resource")
public static void main(String[] args) {
try {
BufferedReader br = new BufferedReader(new FileReader("D:\\fromEmail.html"));
BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\findEmail.txt")); String line = "";
while((line = br.readLine()) != null){
writeToFile(line, bw);
}
bw.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
} public static void writeToFile(String line, BufferedWriter bw) throws IOException{
Pattern p = Pattern.compile("[\\w[.-]]+@[\\w[.-]]+\\.[\\w]+");
Matcher m = p.matcher(line);
while(m.find()){
bw.write(m.group());
bw.newLine();
}
}
}

13.修饰符、限定词:

         /**
* qulifiers 修饰符 限定词 在数量后面 加限定词
* Greedy quantifiers 贪婪的;默认的写法都是贪婪的;x? x* x+ x{n} x{n,} x{n,m}都是贪婪的
* Reluctant quantifiers: 勉强的,非贪婪的,和Greedy正好相反:x?? x*? x+? ...
* Possessive quantifiers: 独占的;和贪婪的类似,.{3,10}+,一下吞进去10个字符,不匹配时但是不往外吐,就是找不着;
*/ Pattern p = Pattern.compile(".{3,10}[0-9]");
String s = "aaaa5bbbb6";
Matcher m = p.matcher(s);
if(m.find()){
p(m.start() + "-" + m.end()); //0-10
}else{
p("not match!");
} Pattern p = Pattern.compile(".{3,10}?[0-9]");
String s = "aaaa5bbbb6";
Matcher m = p.matcher(s);
if(m.find()){
p(m.start() + "-" + m.end()); //0-5
}else{
p("not match!");
} Pattern p = Pattern.compile(".{3,10}+[0-9]");
String s = "aaaa5bbbb6";
Matcher m = p.matcher(s);
if(m.find()){
p(m.start() + "-" + m.end());
}else{
p("not match!"); //not match!
} Pattern p = Pattern.compile(".{3,10}+[0-9]");
String s = "aaaa5bbbb68";
Matcher m = p.matcher(s);
if(m.find()){
p(m.start() + "-" + m.end()); //0-11
}else{
p("not match!");
}

14.non-capturing groups 非捕获组:

         /**
* non-capturing groups
* 非捕获组: 如果符合这个条件就捕获;如果不符合这个条件就不捕获
*/
//这个正则表达式匹配 3个字母的后面紧跟的是一个a,像这样的才去匹配它;而且这个a不被抓出来
// ?=a 不捕获这个a
//(?=X) X, via zero-width positive lookahead lookahead从头开始看
Pattern p = Pattern.compile(".{3}(?=a)");
String s = "444a66b";
Matcher m = p.matcher(s);
while(m.find()) {
p(m.group()); //
} //前面是a的,3个字母
Pattern p = Pattern.compile("(?=a).{3}");
String s = "444a66b";
Matcher m = p.matcher(s);
while(m.find()) {
p(m.group()); //a66
} //(?!a) 前面不是a的,3个字母
Pattern p = Pattern.compile("(?!a).{3}");
String s = "444a66b";
Matcher m = p.matcher(s);
while(m.find()) {
p(m.group()); //444 66b
} //3个字母, 后面不是a
Pattern p = Pattern.compile(".{3}(?!a)");
String s = "444a66b";
Matcher m = p.matcher(s);
while(m.find()) {
p(m.group()); //44a 66b
} //3个字母,从后往前数,不能是a
Pattern p = Pattern.compile(".{3}(?<!a)");
String s = "444a66b";
Matcher m = p.matcher(s);
while(m.find()) {
p(m.group()); //444 a66
} //3个字母,从后往前数,是a, 包含a
Pattern p = Pattern.compile(".{3}(?<=a)");
String s = "444a66b";
Matcher m = p.matcher(s);
while(m.find()) {
p(m.group()); //44a
}

15.back refenrences  向前引用:

         /**
* back refenrences
* 向前引用;
* (\\d\\d)匹配两个数字,作为结果;\\1 指的是后面的东西必须和前面第一个group找到的结果一模一样
* 第一个group找到的是12,后面是12,和前面第1个group找到的东西一样, 所以返回true
*/
Pattern p = Pattern.compile("(\\d\\d)\\1");
String s = "1212";
Matcher m = p.matcher(s);
p(m.matches()); //true //第2个group抓到的是2,后面的结果要和第2个group抓到的内容一样
Pattern p = Pattern.compile("(\\d(\\d))\\2");
String s = "122";
Matcher m = p.matcher(s); //true
p(m.matches());

16.flags的简写:

      /**
* flags的简写
* DOTALL .可以匹配所有的字符,默认的.是不匹配换行符的;
* CASE_INSENSITIVE 忽略大小写
* API: Case-insensitive matching can also be enabled via the embedded flag expression (?i).
*/
Pattern p = Pattern.compile("java", Pattern.CASE_INSENSITIVE); //(?i) 也是非捕获组 跟上面的写法一模一样,上面写法的简写
p("Java".matches("(?i)(java)")); //true

java正则表达式学习的更多相关文章

  1. java 正则表达式学习

    一. Java正则表达式 在程序开发中,难免会遇到需要匹配.查找.替换.判断字符串的情况发生,而这些情况有时又比较复杂. 因此,学习及使用正则表达式,便成了解决这一矛盾的主要手段. 正则表达式是一种可 ...

  2. java正则表达式学习笔记

    Java 正则表达式语法 为了更有效的使用正则表达式,需要了解正则表达式语法.正则表达式语法很复杂,可以写出非常高级的表达式.只有通过大量的练习才能掌握这些语法规则. 本篇文字,我们将通过例子了解正则 ...

  3. Java 正则表达式学习总结和一些小例子

    从Java1.4起,Java核心API就引入了java.util.regex程序包,它是一种有价值的基础工具,可以用于很多类型的文本处理, 如匹配,搜索,提取和分析结构化内容. java.util.r ...

  4. Java正则表达式学习与记录

    转载自:http://www.runoob.com/java/java-regular-expressions.html 正则表达式定义了字符串的模式,用于搜索.编辑或处理文本. 1.正则表达式中字符 ...

  5. java正则表达式基础知识(转)

    1基础 2.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-z&& ...

  6. 正则表达式学习笔记(附:Java版示例代码)

    具体学习推荐:正则表达式30分钟入门教程 .         除换行符以外的任意字符\w      word,正常字符,可以当做变量名的,字母.数字.下划线.汉字\s        space,空白符 ...

  7. Java基础学习总结(35)——Java正则表达式详解

    在Sun的Java JDK 1.40版本中,Java自带了支持正则表达式的包,本文就抛砖引玉地介绍了如何使用java.util.regex包. 可粗略估计一下,除了偶尔用Linux的外,其他Linu  ...

  8. Java 正则表达式[转载]

    PS:转载自CSDN博客看上去很美 众所周知,在程序开发中,难免会遇到需要匹配.查找.替换.判断字符串的情况发生,而这些情况有时又比较复杂,如果用纯编码方式解决,往往会浪费程序员的时间及精力.因此,学 ...

  9. Java正则表达式的应用

    在很多种情况下,我们都必须对字符串进行匹配,以便判断字符串的格式是否符合要求,对字符串中的内容进行提取.比如,我要从一段话aabdfe中,判断这段话是否有包含ab这个词,那么如果用if-else来判断 ...

随机推荐

  1. Oracle 将另外一张表的列更新到本表的列

    Oracle写法: update temp_agentpay_df q set q.up_batch_bizid=(select c.batch_bizid from temp_df_id c whe ...

  2. Mysql/Mariadb 升级注意事项

    因需要使用到分区表,在业务不中断的情况下,可以新增分区,需要将原来的Mariadb10.1.25版本升级到Mariadb10.3.8. 1.升级步骤如下 1)新搭建Mariadb10.3.8版本的DB ...

  3. 参数 out

    function outtest(out jo: ISuperObject; out s: string):Boolean; begin //进入函数时 jo =nil ErrStr = '' Res ...

  4. 1.2 C++命名空间(namespace)

    参考:http://www.weixueyuan.net/view/6326.html 总结: C++语言引入命名空间(Namespace)这一概念主要是为了避免命名冲突,其关键字为 namespac ...

  5. 玩转X-CTR100 | X-Assistant串口助手控制功能

      更多塔克创新资讯欢迎登陆[塔克社区 www.xtark.cn ][塔克博客 www.cnblogs.com/xtark/ ]       X-CTR100控制器配套的X-Assistant串口调试 ...

  6. DevExpress v17.2新版亮点—WPF篇(七)

    用户界面套包DevExpress v17.2终于正式发布,本站将以连载的形式为大家介绍各版本新增内容.本文将介绍了DevExpress WPF v17.2 新的Hamburger Menu.Sched ...

  7. 第一个dubbo+zookeeper项目例子

    公司项目要用这两个东西,于是打算学习它. 首先我的理解dubbo是什么?zookeeper是什么?为什要这么搞. 项目分层: 传统的,mvc -->垂直架构(将模块抽取成单独项目,项目互相调用) ...

  8. python struct模块的使用

    struct模块中的函数 函数 return explain pack(fmt,v1,v2…) string 按照给定的格式(fmt),把数据转换成字符串(字节流),并将该字符串返回. pack_in ...

  9. ide fix pack for delph 10.2.3发布了

    http://andy.jgknet.de/blog/ide-tools/ide-fix-pack/ IDE Fix Pack是RAD Studio IDE,Win32 / Win64 / Andoi ...

  10. OC基础:内存(内存管理) 分类: ios学习 OC 2015-06-25 16:50 73人阅读 评论(0) 收藏

    自动释放池: @autoreleasepool { } 内存管理机制       谁污染,谁治理 垃圾回收机制:gc(Garbage collection),由系统管理内存,开发人员不需要管理. OC ...