精华内容
下载资源
问答
  • Pattern和Matcher

    2017-04-20 18:07:12
    Pattern Matcher 基础实现 Matcher的find(),matches(),lookingAt()方法的区别 使用find()注意点

    jdk中文文档地址: http://www.javaweb.cc/help/JavaAPI1.6/java/util/regex/Pattern.html

    基础实现

    1. Pattern直接匹配

    优点:比较方便、简洁
    缺点:模式不能重复使用,使用方式比较单一

        boolean b = Pattern.matches("正则表达式规则", "需要匹配的字符串");
    

    2. Matcher匹配

    优点:模式可以重复使用,创建多个Matcher。Pattern可以加入需要的属性,Matcher有多种匹配方式和很多内置方法,更灵活、更强大。
    缺点:在只需要匹配一次的简单应用上,Pattern直接匹配开销更少

         Pattern p = Pattern.compile("正则表达式规则");
         Matcher m = p.matcher("需要匹配的字符串");
         boolean b = m.matches();

    相关知识归纳

    Matcher的find(),matches(),lookingAt()方法的区别

    • matches()
      方法尝试将整个输入序列与该模式匹配。相当于正则加上了边界匹配器符号^&
    • lookingAt()
      尝试将输入序列从头开始与该模式匹配。 相当于正则加上了边界匹配器符号^
    • find()
      方法扫描输入序列以查找与该模式匹配的下一个子序列。
        String matchStr = "zxbzxbzxb";
        String reg = "zxb";
        Pattern pattern = Pattern.compile(reg);
        Matcher matcher = pattern.matcher(matchStr);
        // matches() 
        //System.out.println(matcher.matches());// false,匹配整个输入序列不成功
        //System.out.println(matcher.start());// 匹配失败,IllegalStateException异常
        //System.out.println(matcher.end());// 匹配失败,IllegalStateException异常
        // lookingAt()
        //System.out.println(matcher.lookingAt());// true 从头开始匹配匹配成功
        //System.out.println(matcher.start());// 0
        //System.out.println(matcher.end());// 3
        // find()
        System.out.println(matcher.find());// 匹配成功
        System.out.println(matcher.start());// 0
        System.out.println(matcher.end());// 3
    

    Matcher使用find()注意点

    • 匹配开始位置
      此方法从匹配器区域的开头开始,如果该方法的前一次调用成功了并且从那时开始匹配器没有被重置,则从以前匹配操作没有匹配的第一个字符开始。
        String matchStr = "zxb";
        String reg = "zxb";
        Pattern pattern = Pattern.compile(reg);
        Matcher matcher = pattern.matcher(matchStr);
    
        System.out.println("lookingAt()");
        System.out.println(matcher.lookingAt());
        System.out.println(matcher.start());
        System.out.println(matcher.end());
    
        System.out.println("matches()");
        System.out.println(matcher.matches());
        System.out.println(matcher.start());
        System.out.println(matcher.end());// 3
    
        // 从上一次匹配结果结束位置(matcher.end();// 3)开始,已经超出了输入字符传的范围
        System.out.println("find()");
        System.out.println(matcher.find());// false
        System.out.println(matcher.start());// 匹配失败,IllegalStateException异常
        System.out.println(matcher.end());// 匹配失败,IllegalStateException异常
    
        //matcher.reset();// 重置匹配位置,从头开始匹配 也可以使用region(s,e)来设置匹配范围
        //System.out.println("find()");
        //System.out.println(matcher.find());// true
        //System.out.println(matcher.start());// 0
        //System.out.println(matcher.end());// 3
    

    返回结果:

    lookingAt()
    true
    0
    3
    matches()
    true
    0
    3
    find()
    false

    展开全文
  • Pattern Matcher

    2017-04-07 12:21:26
    package com.jerry.frame.utils; import org.junit.Test; import java.util.regex.Matcher; import java.util.regex.Pattern; /** * Created by zjh on 2017/4/7. */ public class TestPattern { @Test
    package com.jerry.frame.utils;
    
    import org.junit.Test;
    
    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    /**
     * Created by zjh on 2017/4/7.
     */
    public class TestPattern
    {
        @Test
        public void  testPattern(){
            Pattern pattern =  Pattern.compile("a");
            Matcher matcher = pattern.matcher("abcseas");
            System.out.print(matcher.replaceAll("d"));
    
        }
    }
    


    展开全文
  • Pattern和Matcher概述

    2019-07-26 11:15:13
    Pattern和Matcher概述 什么是Pattern 正则表达式的编译表示形式。 什么是Matcher 通过解释 Pattern 对 character sequence 执行匹配操作的引擎 Pattern调用顺序 Pattern p = Pattern.compile(“a*b...

    Pattern和Matcher概述

    什么是Pattern

    正则表达式的编译表示形式。

    什么是Matcher

    通过解释 Pattern 对 character sequence 执行匹配操作的引擎

    Pattern调用顺序

    Pattern p = Pattern.compile(“a*b”);
    Matcher m = p.matcher(“aaaaab”);
    boolean b = m.matches();

    方法介绍
    Pattern.compile(); 将给定的正则表达式编译到模式中
    Pattern.matcher(); 创建匹配给定输入与此模式的匹配器
    Matcher find() 在匹配器中查找满足正则表达式的字符串,找到返回true
    Matcher group() 返回在匹配器查找到的字符串

    演示:
    public class PattermAndMatcher {
    	public static void main(String[] args) {
    		String s = "aaaab";
    		String regex = "a*b";
    		Pattern p = Pattern.compile(regex);  //获取正则表达式
    		Matcher m = p.matcher(s);            //获取匹配器
    		boolean b = m.matches();             //看是否能匹配,匹配返回true
    		
    		System.out.println(b);
    	}
    }
    

    在这里插入图片描述

    练习:
    描述:把一个字符串中的手机号获取出来
    public class PattermAndMatcher {
    	public static void main(String[] args) {
    		String s = "我的手机号码是18988888888,曾经用过18987654321,还用过18812345678";
    
    		String regex = "1[3578]\\d{9}";      //手机号码的正则表达式
    		Pattern p = Pattern.compile(regex);
    		Matcher m = p.matcher(s);
    
    		while (m.find()) {                   //查找满足正则表达式的手机号,找到返回true
    			String s1 = m.group();           //返回查找到的手机号
    			System.out.println(s1);
    		}
    	}
    }
    

    在这里插入图片描述

    展开全文
  • 它包括两个类:Pattern和Matcher Pattern 一个Pattern是一个正则表达式经编译后的表现模式。 Matcher 一个Matcher对象是一个状态机器,它依据Pattern对象做为匹配模式对字符串展开匹配检查。 首先一个Pattern实例...
  • 主要介绍了Java正则表达式Pattern和Matcher原理详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • Pattern MatcherPattern和MatcherPattern Pattern和Matcher  今天又复习了以下java的基础知识,发现对Pattern和Matcher的使用又生疏了,特地整理了一下,Pattern可以看作是一个正则表达式的匹配模式,Matcher可以...

    Pattern和Matcher

     今天又复习了以下java的基础知识,发现对Pattern和Matcher的使用又生疏了,特地整理了一下,Pattern可以看作是一个正则表达式的匹配模式,Matcher可以看作是管理匹配结果,重复使用正则表达式匹配的一个类。

    Pattern

    Pattern的创建

            //pattern创建一个正则匹配
            Pattern pattern = Pattern.compile("java");
            System.out.println(pattern);//java
    

    split方法

     方法中第二个参数是可选参数,代表limit,也就是切分结果的个数限制。

    String[] split = pattern.split("123123java123123",4);//通过正则匹配切分
            for(String s : split){//123123 123123
                System.out.println(s);
            }
    

    全局匹配

     Pattern带有一个静态方法用于对字符串进行全局匹配。第一个参数是正则表达式,后一个参数是被匹配字符串。

    //自带一个matcher方法,但是只能做全局匹配
            System.out.println(Pattern.matches("java","java"));//true
    

    Matcher

     但需要匹配的要求变得复杂,我们就需要使用到Matcher类了,该类一般和Pattern一起使用。

    Matcher类的创建

     必须提供一个参数,该参数代表被匹配的字符串,由于matcher通过pattern.matcher()方法生成,当中已经存储了正则表达式和目标字符串。

      /*matcher提供了一个匹配类,可以多次使用正则式,用于提供各种匹配和管理匹配内容,matcher得到了pattern的正则表达式和需要匹配的字符串。
             */
            String s = "123java123";
            Matcher matcher = pattern.matcher(s);//java.util.regex.Matcher[pattern=java region=0,9 lastmatch=]
    

    全局匹配

    System.out.println(matcher.matches());//false
    

    find方法

     find方法需要好好讲一下,find方法顾名思义,就是查找,如果不传入参数,那么find会从索引0开始查找,一旦找到匹配的字符串就会返回true。
     需要注意的是,find是不断向后查找的,什么意思呢,就是说你第一次调用find,查找到的是第一个匹配的子字符串,假如目标字符串有多个匹配项,那么再调用一次,查找到的就是第二个匹配的字符串,matcher会记录好相应的匹配信息。
     如果传入一个参数x,代表find从索引x开始查找

     //可以从任意位置查找,只要子字符串找到返回true 注意:每次调用find都会往后查找一次。
     		Pattern pattern = Pattern.compile("java");
     		String s = "123java123";
            Matcher matcher = pattern.matcher(s);
            System.out.println(matcher.find());//true
            System.out.println(matcher.find(3));//true
            System.out.println(matcher.find(2));//true
            System.out.println(matcher.find(6));//false
    

    lookingAt方法

     从索引0开始匹配,如果匹配上了返回true,不需要全局匹配。与find不同,lookingAt要求第一个字符开始就要匹配,否则返回false

    //从第一个开始匹配,能匹配上就返回true,不需要全局匹配
        Pattern pattern = Pattern.compile("java");
     	String s = "123java123";
        Matcher matcher = pattern.matcher(s);
        System.out.println(matcher.lookingAt());//false
        String s1 = "java123";
        matcher = pattern.matcher(s1);
        System.out.println(matcher.lookingAt());//true
    

    start方法

     //start()返回匹配字符串开始位置
            System.out.println(matcher.start());
    

    end方法

     //end()返回匹配字符串结束位置
            System.out.println(matcher.end());
    

    group方法

     group的概念是相对正则匹配式的,比如正则匹配式(java)(python)©就是包含了3个group,注意group(0)为javapythonc。

     	Pattern pattern = Pattern.compile("java");
     	String s = "123java123";
        Matcher matcher = pattern.matcher(s);
        System.out.println(matcher.group());//java
        pattern = Pattern.compile("(java)(python)(c)");
        //注意:虽然分组了,但匹配时还是要将javapythonc都匹配上,否则报错。
        String s2 = "123javapythonc342c34546";
        matcher = pattern.matcher(s2);
        //要使用start,end,group等方法,要先进行一次匹配,这样才有记录,不然会报错
        matcher.find();
    
        System.out.println(matcher.groupCount());//3
    
        //没参数默认group(0);也就是整个正则表达式
        System.out.println(matcher.start());//3
        System.out.println(matcher.end());//14
        System.out.println(matcher.group());//javapythonc
        System.out.println(matcher.start(1));//3
        System.out.println(matcher.end(1));//7
        System.out.println(matcher.group(1));//java
        System.out.println(matcher.start(2));//7
        System.out.println(matcher.end(2));//13
        System.out.println(matcher.group(2));//python
        System.out.println(matcher.start(3));//13
        System.out.println(matcher.end(3));//14
        System.out.println(matcher.group(3));//c
    

    注意
    在使用start,end,group方法之前都需要调用find方法,确保matcher进行了一次查询并记录后才能调用之前的方法,否则报错,同时如果find没有找到匹配的子字符串,会报错no matcher find。

    region方法

      /*
            region用于设定查找范围,设定之后之前查找保存在mathcer中的结果清空
             */
            matcher.region(1,15);
            System.out.println(matcher.regionStart());//1
            System.out.println(matcher.regionEnd());//15
            matcher.find();
            System.out.println(matcher.group());//javapythonc
    

    reset方法

    	pattern = Pattern.compile("(java)(python)(c)");
        String s2 = "123javapythonc342c34546";
        matcher = pattern.matcher(s2);
    //重置匹配器方法
            matcher.reset();//重置后调用find会从0索引开始查找
    //        System.out.println(matcher.group());//出错,因为已经重置,matcher里没有匹配记录。
            matcher.reset("javapythonc123javapythonc");//重置需要匹配的字符串
            System.out.println(matcher.find());//true
    

    替换方法

     //替换方法
     //替换所有符合正则表达式的字符串       
     System.out.println(matcher.replaceAll("abc"));//abc123abc
    //替换第一个匹配上的字符串        
    System.out.println(matcher.replaceFirst("abc"));//abc123javapythonc
    

    appendReplacement和appendTail

     这两个方法是比较复杂的,简单来说

    • appendReplacement是将这次查找匹配到的字符串及其之前的字符渐进地输出到一个StringBuffer中去。
    • appendTail是将剩下的为匹配的字符串输出到一个StringBuffer中。
    @Test
        public void appendTest(){
            Pattern pattern = Pattern.compile("a|b");
            Matcher matcher = pattern.matcher("abcabca@126.com");
            StringBuffer sb = new StringBuffer();
            StringBuffer sb1 = new StringBuffer();
            while(matcher.find()){//每次find向后查找一个匹配项
                matcher.appendReplacement(sb, matcher.group().toUpperCase());
                System.out.println(sb);
            }
            matcher.appendTail(sb1);
            System.out.println(sb1);
        }
    

    输出结果如下:

    A
    AB
    ABcA
    ABcAB
    ABcABcA
    @126.com
    
    展开全文
  • JAVA正则表达式Pattern和Matcher
  • Java使用Pattern和Matcher两个类来支持正则表达式功能,字符串提供的正则表达式功能实际也是调用这两个类来实现的。 本文将介绍Pattern和Matcher的使用方法。 Pattern Pattern用来表示一个...
  • Pattern和Matcher的概述

    2019-04-01 00:48:36
    Pattern和Matcher的概述 A:PatternMatcher的概述 B:模式匹配器的典型调用顺序 通过JDK提供的API,查看Pattern类的说明 典型的调用顺序是: Pattern p = Pattern.compile(“a*b”); Matcher m = p....
  • java Pattern和Matcher详解

    2015-09-06 17:16:43
    看到了Pattern和Matcher的代码,找了篇博客学习一下 结论:PatternMatcher一起合作.Matcher类提供了对正则表达式的分组支持,以及对正则表达式的多次匹配支持. 单独用Pattern只能使用Pattern.matcher(String ...
  • 主要介绍了Java正则相关的Pattern和Matcher类及遇到的坑,本文给大家提到了Matcher 里面的三个方法,本文通过实例代码给大家介绍的非常详细,具有一定的参考借鉴价值,需要的朋友可以参考下
  • Java Pattern和Matcher用法

    2018-04-06 15:30:33
    Java正则表达式通过java.util.regex包下的Pattern和Matcher类实现 package cs; import java.util.regex.Pattern; //Matcher import java.util.regex.Matcher; //Pattern和 public class Zuoye8 { public static ...
  • 正则表达式 pattern和Matcher
  • java中Pattern和Matcher的使用

    千次阅读 2019-06-08 18:46:04
    我们的字符串String类中包含了正则的匹配、字符的替换等操作,但是,有的时候String的正则匹配不能够满足要求就需要用到Pattern和Matcher
  • java正则 Pattern和Matcher

    2017-11-02 14:00:14
    Java正则表达式通过java.util.regex包下的Pattern和Matcher类实现 Pattern类用于创建一个正则表达式,也可以说是创建一个匹配模式,可以通过两个静态方法创建:compile(String regex)compile(String regex,int ...
  • Java正则表达式通过java.util.regex包下的Pattern和Matcher类实现 Pattern类用于创建一个正则表达式,也可以说是创建一个匹配模式,可以通过两个静态方法创建:compile(String regex)compile(String regex,int ...
  • Pattern和Matcher的结合使用

    千次阅读 2017-05-07 22:17:11
    Pattern和Matcher java.lang.Object ————java.util.regex.Pattern public final class Patterne xtends Object implements Serializable 正则表达式的编译表示形式。  因此,典型的调用顺序是   ...
  • Java正则表达式pattern和matcher Pattern 提供一个正则表达式编译之后的表现模式 常用定义方法及使用: 1. Pattern p = Pattern.compile(“ String s”) //Stirng s 为正则表达式; 2. Matcher m=p.matcher...
  • JAVA正则表达式--Pattern和Matcher 现在JDK1.4里终于有了自己的正则表达式API包,JAVA程序员可以免去找第三方提供的正则表达式库的周折了,我们现在就马上来了解一下这个SUN提供的­迟来恩物- -对我来说确实如此。...
  • java正则表达式匹配的Pattern和Matcher,以及String类的Matches
  • Java中的Pattern和Matcher类的详解在工作中又一次的接触到了Pattern和Matcher,其中涉及到Matcher类中的一些方法,例如:group(),groupCount()等,因此又找了相关资料看了下,觉得下面两篇博文讲解的挺好的,因此...
  • 今天要分享的内容是java语言中的pattern和matcher的用法java.util.regex是一个用正则表达式所订制的模式来对字符串进行匹配工作的类库包。 它包括两个类:Pattern和Matcher Pattern 一个Pattern是一个正则表达式经...
  • 正则pattern和matcher

    2016-02-19 22:46:04
    自己重新排版了一下结论PatternMatcher一起合作.Matcher类提供了对正则表达式的分组支持,以及对正则表达式的多次匹配支持. 单独用Pattern只能使用Pattern.matcher(String regex,CharSequence input)一种最基础最...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 60,414
精华内容 24,165
关键字:

pattern和matcher