java中的正则matches方法和find方法的区别

Java 正则表达式里find()方法的使用

package com.zte.st.dailybuild.dao;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * Created by 6092002943 on 2020/3/28.
 */
public class Test {

    public static void main(String[] args) {
        Pattern p = Pattern.compile("\\d{3,5}");
        Matcher m = p.matcher("123-4567812-910-11");

       /*print (m.matches ());
m.reset ();*/
        print(m.find());//true
        print(m.group());//123
        print(m.start() + "-" + m.end());//0-3： 1~-
        System.out.printf("换行--------------------\n");
        print(m.find());//true
        print(m.group());//45678
        print(m.start() + "-" + m.end());//4-9： 4~1
        System.out.printf("换行--------------------\n");
        print(m.find());//true
        print(m.group());//910
        print(m.start() + "-" + m.end());//12-15:9~-
        System.out.printf("换行--------------------\n");
        print(m.find());//false
        System.out.printf("换行--------------------\n");
        System.out.println();


        print(m.matches());//false
        System.out.printf("换行\n");
        //m.reset ();
        print(m.find());//true
        print(m.group());//45678
        print(m.start() + "-" + m.end());//4-9
        System.out.printf("换行\n");
        print(m.find());//true
        print(m.group());//910
        print(m.start() + "-" + m.end());//12-15
        System.out.printf("换行\n");
        print(m.find());//false
        System.out.printf("换行\n");
        print(m.find());//false
        System.out.printf("换行\n");
        System.out.println();

        print(m.matches());//false
        System.out.printf("换行\n");
        m.reset();
        print(m.find());//true
        print(m.group());//123
        print(m.start() + "-" + m.end());//0-3
        System.out.printf("换行\n");
        print(m.find());//true
        print(m.group());//45678
        print(m.start() + "-" + m.end());//4-9
        System.out.printf("换行\n");
        print(m.find());//true
        print(m.group());//910
        print(m.start() + "-" + m.end());//12-15
        System.out.printf("换行\n");
        print(m.find());//false
        System.out.printf("换行\n");
        System.out.println();

        print(m.lookingAt());//true
        print(m.lookingAt());//true
    }



    public static void print(Object o) {
        System.out.println(o);
    }

}

 

/*
* 　　 对这个程序的解释：这个程序最大的难点在于find()方法的理解
* 　　 在第一段程序中，find会一个字符一个字符的匹配，当检测到3的时候，发现已经有3个字符，那么这个find可以返回true了，但是没有完，它会继续检测，发现3的后面是-而不是数字，第一个find的结束，所以在group这个里输出123，从0到3（注意下标是从0开始的）
* 　　 第二个find从下标为3的字符开始找，也就是上次find结束的地方，那么这个find一上来就找到-，会不会因此而返回false，答案是不会，它会继续往后面找，看能不能在后面的字符串中找到符合条件的字符串片段，很幸运，它找到了，那就是45678，因为指定的字符串
* 　　片段的上限长度为5，所以在group输出45678而不是4567812，那么下标的始末为什么是4-9而不是4-8呢？虽然字符串片段的指定上限是5，但并不会因此就不继续往后面检查一位。
* 　　 第三个find从下标为9的地方开始找，1,2，-，发现都不行，继续找！9,1,0，-发现满足条件了，返回true，同时group里输出910，下标又为什么从12开始呢？因为find从下标为12处才找到满足条件的字符串片段。
* 　　 第四个find很可怜，-，1,1都不满足，后面又没有字符串了，所以只好返回false了、
* 　　 为什么加了matches和reset后输出结果又变得不一样了？先从matches说起，matches要求全部匹配才能返回true，但是很不幸字符串的长度一看就不止5个字符，所以返回false是毫无疑问的。具体来说，matches也是一个字符一个字符检查的，当他检查到第一个“-”时发现
* 　　不是数字了，所以返回了false(但是就算全部是数字也返回false,就如上面所说的)，关键是这个matches对后面的find有影响，因为find是从matches停止位开始检查的，就像下一个find是从上一个find停止位开始检查的一样，所以输出结果和上一段不一样了。
* 　　 但是加了reset后，匹配器被重置，就相当于find可以从字符串的第一个字符开始检查了。
* 　　 lookingAt()是每一次都从头开始检查是不是符合要求，不管有多少个lookingAt(),而123是符合要求的，所以会输出true
* 　　 注意只有匹配成功，才可以通过 start、end 和 group 方法获取更多信息。
*/

 

