java正则正向 java正则对象

转载

西门吹雪 2024-04-11 11:42:54

文章标签 java正则正向 java正则表达式对象 System bc Test 文章分类 Java 后端开发

14.01_常见对象(正则表达式的概述和简单使用)

A:正则表达式

是指一个用来描述或者匹配一系列符合某个语法规则的字符串的单个字符串。其实就是一种规则。有自己特殊的应用。

作用:比如注册邮箱,邮箱有用户名和密码,一般会对其限制长度,这个限制长度的事情就是正则表达式做的

B:案例演示

需求：校验qq号码.

1:要求必须是5-15位数字

2:0不能开头

3:必须都是数字

a:非正则表达式实现

@Test
public void testCheckQQ(){
System.out.println(checkQQ("012345"));
System.out.println(checkQQ("a1b345"));
System.out.println(checkQQ("123456"));
System.out.println(checkQQ("1234567890987654321"));
}
/**
* /*
* 需求：校验qq号码.
* 1:要求必须是5-15位数字
* 2:0不能开头
* 3:必须都是数字
* 校验qq
* 1,明确返回值类型boolean
* 2,明确参数列表String qq
*/
public static boolean checkQQ(String qq){
//如果校验qq不符合要求就把flag置为false,如果符合要求直接返回
boolean flag = true;
if(qq.length() >= 5 && qq.length()<=15){
if(!qq.startsWith("0")){
//将字符串转换成字符数组
char[] charArray = qq.toCharArray();
for(int i = 0;i= '0' && ch <= '9')){
flag = false; //不是数字
break;
}
}
}else{
flag = false;//以0开头，不符合qq标准
}
}else{
flag = false;//长度不符合
}
return flag;
}
- b:正则表达式实现
@Test
public void testCheckQQ(){
System.out.println(checkQQ("012345"));
System.out.println(checkQQ("a1b345"));
System.out.println(checkQQ("123456"));
System.out.println(checkQQ("1234567890987654321"));
String regex = "[1-9]\\d{4,14}";
System.out.println("2553868".matches(regex));
System.out.println("012345".matches(regex));
System.out.println("2553868abc".matches(regex));
}

14.02_常见对象(正则表达式-字符类演示)

A:字符类

[abc] a、b 或 c(简单类)

[^abc] 任何字符，除了 a、b 或 c(否定)

[a-zA-Z] a到 z 或 A到 Z，两头的字母包括在内(范围)

[0-9] 0到9的字符都包括

/**

* 字符类

[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](减去)

*/
@Test
public void testRegexChar1(){
String regex = "[abc]";
System.out.println("-----[abc](a、b或c)----");
System.out.println("a".matches(regex));
System.out.println("b".matches(regex));
System.out.println("e".matches(regex));
System.out.println("----[^abc](除了a、b或c ，否定)----");
String regex2 = "[^abc]";
System.out.println("a".matches(regex2));
System.out.println("b".matches(regex2));
System.out.println("e".matches(regex2));
System.out.println("----[a-zA-Z]--a到 z 或 A到 Z，两头的字母包括在内(范围)----");
String regex3 = "[a-zA-Z]";
System.out.println("a".matches(regex3));
System.out.println("z".matches(regex3));
System.out.println("A".matches(regex3));
System.out.println("Z".matches(regex3));
System.out.println("1".matches(regex3));
System.out.println("%".matches(regex3));
System.out.println("----[0-9]0到9的字符都包括----");
String regex4 = "[0-9]";
System.out.println("0".matches(regex4));
System.out.println("7".matches(regex4));
System.out.println("9".matches(regex4));
System.out.println("10".matches(regex4));
}
//打印结果如下：
-----[abc](a、b或c)----
true
true
false
----[^abc](除了a、b或c ，否定)----
false
false
true
----[a-zA-Z]--a到 z 或 A到 Z，两头的字母包括在内(范围)----
true
true
true
true
false
false
----[0-9]0到9的字符都包括----
true
true
true
false

14.03_常见对象(正则表达式-预定义字符类演示)

A:预定义字符类

. 任何字符(与行结束符可能匹配也可能不匹配)

\d 数字：[0-9]

\D 非数字： [^0-9]

\s 空白字符：[ \t\n\x0B\f\r]

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

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

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

