Java_正则表达式

最新推荐文章于 2022-05-01 01:00:00 发布

weixin_33753003

最新推荐文章于 2022-05-01 01:00:00 发布

阅读量135

点赞数

文章标签： java javascript ViewUI

原文链接：http://www.cnblogs.com/guwenren/archive/2013/04/15/3022386.html

版权

3.11、正则表达式（重点）

3.11.1 、正则表达式的引出

下面完成一个简单的程序，在之前曾经讲解过这样一段代码：判断一个字符串是否由数字组成。

范例：代码实现

package cn.mldn.demo;

public class TestDemo {

public static void main(String[] args) throws Exception {

String str = " 13412a 4124214141232" ;

if (isNumber(str)) {

System.out.println("是由数字所组成！");

} else {

System.out.println("不是由数字所组成！");

}

public static boolean isNumber(String data) {

char arr [] = data.toCharArray() ; // 字符串变为字符数组

for (int x = 0; x < arr.length; x++) {

if (arr[x] < '0' || arr[x] > '9') {

return false ;

}

return true ;

}

但是现在一个简单的问题就出现了，这个验证应该算是不难的，但是面对这样一个不麻烦的验证，代码写了9行代码，如果是一些更为复杂的验证呢？那么对于整体操作就更加的麻烦了，现在有另外一种做法：

package cn.mldn.demo;

public class TestDemo {

public static void main(String[] args) throws Exception {

String str = "1341224124214141232" ;

if (str.matches("\\d+")) {

System.out.println("是由数字所组成！");

} else {

System.out.println("不是由数字所组成！");

}

很明显，现在对于程序而言，第二种方式更加的简单，而第二种方式就是使用了正则表达式的概念，而其中的“\\d+”代码就属于正则表达式的程序代码。

正则表达式最早是在Linux下发展起来的，但是由于其使用方便，在JDK 1.4的时候将其正式引入到了Java的开发行列之中，而在JDK 1.4之前如果要想使用正则表达式，那么需要单独配置一个Apache的开发包，而JDK 1.4之后除了引入了正则的支持之外，同时也对String类进行了一些修改，可以让其直接操作正则。

在JDK 1.4之后专门引入了一个java.util.regex开发包，这个包之中有两个主要类负责完成正则的开发：Pattern（定义并且编译正则的匹配模板）、Matcher（匹配应用），之所以现在不去关心这两个类，主要是因为JDK 1.4之后对String类的修改达到了一个很好的正则操作效果，主要使用String类完成。

3.11.2 、常用正则匹配符号（背，死了都要背）

所有的正则匹配的符号都在java.util.regex.Pattern类之中进行定义，下面分别对这些常用的符号做一些介绍。

1、字符：匹配单个字符

· a：表示匹配字母a；

· \\：匹配转义字符“\”；

· \t：匹配转义字符“\t”；

· \n：匹配转义字符“\n”；

2、一组字符：任意匹配里面的一个单个字符；

· [abc]：表示可能是字母a，可能是字母b或者是字母c；

· [^abc]：表示不是字母a、字母b、字母c的任意一个；

· [a-zA-Z]：表示全部字母中的任意一个；

· [0-9]：表示全部数字的任意一个；

3、边界匹配：在以后编写JavaScript的时候使用正则中要使用到；

· ^：表示一组正则的开始；

· $：表示一组正则的结束；

4、简写表达式：每一位出现的简写标记也只表示一位；

· .：表示任意的一位字符；

· \d：表示任意的一位数字，等价于“[0-9]”；

· \D：表示任意的一位非数字，等价于“[^0-9]”；

· \w：表示任意的一位字母、数字、_，等价于“[a-zA-Z0-9_]”；

· \W：表示任意的一位非字母、数字、_，等价于“[^a-zA-Z0-9_]”；

· \s：表示任意的一位空格，例如：\n、\t等；

· \S：表示任意的一位非空格；

5、数量表示：之前的所有正则都只是表示一位，如果要想表示多位，则就需要数量表示。

· 正则表达式?：此正则出现0次或1次；

· 正则表达式*：此正则出现0次、1次或多次；

· 正则表达式+：此正则出现1次或多次；

· 正则表达式{n}：此正则出现正好n次；

· 正则表达式{n,}：此正则出现n次以上；

· 正则表达式{n,m}：此正则出现n ~ m次。

6、逻辑表示：与、或、非

· 正则表达式A正则表达式B：表达式A之后紧跟着表达式B；

· 正则表达式A|正则表达式B：表示表达式A或者是表达式B，二者任选一个出现；

· (正则表达式)：将多个子表达式合成一个表示，作为一组出现。

3.11.3 、String类对正则的支持

在JDK 1.4之后，String类对正则有了直接的方法支持，只需要通过如下的几个方法就可以操作正则。

No.	方法名称	类型	描述
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)	普通	按照指定的正则拆分为指定个数

Pattern类之中存在的方法：

· 字符串全拆分：public String[] split(CharSequence input)；

· 字符串部分拆分：public String[] split(CharSequence input, int limit)；

Matterh类之中存在的方法：

· 字符串匹配：public boolean matches()；

· 字符串全替换：public String replaceAll(String replacement)；

· 字符串替换首个：public String replaceFirst(String replacement)。

正是因为String类支持的方法比较全面，所以在开发之中，主要的都是String类操作正则，因为方便。下面编写若干个操作实例来进行正则的验证。

范例：字符串拆分

package cn.mldn.demo;

public class TestDemo {

public static void main(String[] args) throws Exception {

String str = "a1bb2ccc3dddd4eeeee5fffffff6ggggggg7" ;

String regex = "[a-zA-Z]+" ;// 字母出现1次或多次

System.out.println(str.replaceAll(regex, ""));

System.out.println(str.replaceFirst(regex, ""));

}

范例：字符串拆分

package cn.mldn.demo;

public class TestDemo {

public static void main(String[] args) throws Exception {

String str = "a1bb2ccc3dddd4eeeee5fffffff6ggggggg7" ;

String regex = "\\d" ;// 数字出现1次，[0-9]

String result [] = str.split(regex) ;

for (int x = 0; x < result.length; x++) {

System.out.print(result[x] + "、");

}

有了正则，对于字符串日后的种种操作就会变的相当的方便。而正则在使用的过程之中最为重要的部分就是验证部分，因为一些字符串必须满足于指定的格式才可以操作。

范例：做一个简单的验证，要求字符串格式“aaaaab”，在b之前可以有无数多个a，但是不能没有，至少1个。

package cn.mldn.demo;

public class TestDemo {

public static void main(String[] args) throws Exception {

String str = "aaaaaab" ;

String regex = "a+b" ;

System.out.println(str.matches(regex));

}

范例：验证一个字符串是否是整型数据，如果是则将其变为int型数据，而后执行乘法操作

package cn.mldn.demo;

public class TestDemo {

public static void main(String[] args) throws Exception {

String str = "123" ;

String regex = "\\d+" ;

if (str.matches(regex)) { // 符合于验证要求

int data = Integer.parseInt(str) ; // 字符串变为int型数据

System.out.println(data * data);

} else {

System.out.println("字符串不是数字所组成！");

}

范例：验证字符串是否是小数，如果是则将其变为double型数据，而后执行乘法操作

package cn.mldn.demo;

public class TestDemo {

public static void main(String[] args) throws Exception {

String str = "123.1" ;

String regex = "\\d+(\\.\\d+)?" ;

if (str.matches(regex)) { // 符合于验证要求

double data = Double.parseDouble(str) ; // 字符串变为double型数据

System.out.println(data * data);

} else {

System.out.println("字符串不是数字所组成！");

}

范例：输入一个字符串，按照年-月-日时-分-秒的形式，如果正确，则将其变为Date型数据

package cn.mldn.demo;

import java.text.SimpleDateFormat;

import java.util.Date;

public class TestDemo {

public static void main(String[] args) throws Exception {

String str = "1998-09-18 10:10:10.100" ;

String regex = "\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}\\.\\d{3}" ;

if (str.matches(regex)) { // 符合于验证要求

Date date = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS")

.parse(str);

System.out.println(date);

} else {

System.out.println("字符串不是日期！");

}

范例：一个用户名只能由字母、数字、_所组成，其长度只能是6~15位

package cn.mldn.demo;

public class TestDemo {

public static void main(String[] args) throws Exception {

String str = "343234FDSF_";

String regex = "\\w{6,15}";

if (str.matches(regex)) { // 符合于验证要求

System.out.println("用户名合法。");

} else {

System.out.println("用户名非法！");

}

范例：现在编写一个正则表达式要求验证电话号码是否正确，例如：现在写上咱们电话号码，有如下几种写法：

· 写法一：51283346 è \\d{7,8}；

· 写法二：01051283346 è (\\d{3,4})?\\d{7,8}；

· 写法三：010-51283346 è (\\d{3,4})?-?\\d{7,8}；

· 写法四：(010)-51283346 è ((\\d{3,4}|\$\\d{3,4}\$)-?)?\\d{7,8}；

· 写法五：(010)51283346 è ((\\d{3,4}|\$\\d{3,4}\$)-?)?\\d{7,8}。

package cn.mldn.demo;

public class TestDemo {

public static void main(String[] args) throws Exception {

String str = "51283346";

// 第一步：\\d{7,8}，因为电话号码可能是7~8位所组成；

// 第二步：(\\d{3,4})?\\d{7,8}，因为区号由3~4位所组成；

// 第三步：(\\d{3,4})?-?\\d{7,8}，因为-可能出现也可能不出现

// 第四步：((\\d{3,4}|\$\\d{3,4}\$)-?)?\\d{7,8}

String regex = "((\\d{3,4}|\$\\d{3,4}\$)-?)?\\d{7,8}";

if (str.matches(regex)) { // 符合于验证要求

System.out.println("TRUE，电话号码输入合法。");

} else {

System.out.println("FLASE，电话号码输入非法！");

}

范例：现在要求验证一个email地址，email地址的用户名由字母、数字、_、.所组成，其中不能以数字和.开头，而且email地址的域名只能是.com、.cn、.net

package cn.mldn.demo;

public class TestDemo {

public static void main(String[] args) throws Exception {

String str = "mldnqa@163.net";

String regex = "[a-zA-Z_][a-zA-Z_0-9\\.]*@[a-zA-Z_0-9\\.]+\\.(com|cn|net)";

if (str.matches(regex)) { // 符合于验证要求

System.out.println("TRUE，EMAIL输入合法。");

} else {

System.out.println("FLASE，EMAIL输入非法！");

}

范例：现在判断一个字符串的组成，其组成原则“姓名:年龄:成绩|姓名:年龄:成绩|姓名:年龄:成绩|…”

例如，现在有一个字符串内容如下：“SMITH:19:90.1|ALLEN:18:90.1|KING:20:95.2|”，其中姓名的组成只能是字母，年龄只能是数字，成绩可能是小数。

第一问：写出来验证的正则表达式

package cn.mldn.demo;

public class TestDemo {

public static void main(String[] args) throws Exception {

String str = "SMITH:19:90.1|ALLEN:18:90.1|KING:20:95.2";

String regex = "([a-zA-Z]+:\\d{1,3}:\\d{1,3}(\\.\\d{1,2})?\\|)+([a-zA-Z]+:\\d{1,3}:\\d{1,3}(\\.\\d{1,2})?)?";

if (str.matches(regex)) { // 符合于验证要求

System.out.println("TRUE，输入合法。");

} else {

System.out.println("FLASE，输入非法！");

}

第二问：将所有的数据排序，按照成绩由高到低排序，如果成绩相同，则按照年龄由低到高排序

既然是排序操作，现在可以想到的方法就是：Arrays.sort()，但是现在这些数据可以将其变为对象数组排序，利用比较器完成。

package cn.mldn.demo;

import java.util.Arrays;

class Student implements Comparable<Student> {

private String name ;

private int age ;

private double score ;

public Student(String name,int age,double score) {

this.name = name ;

this.age = age ;

this.score = score ;

}

@Override

public String toString() {

return "Student [name=" + name + ", age=" + age + ", score=" + score

+ "]\n";

}

@Override

public int compareTo(Student o) {

if (this.score > o.score) {

return -1 ;

} else if (this.score < o.score) {

return 1 ;

} else {

if (this.age > o.age) {

return 1 ;

} else if (this.age < o.age){

return -1 ;

} else {

return 0 ;

}

public class TestDemo {

public static void main(String[] args) throws Exception {

String str = "SMITH:19:90.1|ALLEN:18:90.1|KING:20:95.2";

String regex = "([a-zA-Z]+:\\d{1,3}:\\d{1,3}(\\.\\d{1,2})?\\|)+([a-zA-Z]+:\\d{1,3}:\\d{1,3}(\\.\\d{1,2})?)?";

if (str.matches(regex)) { // 符合于验证要求

String result [] = str.split("\\|") ; // 拆分

Student stu [] = new Student[result.length]; // 此时的数组大小就是对象数组大小

for (int x = 0; x < result.length; x++) {

String temp [] = result[x].split(":") ;

stu[x] = new Student(temp[0], Integer.parseInt(temp[1]),

Double.parseDouble(temp[2]));

}

Arrays.sort(stu) ;

System.out.println(Arrays.toString(stu));

} else {

System.out.println("FLASE，输入非法！");

}

因为在日后的所有项目的开发之中，只要是输入的数据都是利用字符串接收的，那么字符串又可以向各个数据类型转换，而要转换之前为了保证转换成功一定需要进行验证，验证最方便的就是正则表达式。

转载于:https://www.cnblogs.com/guwenren/archive/2013/04/15/3022386.html

weixin_33753003

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java_正则表达式

3.11、正则表达式（重点）3.11.1 、正则表达式的引出下面完成一个简单的程序，在之前曾经讲解过这样一段代码：判断一个字符串是否由数字组成。范例：代码实现package cn.mldn.demo;public class TestDemo { public static void main(String[] args) throw...
复制链接

扫一扫