Java 正则表达式

最新推荐文章于 2025-06-01 23:57:41 发布

原创最新推荐文章于 2025-06-01 23:57:41 发布 · 287 阅读

2 ·

CC 4.0 BY-SA版权

文章标签：

#正则表达式 #java #字符串

java 专栏收录该内容

41 篇文章

订阅专栏

本文介绍正则表达式的基础知识及Java中应用方法，包括基本语法、字符串验证、替换及拆分等操作，并通过示例讲解如何使用Pattern和Matcher类处理更复杂的场景。

正则表达式

判断是否由数字组成

//一般
public class JavaApiDemo {
    public static void main(String[] args) throws Exception {
        String str = "123";
        if (isNumber(str)) {
            int num = Integer.valueOf(str);
            System.out.println(num * 2);
        }
    }
    public static boolean isNumber(String str) {
        if (str == null) {
            return false;
        }
        char data[] = str.toCharArray();
        for (char d : data) {
            if (d > '9' || d < '0') {
                return false;
            }
        }
        return true;
    }
}
//进化
public class JavaApiDemo {
    public static void main(String[] args) throws Exception {
        String str = "123";
        if (isNumber(str)) {
            int num = Integer.valueOf(str);
            System.out.println(num * 2);
        }
    }
    public static boolean isNumber(String str) {
        if (str == null) {
            return false;
        }
        return str.matches("\\d+");
    }
}

正则表达式最早是从Perl语言中发展而来的，而后在JDK 1.4以前需要使用到正则表达式的相关定义则需要单独引入其他的*.jar文件，但是从JDK1.4后，正则已经默认被JDK所支持，并提供有java.util.regex开发包，同时针对于String 类也增加了对于正则的验证方法。
使用正则的最大特点在于方便进行验证处理，以及方便进行复杂字符串的修改处理。

常用正则标记Pattern类

如果想要进行正则的处理操作，那么首先需要对常用的正则标记有所掌握，从JDK1.4开始提供java.util.regex开发包，这个包中提供有一个Pattern类，在这个类中定义有所有支持的正则标记。
1、【数量：单个】字符匹配
1）x 任意字符：表示相同的任意字符；
2）\\：匹配 “\”；
3）\n：匹配换行；
4）\t：匹配制表符；
2、【数量：单个】字符集（可以从中任选一个字符）
1）[abc]：表示可能是字母a、b、c中的任意一个；
2）[^abc]：表示不可能是字母a、b、c中的任意一个；
3）[a-zA-Z]：表示一个任意的字母，不区分大小写；
4）[0-9]：表示一个0~9的数字；
3、【数量：单个】简化字符集
1）.：表示任意一个字符；
2）\d：等价于“[0-9]”范围；
3）\D：等价于“[^0-9]”范围；
4）\s：匹配任意一个空格，可能是空格、换行、制表符；
5）\S：匹配任意一个非空格，不可能是空格、换行、制表符；
6）\w：匹配一个字母、数字或下划线，等价于“[a-zA-Z_0-9]”范围；
7）\W：匹配一个非字母、数字、下划线，等价于“[^a-zA-Z_0-9]”范围；
4、边界匹配：
1）^：匹配边界开始；
2）$：匹配边界结束；
5、数量表达，默认情况下只有添加上了数量单位才可以匹配多为字符；
1）表达式?：该正则可以出现0次或1次；
2）表达式*：该正则可以出现0次、1次或多次；
3）表达式+：该正则可以出现1次或多次；
4）表达式{n}：表达式的长度正好为n次；
5）表达式{n,}：表达式的长度为n次以上；
6）表达式{n,m}：表达式的长度在n~m次；
6、逻辑表达式：可以连接多个正则：
1）表达式X表达式Y：X表达式满足和Y表达式满足；
2）表达式X|表达式Y：X表达式满足或者Y表达式满足；
2）(表达式)：为表达式设置一个整体描述，可以为整体描述设置一个数量单位；

####　String类对正则的支持

在进行正则表达式大部分处理的情况下都会基于String类来完成，并且在String中提供有如下与正则有关的操作方法：
1、将指定字符串进行正则判断：public boolean matches(String regex)；
2、替换全部：public String replaceAll(String regex, String replacement)；
3、替换首个：public String replaceFirst(String regex, String replacement)；
4、正则拆分：public String[] split(String regex)；
5、正则指定个数拆分：public String[] split(String regex, int limit)；

*范例*：实现字符串的替换

//删除非字母、数字
public class JavaApiDemo {
    public static void main(String[] args) throws Exception {
        String str = "asdasds$%^adfFASFSAFA$%^SFASDAsafdsad()adas.;$%^&$%^&*!@#$%^&*()dsdsadasd";
        String regex = "[^a-zA-Z0-9]+";
        System.out.println(str.replaceAll(regex, ""));//asdasdsadfFASFSAFASFASDAsafdsadadasdsdsadasd
    }
}

*范例*：实现字符串的拆分

public class JavaApiDemo {
    public static void main(String[] args) throws Exception {
        String str = "a1b22c333d4444e55555e666666f7777777g";
        String regex = "\\d+";
        String res[] = str.split(regex);
        for (String rs : res) {
            System.out.print(rs + "、");//a、b、c、d、e、e、f、g、
        }
    }
}

