正则表达式及pattern类和Matcher类

常用正则表达式：
[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 空白字符：[\t\n\x0B\f\r]

\S 非空白字符：[^\s]

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

\W 非单词字符：[^\w]

\p{Lower} 小写字母字符：[a-z]

\p{Upper} 大写字母字符：[A-Z]

X? X，一次或一次也没有

X* X，零次或多次

X+ X，一次或多次

X{n} X，恰好 n 次

X{n,} X，至少 n 次

X{n,m} X，至少 n 次，但是不超过 m 次

(X) X，作为捕获组

非捕获

(?=X) X，通过零宽度的正lookahead

(?!X) X，通过零宽度的负lookahead

(?<=X) X，通过零宽度的正lookbehind

(?<!X) X，通过零宽度的负lookbehind

(?>X) X，作为独立的非捕获组

正则表达式的匹配模式
默认情况下,匹配模式属于单行模式,也就是说在匹配的过程中会自动忽略换行符,

• 这个时候 ^ 和 $ 匹配的是行的开头和行的结尾(忽略换行符)
• 换行符
• windows: \r\n
• linux: \n
• mac: \r
• 使用每个操作系统中自带的纯记事本,只能够识别系统定义的换行符
• 如果你使用高级记事本或者IDE,任何一个换行符都是可以识别的
• 切换到多行模式: 使用Pattern.MULTILINE
• 默认情况下, .匹配任意字符,会忽略换行符
• 设置.匹配包括换行符,可以使用 Pattern.DOTALL
• 注意,如果希望使用多种模式同时匹配,模式之间通过 | 隔开

分组

() 元字符含义

• 1. 提高优先级
• 2. 作为子表达式
• 2. 分组

?: 表示忽略分组: 保证表达式执行的优先级,但是不会分配组号

• 分配组号的作用: 回溯引用,利用+组号,可以利用分配的组号重复引用

• 反向引用: 利用$+组号

• 或 |

• This is (Java|Andoroid) Programming
  */

public class RegexpDemo03 {
    public static void main(String[] args) {
        // 1. 提高优先级
        String regexp = "Jack{3,}";
        regexp = "(Jack){3,}";

        // 2014-10-12
        regexp = "(\\d{4})-(\\d{2})-(\\d{2})";
        regexp = "(\\d{4})-(?:\\d{2})-(\\d{2})";

        // 将日期2018-04-27 转换成为 04/27/2018
        // 2018-04-27 ==> 04/27/2018
        String regex = "(\\d{4})-(\\d{2})-(\\d{2})";
        String s = "2018-04-27";
        System.out.println("原日期字符串:" + s);
        String replace = s.replaceAll(regex, "$2/$3/$1");
        System.out.println("使用正则修改后的日期字符串:" + replace);
    }
}

Java中的pattern类

在JDK 1.4中，Java增加了对正则表达式的支持。
final修饰，不被继承。
含义，模式类，正则表达式的编译表达的形式。
实例不可变
java 使用pattern这个类来描述正则表达式对象

String s="This is a car, carry it, don't destroy my car";
s="car";
String regex="\\bcar\\b";
  // 1. 将正则表达式字符串包装成正则表达式对象
Pattern p=new Pattern(regex);
        // 2. 通过正则表达式对象创建匹配器对象
Matcher m=p.matcher(s);
       
m.matches()

patter类中有 ：
1.compile( String regex)(compile( String regex,int flags)方法，用于创建Pattern类的实例对象regex。
2.int flags():返回当前Pattern的匹配flag参数。
3.String[] split(CharSequence input)
用于分割字符串，返回String数组此外String[] split(CharSequence input, int limit)功能和String[]split(CharSequence input)相同，增加参数limit目的在于要指定分割的段数。
4.static boolean matches(String regex,charSequenceinput)
是一个静态方法，用于快速匹配字符串，该方法适合用于只匹配一次，且匹配全部字符串。方法编译给定的正则表达式并且对输入的字串以该正则表达式为模式开展匹配，该方法只进行一次匹配工作，并不需要生成一个Matcher实例。
5.Matcher matcher(CharSequence input)
Pattern.matcher()返回一个Matcher对象，Matcher类的构造方法也是私有的，不能随意创建，只能通过Pattern.matcher(CharSequence input)方法得到该类的实例。
Pattern类只能做一些简单的匹配操作，要想得到更强更便捷的正则匹配操作，那就需要将Pattern与Matcher一起合作。Matcher类提供了对正则表达式的分组支持，以及对正则表达式的多次匹配支持。

Java代码示例：
//
Pattern p = Pattern.compile("\d+");
//利用Pattern类的方法matcher创建类Matcher的实例m
Matcher m = p.matcher(“22bb23”);

    // 返回p也就是返回该Matcher对象是由哪个Pattern对象的创建的

    m.pattern();//结果为字符串"\d+"

6.String pattern()：返回正则表达式的字符串形式。

    其实就是返回Pattern.complile(Stringregex)的regex参数。示例如下：

    String regex ="\\?|\\*";

    Pattern pattern= Pattern.compile(regex);

    StringpatternStr = pattern.pattern();//返回\?\*

Matcher类方法

1、Matcher类提供了三个匹配操作方法，三个方法均返回boolean类型，当匹配到时返回true，没匹配到则返回false。

    boolean matches()最常用方法：尝试对整个目标字符展开匹配检测，也就是只有整个目标字符串完全匹配时才返回真值。

    boolean lookingAt()对前面的字符串进行匹配，只有匹配到的字符串在最前面才会返回true。

    boolean find()：对字符串进行匹配，匹配到的字符串可以在任何位置。

    2、返回匹配器的显示状态：intstart()：返回当前匹配到的字符串在原目标字符串中的位置；int end()：返回当前匹配的字符串的最后一个字符在原目标字符串中的索引位置；String group()：返回匹配到的子字符串。

获取以下英文句子中两个字符组成的单词并且输出

  String s="On Friendship And a youth said, Speak to us of Friendship." +
                " Your friend is your needs answered. He is your field which";
             String regex="\\b[a-zA-z]{2}\\b";
             Pattern p= Pattern.compile(regex);
        Matcher m = p.matcher(s);
        while (m.find())   //当没有find()方法时，group()方法不能使用，要一起用
        {
            System.out.println(m.group());
        }
        //*****find()会从第一个字母开始遍历，遍历到相等的字符串返回True,group()
        //返回这个字符串，find()会在当前位置继续遍历下去，直到结束

    3、int start()，int end()，int group()均有一个重载方法，它们分别是int start(int i)，int end(int i)，int group(int i)专用于分组操作，Mathcer类还有一个groupCount()用于返回有多少组。

    4、Matcher类同时提供了四个将匹配子串替换成指定字符串的方法：

    1)、String replaceAll(Stringreplacement)：将目标字符串里与既有模式相匹配的子串全部替换为指定的字符串。

    2)、String replaceFirst(Stringreplacement)：将目标字符串里第一个与既有模式相匹配的子串替换为指定的字符串。

    3)、还有两个方法Matcher appendReplacement(StringBuffersb, String replacement) 和StringBufferappendTail(StringBuffer sb)也很重要，appendReplacement允许直接将匹配的字符串保存在另一个StringBuffer中并且是渐进式匹配，并不是只匹配一次或匹配全部，而appendTail则是将未匹配到的余下的字符串添加到StringBuffer中。

    5、其他一些方法：例如Matcherreset()：重设该Matcher对象。

    Matcher reset(CharSequence input)：重设该Matcher对象并且指定一个新的目标字符串。

    Matcher region(int start, int end)：设置此匹配器的区域限制。

find()方法
find(int index):

1. 表示从字符串的指定索引 index 位置开始从左往右边查找
2. 如果已经查找到了字符串的后面,可以通过此方法重置索引位置,重新查找

matches()总结
java.lang包中的String类，java.util.regex包中的Pattern，Matcher类中都有matches()方法。
都与正则表达式有关。下面我分别举例：（字符串：“abc”，正则表达式： “[a-z]{3}”）

String类的方法：
boolean b = “abc”.matches("[a-z]{3}"
System.out.println(b);

Pattern类中的方法：
boolean b = Pattern.matches("[a-z]{3}",“abc”);
System.out.println(b);

Matcher类中的方法：
Pattern p = Pattern.compile("[a-z]{3}");
Matcher m = p.matcher(“acc”);
boolean b =m.matches()
System.out.println(b);
得到的结果都为true。