package com.itheima.javabase.regex;
import org.junit.Test;
public class RegexDemo2 {
/*预定义字符类
. 任何字符(与行结束符可能匹配也可能不匹配)
\d 数字：[0-9]
\D 非数字： [^0-9]
\s 空白字符：[ \t\n\x0B\f\r]
\S 非空白字符：[^\s]
\w 单词字符：[a-zA-Z_0-9]
\W 非单词字符：[^\w]
*/
@Test
public void test1(){
String regex = "..";
System.out.println("---.匹配任何字符----");
System.out.println("a".matches(regex));
System.out.println("ab".matches(regex));
}
@Test
public void test2(){
String regex = "\\d"; //\代表转义字符,如果想表示\d的话,需要\\d
System.out.println("---\\d是数字----");
System.out.println("a".matches(regex));
System.out.println("0".matches(regex));
System.out.println("9".matches(regex));
}
@Test
public void test3(){
String regex = "\\D";
System.out.println("---\\D非数字----");
System.out.println("a".matches(regex));
System.out.println("0".matches(regex));
System.out.println("9".matches(regex));
}
@Test
public void test4(){
String regex = "\\S";
System.out.println("---\\S非空白字符----");
System.out.println(" ".matches(regex));
System.out.println("".matches(regex)); //一个tab键
System.out.println(" ".matches(regex)); //四个空格
}
@Test
public void test5(){
String regex = "\\w";
System.out.println("---\\S单词字符----");
System.out.println("a".matches(regex));
System.out.println("z".matches(regex));
System.out.println("_".matches(regex));
System.out.println("%".matches(regex));
}
@Test
public void test6(){
String regex = "\\W";
System.out.println("---\\W单词字符----");
System.out.println("a".matches(regex));
System.out.println("z".matches(regex));
System.out.println("_".matches(regex));
System.out.println("%".matches(regex));
}
}
//打印结果如下：
---.匹配任何字符----
false
true
---\d是数字----
false
true
true
---\D非数字----
true
false
false
---\S非空白字符----
false
false
false
---\S单词字符----
true
true
true
false
---\W单词字符----
false
false
false
true

14.04_常见对象(正则表达式-数量词)

A:Greedy 数量词

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

X* X，零次或多次

X+ X，一次或多次

X{n} X，恰好 n 次

X{n,} X，至少 n 次

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

package com.itheima.javabase.regex;
import org.junit.Test;
public class RegexDemo3{
/**
* Greedy 数量词
X? X，一次或一次也没有
X* X，零次或多次
X+ X，一次或多次
X{n} X，恰好 n 次
X{n,} X，至少 n 次
X{n,m} X，至少 n 次，但是不超过 m 次
*/
@Test
public void demo5() {
String regex = "[abc]{5,}";
System.out.println("X{n,} X，至少 n 次 ");
System.out.println("abcba".matches(regex));
System.out.println("abcbaabcabbabab".matches(regex));
System.out.println("abcb".matches(regex));
System.out.println("abcbaaba".matches(regex));
}
@Test
public void demo4() {
String regex = "[abc]{5}";
System.out.println("X{n} X，恰好 n 次 ");
System.out.println("abcba".matches(regex));
System.out.println("abcbaabcabbabab".matches(regex));
System.out.println("abcb".matches(regex));
System.out.println("abcbaaba".matches(regex));
}
@Test
public void demo3() {
String regex = "[abc]+";
System.out.println("X+ X，一次或多次 ");
System.out.println("".matches(regex));
System.out.println("a".matches(regex));
System.out.println("aaaaabbbbccccc".matches(regex));
}
@Test
public void demo2() {
String regex = "[abc]*";
System.out.println("零次或多次 ");
System.out.println("".matches(regex));
System.out.println("abc".matches(regex));
System.out.println("a".matches(regex));
}
@Test
public void demo1() {
System.out.println("X? X，一次或一次也没有 ");
String regex = "[abc]?";
System.out.println("a".matches(regex));
System.out.println("b".matches(regex));
System.out.println("c".matches(regex));
System.out.println("d".matches(regex));
System.out.println("".matches(regex));
}
}
//打印结果如下：
X? X，一次或一次也没有
true
true
true
false
true
零次或多次
true
true
true
X+ X，一次或多次
false
true
true
X{n} X，恰好 n 次
true
false
false
false
X{n,} X，至少 n 次
true
true
false
true

14.05_常见对象(正则表达式的分割功能)

A:正则表达式的分割功能

String类的功能：public String[] split(String regex)

B:案例演示

正则表达式的分割功能

@Test
public void testRegexSplit(){
String text = "tom.王五.李三.1111111";
String regex = "\\.";
String[] str_array = text.split(regex);
System.out.println(Arrays.toString(str_array));
}
//打印结果如下：
[tom, 王五, 李三, 1111111]

