加入收藏 | 设为首页 | 会员中心 | 我要投稿 李大同 (https://www.lidatong.com.cn/)- 科技、建站、经验、云计算、5G、大数据,站长网!
当前位置: 首页 > 百科 > 正文

正则表达式

发布时间:2020-12-14 05:35:36 所属栏目:百科 来源:网络整理
导读:1.正则表达式的概述和简单使用 是指用来描述或匹配字符串是否符合自己的语法规则,其实就是一种规则,有自己特殊用途 比如注册账号时,会限制用户名和密码的长度,这个限制长度就是正则表达式做的 1 /* * 2 * B:案例演示 3 * 需求:校验qq号码. 4 * 1:要求必

1.正则表达式的概述和简单使用

  是指用来描述或匹配字符串是否符合自己的语法规则,其实就是一种规则,有自己特殊用途

  比如注册账号时,会限制用户名和密码的长度,这个限制长度就是正则表达式做的

 

 1     /**
 2          * B:案例演示
 3          * 需求:校验qq号码.
 4          * 1:要求必须是5-15位数字
 5          * 2:0不能开头
 6          * 3:必须都是数字
 7          */
 8         
 9          demo1();
10 //         正则表达式的匹配规则,用正则表达式实现
11         String regex = "[1-9]d{4,14}";   
12         
13         System.out.println("0123456".matches(regex));        //false
14         System.out.println("a1234567".matches(regex));        //false
15         System.out.println("930275779".matches(regex));        //true
16         System.out.println(Pattern.matches(regex,"1234567"));//true
17     }
18 
19     
20 //    用已循环和if语句实现
21     public static void demo1() {
22         System.out.println(checkQQ("012345"));        //false
23         System.out.println(checkQQ("930275779"));    //true
24         System.out.println(checkQQ("1234567891032489"));//false
25         System.out.println(checkQQ("2346"));        //false
26     }
27     public static boolean checkQQ(String s){
28         boolean flag = true;
29         //限制长度 5~15 之间
30         if(s.length()>=5 && s.length()<=15){
31             //不能以o开头
32             if(!(s.startsWith("0"))){
33                 // 把字符串转为字符数组
34                 char[] chars = s.toCharArray();
35                 //循环录入要判断的字符数组
36                 for(int i=0; i<chars.length; i++){
37                     char ch = chars[i];
38                     //输入的数字字符必须是0~9
39                     if(!(ch>=0 && ch<=9)){
40                         flag = false;
41                         break;
42                     }
43                 }
44             }else {
45                 flag = false;   //数字以0开头
46             }
47         }else {
48             flag = false;       // 长度不合法
49         }
50         return  flag;
51     }

?

2.字符类演示

  /**

   ?* ?[abc] ab c(简单类)

?  * ?[^abc] 任何字符,除了 ab c(否定)

?  * ?[a-zA-Z] a z A Z,两头的字母包括在内(范围)

?  * ?[a-d[m-p]] a d m p[a-dm-p](并集)

?  * ?[a-z&&[def]] de f(交集)

?  * ?[a-z&&[^bc]] a z,除了 b c[ad-z](减去)

?  * ?[a-z&&[^m-p]] a z,而非 m p[a-lq-z](减去)

?  */

?

 1     public static void main(String[] args) { 
 2 //         demo1();
 3         // demo2();
 4          demo3();
 5         // demo4();
 6         // demo5();
 7         // demo6();
 8     }
 9 
