Java正则表达式

Java正则表达式（Java Regex或Regular Expression）是一种定义用于搜索或操作字符串的模式的API。

它广泛用于定义字符串的约束，例如密码和电子邮件验证。学习Java正则表达式教程后，您将能够通过Java Regex测试工具来测试您的正则表达式。

Java正则表达式API在java.util.regex包中提供了1个接口和3个类。

java.util.regex包

Matcher类和Pattern类提供了Java正则表达式的功能。java.util.regex包提供以下类和接口用于正则表达式：

  1. MatchResult接口
  2. Matcher类
  3. Pattern类
  4. PatternSyntaxException类

1.jpg

Matcher类

它实现了MatchResult接口。它是一个正则表达式引擎，用于在字符序列上执行匹配操作。

No.MethodDescription
1boolean matches()测试正则表达式是否匹配模式。
2boolean find()查找下一个与模式匹配的表达式。
3boolean find(int start)从给定的起始编号开始查找与模式匹配的下一个表达式。
4String group()返回匹配的子序列。
5int start()返回匹配子序列的起始索引。
6int end()返回匹配子序列的结束索引。
7int groupCount()返回匹配子序列的总数。

Pattern类

它是正则表达式的编译版本。它用于为正则表达式引擎定义模式。

No.MethodDescription
1static Pattern compile(String regex)编译给定的正则表达式并返回模式的实例。
2Matcher matcher(CharSequence input)创建一个将给定输入与模式相匹配的匹配器。
3static boolean matches(String regex, CharSequence input)它作为编译和匹配器方法的组合。它编译正则表达式并将给定的输入与模式匹配。
4String[] split(CharSequence input)围绕给定模式的匹配项拆分给定的输入字符串。
5String pattern()返回正则表达式模式。

Java正则表达式示例

在Java中，有三种编写正则表达式示例的方式。

import java.util.regex.*;  
public class RegexExample1{  
public static void main(String args[]){  
//第一种方式    
Pattern p = Pattern.compile(".s");//代表单个字符 
Matcher m = p.matcher("as");  
boolean b = m.matches();  
  
//第二种方式  
boolean b2=Pattern.compile(".s").matcher("as").matches();  
  
//第三种方式  
boolean b3 = Pattern.matches(".s", "as");  
  
System.out.println(b+" "+b2+" "+b3);  
}}

输出：

true true true

正则表达式 . 示例

点（.）表示一个字符。

import java.util.regex.*;  
class RegexExample2{  
public static void main(String args[]){  
System.out.println(Pattern.matches(".s", "as"));//true (第二个字符是s)  
System.out.println(Pattern.matches(".s", "mk"));//false (第二个字符不是 s)  
System.out.println(Pattern.matches(".s", "mst"));//false (超过 2 个字符)  
System.out.println(Pattern.matches(".s", "amms"));//false (超过 2 个字符）  
System.out.println(Pattern.matches("..s", "mas"));//true (第3个字符是s)  
}}

正则表达式字符类

No.Character ClassDescription
1[abc]a、b 或 c（简单类）
21除 a、b 或 c 之外的任何字符（否定）
3[a-zA-Z]a 到 z 或 A 到 Z，包括在内（范围）
4[a-d[m-p]]a 到 d，或 m 到 p：[a-dm-p]（并集）
5[a-z&&[def]]d、e 或 f（交点）
6[a-z&&2]a 到 z，b 和 c 除外：[ad-z]（减法）
7[a-z&&3]a 到 z，而不是 m 到 p：[a-lq-z]（减法）

正则表达式字符类示例

import java.util.regex.*;  
class RegexExample3{  
public static void main(String args[]){  
System.out.println(Pattern.matches("[amn]", "abcd"));//false (不是 a 或 m 或 n)  
System.out.println(Pattern.matches("[amn]", "a"));//true (在a或m或n中)  
System.out.println(Pattern.matches("[amn]", "ammmna"));//false (m 和 a 出现不止一次)  
}}

正则表达式量词

量词指定字符出现的次数。

RegexDescription
X?X出现一次或根本不出现
X+X出现一次或多次
X*X 出现零次或多次
X{n}X只出现n次
X{n,}X 出现 n 次或更多次
X{y,z}X 至少出现 y 次但少于 z 次

正则表达式字符类和量词示例

import java.util.regex.*;  
class RegexExample4{  
public static void main(String args[]){  
System.out.println("? quantifier ....");  
System.out.println(Pattern.matches("[amn]?", "a"));//true (a或m或n出现一次)  
System.out.println(Pattern.matches("[amn]?", "aaa"));//false (a 出现不止一次)  
System.out.println(Pattern.matches("[amn]?", "aammmnn"));//false (m 和 n 来了不止一次)  
System.out.println(Pattern.matches("[amn]?", "aazzta"));//false (a 出现不止一次)  
System.out.println(Pattern.matches("[amn]?", "am"));//false (a或m或n必须来一次)  
  
System.out.println("+ quantifier ....");  
System.out.println(Pattern.matches("[amn]+", "a"));//true (a或m或n一次或多次)  
System.out.println(Pattern.matches("[amn]+", "aaa"));//true (a 出现不止一次)  
System.out.println(Pattern.matches("[amn]+", "aammmnn"));//true (a或m或n出现不止一次)  
System.out.println(Pattern.matches("[amn]+", "aazzta"));//false (z 和 t 不匹配模式)  
  
System.out.println("* quantifier ....");  
System.out.println(Pattern.matches("[amn]*", "ammmna"));//true (或m或n可能出现零次或多次)  
  
}}