java中用正则表达式截取字符串中第一个出现的英文左括号之前的字符串。比如：北京市（海淀区）（朝阳区）（西城区），截取结果为：北京市。正则表达式为（）

• A   ".*?(?=\\()"

• B   ".*?(?=\()"

• C　　".*(?=\\()"

• D　　".*(?=\()"

 

http://www.cnblogs.com/xudong-bupt/p/3586889.html

1.什么是正则表达式的贪婪与非贪婪匹配

如：String str="abcaxc";

Patter p="ab*c";

贪婪匹配:正则表达式一般趋向于最大长度匹配，也就是所谓的贪婪匹配。如上面使用模式p匹配字符串str，结果就是匹配到：abcaxc(ab*c)。

非贪婪匹配：就是匹配到结果就好，就少的匹配字符。如上面使用模式p匹配字符串str，结果就是匹配到：abc(ab*c)。

2.编程中如何区分两种模式

默认是贪婪模式；在量词后面直接加上一个问号？就是非贪婪模式。

量词：{m,n}：m到n个

*：任意多个

+：一个到多个

？：0或一个

以上来自博主的博客，然后这道题目

.表示除\n之外的任意字符

*表示匹配0-无穷 
+表示匹配1-无穷

(?=Expression) 顺序环视，(?=\\()就是匹配正括号

懒惰模式正则： 
src=".*? (?=\\()） "

结果：北京市

因为匹配到第一个"就结束了一次匹配。不会继续向后匹配。因为他懒惰嘛。

 

 

A ".*?(?=\\()" 
B ".*?(?=\()"
C ".*(?=\\()"
D ".*(?=\()"
 

前面的.*?是非贪婪匹配的意思， 表示找到最小的就可以了

(?=Expression) 顺序环视，(?=\\()就是匹配正括号

String text = "北京市(海淀区)(朝阳区)(西城区)";Pattern pattern = Pattern.compile(".*?(?=\\()" );
Matcher matcher = pattern.matcher(text);
if (matcher.find()) {
System.out.println(matcher.group(0));
}

 

解析

 

选A， 知识点是正则表达式中的贪婪匹配。

1、正则表达式中元字符:

".":匹配除去\n换行符的任意字符

"*"：匹配前面子表达式任意次

"?":匹配前面子表达式的0次或1次，如果前面也是元字符，那么它就是非贪婪匹配了(默认是贪婪匹配的)。

2、B中 ".*?(?=\\()"中后面的(?=\\()它是(?=assert）的形式，叫做顺序环视，也就是前面.*?匹配到的字符后面必须要紧接着有assrt中声明的值，也就是左括号(其中\\都是转义字符)，但是匹配的到的串是不包含assrt中声明的内容的。

3、题中，原串 “北京市（海淀区）（朝阳区）（西城区）”，首先匹配到北京市（前部分），然后北京市后面有左括号( ，这是后面顺序环视部分，但是不包括左括号，这样整个串就匹配完了，截取到的串为“北京市”。

案例2：

 

Pattern pattern = Pattern.compile("[a-z|A-Z]{3}\\d+", Pattern.CASE_INSENSITIVE);
Matcher matcher = pattern.matcher("DUT1DUT2DUT3");
ArrayList<String> list = new ArrayList<>();
while (matcher.find()) {
    System.out.println(matcher.group());
    }

输出：DUT1   DUT2  DUT3

参考文章：正则表达式Pattern和Matcher详解