10     public static void demo1() {
11         String regex = "[abc]"; // []表示单个字符            只有abc这几个单个字符可以匹配
12         System.out.println("a".matches(regex)); // true
13         System.out.println("b".matches(regex)); // true
14         System.out.println("++++++++++");
15         System.out.println("m".matches(regex)); // false
16         System.out.println("n".matches(regex)); // false
17         
18     }
19 
20     public static void demo2() {
21         String regex = "[^abc]";                //除了abc的单个字符以外,任何单个字符都能满足匹配
22         System.out.println("a".matches(regex));    // false
23         System.out.println("m".matches(regex)); // true
24         System.out.println("sd".matches(regex));//false            是两个字符
25     }
26 
27     private static void demo3() {
28         //    取交集,也就是两个范围内,相同的单个字符     "[a-z&&[def]]"也是一样
29         String regex = "[ac&&[dc]]";        
30         System.out.println("a".matches(regex));
31         System.out.println("c".matches(regex));
32         System.out.println("%".matches(regex)); // false
33     }
34 
35     private static void demo4() {
36         String regex = "[a-d[m-p]]";        //取并集,就是两个范围内的所有单个字符
37         System.out.println("a".matches(regex));
38         System.out.println("m".matches(regex));
39         System.out.println("n".matches(regex));
40     }
41 
42     private static void demo6() {
43         String regex = "[a-z&&[^bc]]";    //在a-z的单个字符内,除去  bc 这两个单个字符以外,都匹配
44         System.out.println("a".matches(regex));
45         System.out.println("b".matches(regex));
46         System.out.println("1".matches(regex));
47     }

?

3.预定义字符类

  /**
  ?* ??????任何字符
  ?* ???????d 数字:[0-9] ---代表单个的数字字符。 是转义字符
  ?* ???????D 非数字: [^0-9] ----取反
  ?* ???????s 空白字符:[ tnx0Bfr] 代表垂直制表符。f代表翻页dos系统里的,r回车,
  ?* ???????S 非空白字符:[^s]
  ?* ???????w 单词字符:[a-zA-Z_0-9]
  ?* ???????W 非单词字符:[^w]

  *?  .? 代表任意字符,一个点代表一个字符
  ?*/

?

 1 public static void main(String[] args) {
 2         demo1();
 3         demo2();
 4         demo3();
 5         demo4();
 6         demo5();
 7         demo6();
 8     }
 9 
10     private static void demo6() {
11         // W   取反  非单词字符
12         String regex = "w";    //单词字符
13         System.out.println("a".matches(regex)); // true
14         System.out.println("z".matches(regex)); // true
15         System.out.println("_".matches(regex)); // true
16         System.out.println("9".matches(regex)); // false
17     }
18 
19     private static void demo5() {
20         String regex = "S";        // 取反 ,非空白字符
21         System.out.println(" ".matches(regex)); // 空格 false
22         System.out.println("   ".matches(regex)); // tab键 false
23         System.out.println("a".matches(regex)); // true
24     }
25 
26     private static void demo4() {
27         String regex = "s"; // 匹配空白
28         System.out.println(" ".matches(regex));                        //true
29         System.out.println("    ".matches(regex)); // 一个tab键        true
30         System.out.println("    ".matches(regex)); // 四个空格        false
31     }
32 
33     private static void demo3() {
34         String regex = "D";    // [^0-9]取反,除了数字字符以外都为true
35         System.out.println("0".matches(regex)); // false
36         System.out.println("9".matches(regex)); // false
37         System.out.println("a".matches(regex)); // true
38     }
39 
40     private static void demo2() {
41         String regex = "d"; // 代表转义字符,如果想表示d的话,需要d        代表[0-9]单个的数字字符,    
42         System.out.println("0".matches(regex)); // true
43         System.out.println("a".matches(regex)); // false
44         System.out.println("9".matches(regex)); // true
45     }
46 
47     private static void demo1() {
48         String regex = "..";// 点代表任意字符, 一个点代表一个字符,两个点代表两个字符。
49         System.out.println("a".matches(regex)); // f
50         System.out.println("ab".matches(regex)); // t
51     }

?

4.数量词

  

  * A:Greedy 数量词?

  * X? X,一次或一次也没有

  * X* X,零次或多次

  * X+ X,一次或多次

  * X{n} X,恰好?n ?

  * X{n,} X,至少?n ?

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

?

 1     public static void main(String[] args) {
 2          demo1();
 3          demo2();
 4          demo3();
 5          demo4();
 6          demo5();
 7          demo6();
 8     }
 9 