在正则处理时，拆分和替换的操作相对容易些，数据验证是比较麻烦的。
*范例*：判断一个数据是否为小数，如果是小数则将其变为double类型。

public class JavaApiDemo {
    public static void main(String[] args) throws Exception {
        String str = "100.3";//要判断的数据
        String regex = "\\d+(\\.\\d+)?";//正则表达式
        if (str.matches(regex)) {
            double v = Double.valueOf(str);
            System.out.println(str + "是小数，值为：" + v);
        } else {
            System.out.println(str + "不是小数");
        }
    }
}

*范例*：判断一个字符串是否是日期格式，如果是日期则转为Date类型

public class JavaApiDemo {
    public static void main(String[] args) throws Exception {
        String str = "2001-09-11 ";//要判断的数据
        String regex = "\\d{4}-\\d{2}-\\d{2}";//正则表达式
        if (str.matches(regex)) {
            SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
            Date d=sdf.parse(str);
            System.out.println(str + "是日期，值为：" + d);
        } else {
            System.out.println(str + "不是日期格式");
        }
    }
}

需要注意的是，正则表达式无法对字符串中的内容进行判断，只能对格式进行判断处理。
*范例*：判断给定的号码是否正确

电话号码：51283346、\d{7,8}；
电话号码：01051283346、(\d{3,4})?\d{7,8}；
电话号码：(010)-51283346、((\d{3,4})|((\d{3,4})-))?\d{7,8}；

public class JavaApiDemo {
    public static void main(String[] args) throws Exception {
        String phoneA = "51283346";
        String phoneB = "01051283346";
        String phoneC = "(010)-51283346";
        String regex = "((\\d{3,4})|(\\(\\d{3,4}\\)-))?\\d{7,8}";//正则表达式
        System.out.println(phoneA.matches(regex));
        System.out.println(phoneB.matches(regex));
        System.out.println(phoneC.matches(regex));
    }
}

既然已经可以使用正则进行验证了，那么下面就可以来实现一个email地址格式的验证。
*范例*：验证email格式

email的用户名可以由（字母、数字、）所组成（不能以开头）；
email的域名可以由（字母、数字、_、-）所组成；
email的域名后缀必须是：.cn、.com、.net、,com.cn、.gov；

在这里插入图片描述

public class JavaApiDemo {
    public static void main(String[] args) throws Exception {
        String email="jhflr999@qq.comxcn";
        String regex="[a-zA-Z0-9]\\w+@\\w+\\.(cn|com|net|com\\.cn|gov)";
        System.out.println(email.matches(regex));
    }
}

以上这几种匹配处理操作是最常用的几种处理形式。

ava.util.regex包支持

虽然大部分情况下都可以利用String类实现正则的操作，但是也有一些情况需要使用java.util.regex包中提供的正则处理类，在这个包里只有两个类：Pattern（正则编译类）、Matcher（正则匹配类）。
1、Pattern类

正则表达式的编译处理支持：public static Pattern compile(String regex)；
字符串的拆分操作：public String[] split(CharSequence input)；

import java.util.regex.Pattern;
public class JavaApiDemo {
    public static void main(String[] args) throws Exception {
        String str = "dad%^7dsa%^&dsa%^&d5678D%^&*dadasd";
        String regex = "[^a-zA-Z]+";
        Pattern pattern = Pattern.compile(regex);
        String[] res = pattern.split(str);
        for (String rs : res) {
            System.out.print(rs + "、");
        }
    }
}

2、Matcher类，实现了正则匹配的处理类，这个类的对象实例化依靠Pattern完成：

Pattern类提供的方法：public Matcher matcher(CharSequence input)；
当获取了Matcher类的对象后就可以利用该类的方法进行如下操作：
正则匹配：public boolean matches()
字符串替换：public String replaceAll(String replacement)；
*范例*：字符串匹配

import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class JavaApiDemo {
    public static void main(String[] args) throws Exception {
        String str = "101";
        String regex = "\\d+";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher=pattern.matcher(str);
        System.out.println(matcher.matches());//true
    }
}

*范例*：字符串替换

import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class JavaApiDemo {
    public static void main(String[] args) throws Exception {
        String str = "101TYUI))(())adsadsad3131231";
        String regex = "\\D+";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher=pattern.matcher(str);
        System.out.println(matcher.replaceAll(""));//1013131231
    }
}

如果只是拆分、替换、匹配三种操作，根本不需要使用java.util.regex开发包，使用String类都可以实现了。但是Matcher类中提供了分组的功能，这是String类不具备的。

import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class JavaApiDemo {
    public static void main(String[] args) throws Exception {
        //要求取出"#{内容}"标记中的所有内容
        String str="insert into student(id,name,age) values (#{id},#{name},#{age});" ;
        String regex="#\\{\\w+\\}";
        String regex2="#\\{(\\w+)\\}";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher=pattern.matcher(str);
        while (matcher.find()){
            System.out.print(matcher.group(0).replaceAll("#|\\{|\\}","")+"、");//id、name、age、
        }
        System.out.println();
        pattern = Pattern.compile(regex2);
         matcher=pattern.matcher(str);
        while (matcher.find()){
            System.out.print(matcher.group(1)+"、");//id、name、age、
        }
    }
}

java.util.regex开发包，如果不是进行一些复杂的正则处理一般情况下是不需要使用的，而String类提供的正则功能只是一些正则的基本操作。