正则表达式元字符

正则表达式元字符作为快捷方式。

RegexDescription
.任何字符（可能匹配也可能不匹配终止符）
d[0-9] 以外的任何数字
D任何非数字，4 的缩写
s任何空白字符，[tnx0Bfr] 的缩写
S任何非空白字符，5 的缩写
w任何单词字符，[a-zA-Z_0-9] 的缩写
W任何非单词字符，6 的缩写
b单词边界
B非单词边界

正则表达式元字符示例

import java.util.regex.*;  
class RegexExample5{  
public static void main(String args[]){  
System.out.println("metacharacters d....");\\d means digit  
  
System.out.println(Pattern.matches("\\d", "abc"));//false (非数字)  
System.out.println(Pattern.matches("\\d", "1"));//true (数字出现一次)  
System.out.println(Pattern.matches("\\d", "4443"));//false (数字但出现不止一次)  
System.out.println(Pattern.matches("\\d", "323abc"));//false (数字和字符)  
  
System.out.println("metacharacters D....");\\D means non-digit  
  
System.out.println(Pattern.matches("\\D", "abc"));//false (非数字但出现不止一次)  
System.out.println(Pattern.matches("\\D", "1"));//false (数字)  
System.out.println(Pattern.matches("\\D", "4443"));//false (数字)  
System.out.println(Pattern.matches("\\D", "323abc"));//false (数字和字符)  
System.out.println(Pattern.matches("\\D", "m"));//true (非数字且出现一次)  
  
System.out.println("metacharacters D with quantifier....");  
System.out.println(Pattern.matches("\\D*", "mak"));//true (非数字，可能出现 0 次或多次)  
  
}}

正则表达式问题1

/*创建一个只接受字母数字字符的正则表达式。  
它的长度只能是六个字符。*/  
  
import java.util.regex.*;  
class RegexExample6{  
public static void main(String args[]){  
System.out.println(Pattern.matches("[a-zA-Z0-9]{6}", "arun32"));//true  
System.out.println(Pattern.matches("[a-zA-Z0-9]{6}", "kkvarun32"));//false (超过6个字符)  
System.out.println(Pattern.matches("[a-zA-Z0-9]{6}", "JA2Uk2"));//true  
System.out.println(Pattern.matches("[a-zA-Z0-9]{6}", "arun$2"));//false ($不匹配)  
}}

正则表达式问题2

/* 创建一个接受 10 位数字字符的正则表达式 
 仅以 7、8 或 9 开头。*/  
  
import java.util.regex.*;  
class RegexExample7{  
public static void main(String args[]){  
System.out.println("by character classes and quantifiers ...");  
System.out.println(Pattern.matches("[789]{1}[0-9]{9}", "9953038949"));//true  
System.out.println(Pattern.matches("[789][0-9]{9}", "9953038949"));//true  
  
System.out.println(Pattern.matches("[789][0-9]{9}", "99530389490"));//false (11个字符)  
System.out.println(Pattern.matches("[789][0-9]{9}", "6953038949"));//false (从 6 开始)  
System.out.println(Pattern.matches("[789][0-9]{9}", "8853038949"));//true  
  
System.out.println("by metacharacters ...");  
System.out.println(Pattern.matches("[789]{1}\\d{9}", "8853038949"));//true  
System.out.println(Pattern.matches("[789]{1}\\d{9}", "3853038949"));//false (从 3 开始)  
  
}}

Java正则表达式查找器示例

import java.util.regex.Pattern;  
import java.util.Scanner;  
import java.util.regex.Matcher;    
public class RegexExample8{    
    public static void main(String[] args){    
        Scanner sc=new Scanner(System.in);  
        while (true) {    
            System.out.println("Enter regex pattern:");  
            Pattern pattern = Pattern.compile(sc.nextLine());    
            System.out.println("Enter text:");  
            Matcher matcher = pattern.matcher(sc.nextLine());    
            boolean found = false;    
            while (matcher.find()) {    
                System.out.println("I found the text "+matcher.group()+" starting at index "+    
                 matcher.start()+" and ending at index "+matcher.end());    
                found = true;    
            }    
            if(!found){    
                System.out.println("No match found.");    
            }    
        }    
    }    
}

输出：

Enter regex pattern: java
Enter text: this is java, do you know java
I found the text java starting at index 8 and ending at index 12
I found the text java starting at index 26 and ending at index 30
  1. abc ↩
  2. bc ↩
  3. m-p ↩
  4. 0-9 ↩
  5. s ↩
  6. w ↩

标签: java, Java面试题, Java下载, java教程, java技术, Java学习, Java学习教程, Java语言, Java开发, Java入门教程, Java进阶教程, Java高级教程, Java笔试题, Java编程思想