10     private static void demo6() {
11         String regex = "[abc]{5,15}";//范围内的单个字符出现了至少5次,但不超过15次
12         System.out.println("abcba".matches(regex));                //true
13         System.out.println("abcbaabcabbabab".matches(regex));    //true
14         System.out.println("abcb".matches(regex));                //false
15         System.out.println("abcbaabaabcbaaba".matches(regex));    //false
16     }
17 
18     public static void demo5() {
19         String regex = "[abc]{5,}";    //范围内的单个字符至少出现了5次,
20         System.out.println("abcba".matches(regex));            //true
21         System.out.println("abcbaabcabbabab".matches(regex));//true
22         System.out.println("abcb".matches(regex));            //false
23         System.out.println("abcbaaba".matches(regex));        //true
24     }
25 
26     public static void demo4() {
27         String regex = "[abc]{5}";    //范围内的单个字符 恰好出现了5次,
28         System.out.println("abcba".matches(regex));                //true
29         System.out.println("abcbaabcabbabab".matches(regex));    //false
30         System.out.println("abcb".matches(regex));                //false
31         System.out.println("abcbaaba".matches(regex));            //false
32     }
33 
34     public static void demo3() {
35         String regex = "[abc]+";    //范围内的单个符出现了一次或多次
36         System.out.println("".matches(regex));                //false        一次没出现false
37         System.out.println("a".matches(regex));                //true
38         System.out.println("aaaaabbbbccccc".matches(regex));//true
39     }
40 
41     public static void demo2() {
42         String regex = "[abc]*";    //     范围内的单个字符只出现零次或多次    出现一次也正确
43         System.out.println("".matches(regex));                //true
44         System.out.println("abc".matches(regex));            //true
45         System.out.println("a".matches(regex));                //true
46         System.out.println("v".matches(regex));                //false
47     }
48 
49     public static void demo1() {
50         String regex = "[abc]?";    // 范围内的单个字符只出现了一次或一次也没有    空的也是true
51         System.out.println("a".matches(regex));                //true
52         System.out.println("b".matches(regex));                //trrue
53         System.out.println("d".matches(regex));                //false
54         System.out.println("".matches(regex));                //true
55     }

?

5.正则表达式的分割功能  

/**
?* *A:正则表达式的分割功能
?* ???????* String类的功能:public String[] split(String regex)
?* ?????Split(“.”).表示任意字符。要转义 .
?* ????* B:案例演示
?* ???????* 正则表达式的分割功能
?*/

  split()是分割方法

1 public static void main(String[] args) {
2         String s = "我们,是,一家人";
3         String[] arr = s.split(",");
4         for (int i = 0; i < arr.length; i++) {
5             System.out.println(arr[i]);
6         }
7         System.out.println("++++++++++++");
8     }

    //输出结果为 我们
            是
            一家人

?

6.把给定字符串中的数字排序

?

  /*

?  * @param args

?  * * A:案例演示

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

  ?* 100

  ?* 80

   */

  

 1 /**
 2           *  1. 切分这个字符串,使用的方法就是split(),传入的内容为分隔符
 3           *   2. split方法返回的是一个字符串数组
 4           */
 5         String s = "91 27 46 38 50 600";
 6         // 1:将字符串切割为字符数组
 7         String[] sarr = s.split(" ");
 8         // 2:将字符串转换成数字并存储在一个等长度的int数组中
 9         Arrays.sort(sarr);
10         for (int i = 0; i < sarr.length; i++) {
11             System.out.print(sarr[i] + " ");
12         }
13         System.out.println();
14         System.out.println("++++++++++++++++++++++++++++");
15         int[] iarr = new int[sarr.length];
16         for (int i = 0; i < iarr.length; i++) {
17             iarr[i] = Integer.parseInt(sarr[i]);
18         }
19         Arrays.sort(iarr);
20         StringBuffer s1 = new StringBuffer();
21         for (int i = 0; i < iarr.length; i++) {
22             // 如果i等于最后一个元素,
23             if (i == iarr.length - 1) {
24                 s1.append(iarr[i]);
25             } else {
26                 s1.append(iarr[i] + " ");
27             }
28         }
29         System.out.println(s1);// 27 38 46 50 91
30 
31     }

(编辑:李大同)

【声明】本站内容均来自网络,其相关言论仅代表作者个人观点,不代表本站立场。若无意侵犯到您的权利,请及时与联系站长删除相关内容!

    推荐文章
      热点阅读