java 正则表达式详细用法

1正则表达式

1.1。什么是正则表达式？
正则表达式定义字符串的搜索模式
正则表达式的英文全称是regular expression。搜索模式可以是简单字符，固定字符串或包含描述模式的特殊字符的复杂表达式的任何内容
由正则表达式定义的 pattern 可以同时匹配一个或多个，或者一个都没匹配到

正则表达式可用于搜索，编辑和操作文本
使用正则表达式分析或修改文本的过程称为：正则表达式应用于文本/字符串
由正则表达式定义的模式从左到右应用于文本。一旦源字符在匹配中被使用，就不能重复使用。

例如，正则表达式aba将仅可以匹配ababababa两次（aba_aba__）

2正则表达式的例子

一个字符串其实就是一个简单的正则表达式，例如 Hello World 正则表达式匹配 “Hello World” 字符串。
.（点号）也是一个正则表达式，它匹配任何一个字符如：”a” 或 “1”。
下表列出了一些正则表达式的实例及描述：

正则表达式	描述
this is text	匹配字符串 “this is text”
this\s+is\s+text	注意字符串中的 \s+。 匹配单词 “this” 后面的 \s+ 可以匹配多个空格，之后匹配 is 字符串，再之后 \s+ 匹配多个空格然后再跟上 text 字符串。 可以匹配这个实例：this is text
^\d+(\.\d+)?	^ 定义了以什么开始 \d+ 匹配一个或多个数字 ? 设置括号内的选项是可选的 \. 匹配 “.” 可以匹配的实例：”5”, “1.5” 和 “2.21”。

3.正则表达式规则

下面的描述是可以在正则表达式中使用可用的元字符的概述。
3.1。常见的匹配符号

正则表达式	描述
.	匹配任何字符
^	匹配输入字符串开始的位置。如果设置了 RegExp 对象的 Multiline 属性，^ 还会与”\n”或”\r”之后的位置匹配。。
$	匹配输入字符串结尾的位置。如果设置了 RegExp 对象的 Multiline 属性，$ 还会与”\n”或”\r”之前的位置匹配。。
[abc]	集定义，可以匹配字母A或B或C。例如，”[abc]”匹配”jian”中的”a”。。
[abc][vz]	集定义，可以匹配或B或C，接着为v或z。
[^abc]	向字符集。匹配未包含的任何字符。例如，”[^abc]”匹配”plain”中”p”，”l”，”i”，”n”。
[a-d1-7]	范围：从1到7 a和d和数字之间的匹配信，但不能匹配D1。
X|Z	查找X或Z
XZ	发现X直接跟着Z.

3.2。元字符
下面的元字符有一个预先定义的含义，使某些共同的pattern更易于使用，例如 \d 代替 [0..9]。

正则表达式	描述
\d	数字字符匹配。等效于 [0-9]。]
\D	非数字字符匹配。等效于 [^0-9]。
\s	匹配任何空白字符，包括空格、制表符、换页符等。与 [ \f\n\r\t\v] 等效。
\S	匹配任何非空白字符。与 [^ \f\n\r\t\v] 等效。
\w	垂直制表符匹配。与 \x0b 和 \cK 等效。
\W	匹配任何字类字符，包括下划线。与”[A-Za-z0-9_]”等效。
\S	匹配任何非空白字符。与 [^ \f\n\r\t\v] 等效。
\b	匹配一个单词边界，单词字符是 [a-zA-Z0-9_]

3.3。量化
量词定义如何经常可以发生的元素。{}的符号？，*，+，并定义正则表达式的数量

正则表达式	描述	例子
*	出现零次或更多次，等效于{0，} ，例如，jia* 匹配”ji”和”jian”{0,}	X*X *0个或多个字母X，。*找到任何字符序列
+	发生一次或多次，是{1，}的缩写 {1,}	X+ - 找到一个或几个字母X
?	没有发生次或一次，?是{0,1}的缩写。	X? 未找到或只有一个字母X
{X}	非负整数。正好匹配 X 次。例如，”o{2}”与”Bob”中的”o”不匹配，但与”food”中的两个”o”匹配。	\d{3}搜索三位数字，.{10}对于长度为10的任何字符序列。
{X,Y}	X和Y之间发生，	\d{1,4}\d出现至少一次，并最多出现四个。
*?	?后一个量词使其成为一个不贪婪的量词。它试图找到最小的匹配。。

根据 Java Language Specification 的要求，Java 源代码的字符串中的反斜线被解释为 Unicode 转义或其他字符转义。因此必须在字符串字面值中使用两个反斜线，表示正则表达式受到保护，不被 Java 字节码编译器解释。例如，当解释为正则表达式时，字符串字面值 “\b” 与单个退格字符匹配，而 “\b” 与单词边界匹配。字符串字面值 “(hello)” 是非法的，将导致编译时错误；要与字符串 (hello) 匹配，必须使用字符串字面值 “\(hello\)”。
3.4捕获组
捕获组是把多个字符当一个单独单元进行处理的方法，它通过对括号内的字符分组来创建。
例如，正则表达式 (dog) 创建了单一分组，组里包含”d”，”o”，和”g”。
捕获组是通过从左至右计算其开括号来编号。例如，在表达式（（A）（B（C））），有四个这样的组：

