java正则表达式

Java 正则表达式

java.util.regex 包主要包括以下三个类：

• pattern类

pattern 对象是一个正则表达式的编译表示。Pattern 类没有公共构造方法。要创建一个 Pattern 对象，你必须首先调用其公共静态编译方法，它返回一个 Pattern 对象。该方法接受一个正则表达式作为它的第一个参数。

• macher类

Matcher 对象是对输入字符串进行解释和匹配操作的引擎。与Pattern 类一样，Matcher 也没有公共构造方法。你需要调用 Pattern 对象的 matcher 方法来获得一个 Matcher 对象。

• PatternSyntaxException

PatternSyntaxException 是一个非强制异常类，它表示一个正则表达式模式中的语法错误。

一个简单的实例：

    public class Regex {

        public static void main(String args[]){
            String content = "I am Great " +
                "Hua from china.";

            String pattern = ".*eat.*";

            boolean isMatch = Pattern.matches(pattern, content);
            System.out.println("字符串中是否包含了 'eat' 子字符串? " + isMatch);
        }
    }

结果：

分组的匹配

分析一波应用场景，比如你的字符串中含有电话，IP地址，gps坐标等信息需要被剥离出来另做处理；

分组就是把多个字符当一个单独单元进行处理的方法，它通过对括号内的字符分组来创建。

分组是按照括号来区分的，从左至右的顺序，如表达式（A(B(C))）,分组如下：

1）A

2）（A(B(C))）

3）C

4）(B(C))

可以通过调用 matcher 对象的 groupCount 方法来查看表达式有多少个分组。groupCount 方法返回一个 int 值，表示matcher对象当前有多个捕获组。

还有一个特殊的组（group(0)），它总是代表整个表达式。该组不包括在 groupCount 的返回值中。

实例程序：

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


public class RegexGroup {
    public static void main( String args[] ){

        // 按指定模式在字符串查找
        String line = "This order was placed for ZK1314! OK?";
        String pattern = "(\\D*)(.*)(\\d+)";//查找  “至少0个非数字 至少一个数字 至少0个.”
        //惰性匹配  非惰性匹配，这里是惰性匹配
        // 创建 Pattern 对象
        Pattern r = Pattern.compile(pattern);

        // 现在创建 matcher 对象
        Matcher m = r.matcher(line);
        System.out.println("Group count: " + m.groupCount() );//group(0)不算在其中groupCount()中
        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");
        }
    }
}

运行结果：

正则表达式语法

在其他语言中，\ 表示：我想要在正则表达式中插入一个普通的（字面上的）反斜杠，请不要给它任何特殊的意义。

在Java中，\ 表示：我要插入一个正则表达式的反斜线，所以其后的字符具有特殊的意义。

所以，在其他的语言中，一个反斜杠\就足以具有转义的作用，而在正则表达式中则需要有两个反斜杠才能被解析为其他语言中的转义作用。也可以简单的理解在正则表达式中，两个 \ 代表其他语言中的一个 \，这也就是为什么表示一位数字的正则表达式是 \d，而表示一个普通的反斜杠是 \\。

具体的语法，请参考网上的信息吧，个人觉的没必要全记住，知道去用就可以了；

Macher类

索引方法：

序号	函数	备注
1	public int start()	参数：int groupNumber 不写默认为0，返回‘分组’匹配字符串的起始索引
2	public int end()	参数：int groupNumber 不写默认为0，返回‘分组’匹配字符串的结束索引

下图是结果示意图，不做详细描述：

public class RegexGroup {
    public static void main( String args[] ){

        // 按指定模式在字符串查找
        String line = "This order was placed for ZK1314! OK?";
        String pattern = "(\\D*)(.*)(\\d+)";//查找  “至少0个非数字 至少一个数字 至少0个.”
        //惰性匹配  非惰性匹配，这里是惰性匹配
        // 创建 Pattern 对象
        Pattern r = Pattern.compile(pattern);

        // 现在创建 matcher 对象
        Matcher m = r.matcher(line);
        System.out.println("Group count: " + m.groupCount() );//group(0)不算在其中groupCount()中
        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) );

            System.out.println("-------华丽的分割线--------");
            System.out.println("start函数: " +m.start());
            System.out.println("start函数: " +m.start(0));
            System.out.println("start函数: " +m.start(1));
            System.out.println("start函数: " +m.start(2));
            System.out.println("start函数: " +m.start(3));
            System.out.println("-------华丽的分割线--------");
            System.out.println("end函数: " +m.end());
            System.out.println("end函数: " +m.end(0));
            System.out.println("end函数: " +m.end(1));
            System.out.println("end函数: " +m.end(2));
            System.out.println("end函数: " +m.end(3));


        } else {
            System.out.println("NO MATCH");
        }
    }
}

常用的研究方法

研究方法用来检查输入字符串并返回一个布尔值，表示是否找到该模式；

本人用的表格太low了，这里换列表标记吧。

1）public boolean lookingAt() 

尝试将从区域开头开始的输入序列与该模式匹配。

2）public boolean find() 

尝试查找与该模式匹配的输入序列的下一个子序列。

3）public boolean find(int start）

重置此匹配器，然后尝试查找匹配该模式、从指定索引开始的输入序列的下一个子序列。

4）public boolean matches() 

尝试将整个区域与模式匹配。

find:部分匹配，从当前位置开始匹配，找到一个匹配的子串，将移动下次匹配的位置。

lookingAt:部分匹配，总是从第一个字符进行匹配,匹配成功了不再继续匹配，匹配失败了,也不继续匹配

matches:整个匹配，只有整个字符序列完全匹配成功，才返回True，否则返回False。但如果前部分匹配成功，将移动下次匹配的位置

替换方法

替换方法是替换输入字符串里文本的方法：

1）public Matcher appendReplacement(StringBuffer sb, String replacement)

实现非终端添加和替换步骤。

2）public StringBuffer appendTail(StringBuffer sb) 

实现终端添加和替换步骤。

3）public String replaceAll(String replacement) 

替换模式与给定替换字符串相匹配的输入序列的每个子序列。

4）public String replaceFirst(String replacement) 

替换模式与给定替换字符串匹配的输入序列的第一个子序列。

5）public static String quoteReplacement(String s)

返回指定字符串的字面替换字符串。这个方法返回一个字符串，就像传递给Matcher类的appendReplacement 方法一个字面字符串一样工作。

public class RegexPlace {

    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());
    }
}

PatternSyntaxException 类的方法

1）public String getDescription()

获取错误的描述。

2）public int getIndex() 

获取错误的索引。

3）public String getPattern() 

获取错误的正则表达式模式。
4）public String getMessage()

返回多行字符串，包含语法错误及其索引的描述、错误的正则表达式模式和模式中错误索引的可视化指示。

总结

本人由于工作需要进行了java正则表达式的学习，首先感谢互联网的开源精神，我也正在为互联网的学习做一些贡献；
说一下这个java正则表达式，本人在大学时学过一门编译原理（很牛逼，但不知道有啥用）的课程，不才没有学到精髓，目前只剩下了正则表达式；
最后，感谢菜鸟教程http://www.runoob.com/