14.06_常见对象(把给定字符串中的数字排序-按正则表达式切割)

A:案例演示

需求：我有如下一个字符串:”91 27 46 38 50”，请写代码实现最终输出结果是：[27, 38, 46, 50, 91]

@Test
public void strSort(){
String str = "91 27 46 38 50";
String [] str_array = str.split(" ");
int [] array = new int[str_array.length];
for(int i = 0;i
array[i] = Integer.parseInt(str_array[i]);
}
Arrays.sort(array);
System.out.println(Arrays.toString(array));
}

打印结果如下：

[27, 38, 46, 50, 91]

14.07_常见对象(正则表达式的替换功能)

A:正则表达式的替换功能

String类的功能：public String replaceAll(String regex,String replacement)

B:案例演示

正则表达式的替换功能

@Test
public void regexReplace(){
String str = "91 27 46 38 50";
String replaceStr = str.replaceAll(" ", "@");
System.out.println(replaceStr);
}

//打印结果如下：

91@27@46@38@50

14.08_常见对象(正则表达式的分组功能)

A:正则表达式的分组功能

捕获组可以通过从左到右计算其开括号来编号。例如，在表达式 ((A)(B(C))) 中，存在四个这样的组：

1 ((A)(B(C)))

2 (A

3 (B(C))

4 (C)

组零始终代表整个表达式。

B:案例演示

a:切割

需求：请按照叠词切割： "sdqqfgkkkhjppppkl";

b:替换

需求：我我....我...我.要...要要...要学....学学..学.编..编编.编.程.程.程..程

将字符串还原成:“我要学编程”。

@Test
public void demo3() {
/*
* 需求：我我....我...我.要...要要...要学....学学..学.编..编编.编.程.程.程..程
将字符串还原成:“我要学编程”。
*/
String s = "我我....我...我.要...要要...要学....学学..学.编..编编.编.程.程.程..程";
String s2 = s.replaceAll("\\.+", "");
String s3 = s2.replaceAll("(.)\\1+", "$1");//$1代表第一组中的内容
System.out.println(s3);
}
@Test
public void demo2() {
//需求：请按照叠词切割： "sdqqfgkkkhjppppkl";
String s = "sdqqfgkkkhjppppkl";
String regex = "(.)\\1+";//+代表第一组出现一次到多次
String[] arr = s.split(regex);
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
@Test
public void demo1() {
//叠词 快快乐乐,高高兴兴
/*String regex = "(.)\\1(.)\\2";//\\1代表第一组又出现一次\\2代表第二组又出现一次
System.out.println("快快乐乐".matches(regex));
System.out.println("快乐乐乐".matches(regex));
System.out.println("高高兴兴".matches(regex));
System.out.println("死啦死啦".matches(regex));*/
//叠词 死啦死啦,高兴高兴
String regex2 = "(..)\\1";
System.out.println("死啦死啦".matches(regex2));
System.out.println("高兴高兴".matches(regex2));
System.out.println("快快乐乐".matches(regex2));
}

//打印结果如下：

true

false

我要学编程

14.09_常见对象(Pattern和Matcher的概述)

A:Pattern和Matcher的概述

B:模式和匹配器的典型调用顺序

通过JDK提供的API，查看Pattern类的说明

典型的调用顺序是

Pattern p = Pattern.compile("a*b");
Matcher m = p.matcher("aaaaab");
boolean b = m.matches();
@Test
public void patternDemo() {
Pattern p = Pattern.compile("a*b");//获取到正则表达式
Matcher m = p.matcher("aaaaab");//获取匹配器
boolean b = m.matches();//看是否能匹配,匹配就返回true
System.out.println(b);
System.out.println("aaaaab".matches("a*b")); //与上面的结果一样
}

//打印结果如下：

true

14.10_常见对象(正则表达式的获取功能)

A:正则表达式的获取功能

Pattern和Matcher的结合使用

B:案例演示

需求：把一个字符串中的手机号码获取出来

@Test
public void testPattern(){
//demo1();
String s = "我的手机是18988888888,我曾用过18987654321,还用过18812345678";
String regex = "1[3578]\\d{9}";
Pattern p = Pattern.compile(regex);
Matcher m = p.matcher(s);
/*boolean b1 = m.find();
System.out.println(b1);
System.out.println(m.group());
boolean b2 = m.find();
System.out.println(b2);
System.out.println(m.group());*/
while(m.find())
System.out.println(m.group());
}
//打印结果如下：
18988888888
18987654321
18812345678

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。