• ((A)(B(C)))
• (A)
• (B(C))
• (C)
  以通过调用 matcher 对象的 groupCount 方法来查看表达式有多少个分组。groupCount 方法返回一个 int 值，表示matcher对象当前有多个捕获组。
  还有一个特殊的组（group(0)），它总是代表整个表达式。该组不包括在 groupCount 的返回值中。
  常用的正则匹配
  
  例子
  例如，假设您要替换一个字母后跟一个点或逗号的所有空格。

String pattern = "(\\w)(\\s+)([\\.,])";
System.out.println(EXAMPLE_TEST.replaceAll(pattern, ""));

替换标题标签之间的文本

pattern = "(?i)(<title.*?>)(.+?)()";
String updated = EXAMPLE_TEST.replaceAll(pattern, "$2");

4Pattern 和Matcher

您首先创建一个定义正则表达式的Pattern对象。此Pattern对象允许您为给定的字符串创建Matcher对象。这个Matcher对象然后允许你对String进行正则表达式操作

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

public class RegexTestPatternMatcher {
        public static final String EXAMPLE_TEST = "This is my small example string which I'm going to use for pattern matching.";

        public static void main(String[] args) {
                Pattern pattern = Pattern.compile("\\w+");
                // 如果您想忽略大小写敏感度,
                // 你可以使用这个语句:
                // Pattern pattern = Pattern.compile("\\s+", Pattern.CASE_INSENSITIVE);
                Matcher matcher = pattern.matcher(EXAMPLE_TEST);
                // 检查所有的结果
                while (matcher.find()) {
                        System.out.print("Start index: " + matcher.start());
                        System.out.print(" End index: " + matcher.end() + " ");
                        System.out.println(matcher.group());
                }
                // 现在创建一个新的pattern和Matcher 以用选项卡替换空格s
                Pattern replace = Pattern.compile("\\s+");
                Matcher matcher2 = replace.matcher(EXAMPLE_TEST);
                System.out.println(matcher2.replaceAll("\t"));
        }
}

5Java正则表达式示例

建立一个链接检查器

以下示例允许您从网页中提取所有有效的链接。它不考虑以“javascript：”或“mailto：”开头的链接。

public class LinkGetter {
        private Pattern htmltag;
        private Pattern link;

        public LinkGetter() {
                htmltag = Pattern.compile("<a\\b[^>]*href=\"[^>]*>(.*?)</a>");
                link = Pattern.compile("href=\"[^>]*\">");
        }

        public List<String> getLinks(String url) {
                List<String> links = new ArrayList<String>();
                try {
                        BufferedReader bufferedReader = new BufferedReader(
                                        new InputStreamReader(new URL(url).openStream()));
                        String s;
                        StringBuilder builder = new StringBuilder();
                        while ((s = bufferedReader.readLine()) != null) {
                                builder.append(s);
                        }

                        Matcher tagmatch = htmltag.matcher(builder.toString());
                        while (tagmatch.find()) {
                                Matcher matcher = link.matcher(tagmatch.group());
                                matcher.find();
                                String link = matcher.group().replaceFirst("href=\"", "")
                                                .replaceFirst("\">", "")
                                                .replaceFirst("\"[\\s]?target=\"[a-zA-Z_0-9]*", "");
                                if (valid(link)) {
                                        links.add(makeAbsolute(url, link));
                                }
                        }
                } catch (MalformedURLException e) {
                        e.printStackTrace();
                } catch (IOException e) {
                        e.printStackTrace();
                }
                return links;
        }

        private boolean valid(String s) {
                if (s.matches("javascript:.*|mailto:.*")) {
                        return false;
                }
                return true;
        }

        private String makeAbsolute(String url, String link) {
                if (link.matches("http://.*")) {
                        return link;
                }
                if (link.matches("/.*") && url.matches(".*$[^/]")) {
                        return url + "/" + link;
                }
                if (link.matches("[^/].*") && url.matches(".*[^/]")) {
                        return url + "/" + link;
                }
                if (link.matches("/.*") && url.matches(".*[/]")) {
                        return url + link;
                }
                if (link.matches("/.*") && url.matches(".*[^/]")) {
                        return url + link;
                }
                throw new RuntimeException("Cannot make the link absolute. Url: " + url
                                + " Link " + link);
        }
}

找到重复的单词
以下正则表达式匹配重复的单词。

\b(\w+)\s+\1\b

\ b是一个字边界，\ 1引用了第一个组的捕获匹配，即第一个字。 （？！ - in）\ b（\ w +）\ 1 \ b如果不以“-in”开头，则会找到重复的单词。 提示：添加（？s）以跨多行搜索

寻找从新行开始的元素
以下正则表达式允许您找到“标题”单词，以防其在新行中开始。

(\n\s*)title

从一个给定的字符串中找到想要的字符串：

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

          // 按指定模式在字符串查找
          String line = "My name is Jianguotang。I am a Android programmer.I am 21 years old";
          String pattern = "(\\D*)(\\d+)(.*)";

          // 创建 Pattern 对象
          Pattern r = Pattern.compile(pattern);

          // 现在创建 matcher 对象
          Matcher m = r.matcher(line);
          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");
          }
       }


}

运行结果

Found value: My name is Jianguotang。I am a Android programmer.I am 21 years old
Found value: My name is Jianguotang。I am a Android programmer.I am 
Found value: 21
Found value:  years old