java正则表达式对象_3-java常见对象-正则表达式

格秒索杉

于 2021-02-16 22:48:24 发布

阅读量113

点赞数

文章标签： java正则表达式对象

本文链接：https://blog.csdn.net/weixin_42133329/article/details/114250856

版权

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

false

----[^abc](除了a、b或c ，否定)----

false

true

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

true

false

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

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

---\D非数字----

true

false

---\S非空白字符----

false

---\S单词字符----

true

false

---\W单词字符----

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

false

true

零次或多次

true

X+ X，一次或多次

false

true

X{n} X，恰好 n 次

true

false

X{n,} X，至少 n 次

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

格秒索杉

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java正则表达式对象_3-java常见对象-正则表达式

14.01_常见对象(正则表达式的概述和简单使用)A:正则表达式是指一个用来描述或者匹配一系列符合某个语法规则的字符串的单个字符串。其实就是一种规则。有自己特殊的应用。作用:比如注册邮箱,邮箱有用户名和密码,一般会对其限制长度,这个限制长度的事情就是正则表达式做的B:案例演示需求：校验qq号码.1:要求必须是5-15位数字2:0不能开头3:必须都是数字a:非正则表达式实现@Testpublic v...
复制链接

扫一扫