java正则表达式笔记

Posted

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了java正则表达式笔记相关的知识，希望对你有一定的参考价值。

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

  •  A：正则表达式
    • 是指一个用来描述或者匹配一系列符合某个语法规则的字符串的单个字符串。其实就是一种规则。有自己特殊的应用。
    •  作用：比如注册邮箱,邮箱有用户名和密码,一般会对其限制长度,这个限制长度的事情就是正则表达式做的
                作用：专门用于操作字符串
                特点：用一些特定的符号来表示一些代码的操作.这样就简化书写.
                            所以学正则表达式,就是学习一些特殊符号的使用.
                    好处：可以简化对字符串的操作
                    弊端：符号定义越多,正则越长,阅读性越差
    • B：案例演示
      • 需求：校验qq号码.
        • 1： 要求必须是5-15位数字
        • 2： 0不能开头
        • 3： 必须都是数字
      • a:非正则表达式实现
      • b:正则表达式实现
    案例:
    1. package com.zxy.regex;
    3. public class Demo1_Regex {
    5. 	public static void main(String[] args) {
    6. 		System.out.println(checkQQ("012345"));
    7. 		System.out.println(checkQQ("a1b345"));
    8. 		System.out.println(checkQQ("123456"));
    9. 		System.out.println(checkQQ("1234567890987654321"));
    10. 		
    11. 		String regex = "[1-9]\\d{4,14}";
    12. 		System.out.println("2553868".matches(regex));
    13. 		System.out.println("012345".matches(regex));
    14. 		System.out.println("2553868abc".matches(regex));
    15. 	}
    16. 	
    17. 	/*
    18. 	 * 需求：校验qq号码.
    19. 	 * 1:要求必须是5-15位数字
    20. 	 * 2:0不能开头
    21. 	 * 3:必须都是数字
    22. 	 * 校验qq
    23. 	 * 1,明确返回值类型boolean
    24. 	 * 2,明确参数列表String qq
    25. 	 */
    26. 	public static boolean checkQQ(String qq) {
    27. 		boolean flag = true;		//如果校验qq不符合要求就把flag置为false,如果符合要求直接返回
    28. 		
    29. 		if(qq.length() >= 5 && qq.length() <= 15) {
    30. 			if(!qq.startsWith("0")) {
    31. 				char[] arr = qq.toCharArray();	//将字符串转换成字符数组
    32. 				for (int i = 0; i < arr.length; i++) {
    33. 					char ch = arr[i];			//记录每一个字符
    34. 					if(!(ch >= ‘0‘ && ch <= ‘9‘)) {
    35. 						flag = false;			//不是数字
    36. 						break;
    37. 					}
    38. 				}
    39. 			}else {
    40. 				flag = false;					//以0开头,不符合qq标准
    41. 			}
    42. 		}else {
    43. 			flag = false;						//长度不符合
    44. 		}
    45. 		return flag;
    46. 	}
    47. }


    2、字符类演示

    •  A：字符类(在java.util.regex包中的Pattern类中)
      •  [abc]               a、b 或 c（简单类） 
      •  [^abc]             任何字符，除了 a、b 或 c（否定） 
      •  [a-zA-Z]          a到 z 或 A到 Z，两头的字母包括在内（范围） 
      •  [0-9]                0到9的字符都包括
    案例:
    1. package com.zxy.regex;
    3. public class Demo2_Regex {
    5. 	/**
    6. 	 * [abc] a、b 或 c（简单类） 
    7. 		[^abc] 任何字符，除了 a、b 或 c（否定） 
    8. 		[a-zA-Z] a 到 z 或 A 到 Z，两头的字母包括在内（范围） 
    9. 		[a-d[m-p]] a 到 d 或 m 到 p：[a-dm-p]（并集） 
    10. 		[a-z&&[def]] d、e 或 f（交集） 
    11. 		[a-z&&[^bc]] a 到 z，除了 b 和 c：[ad-z]（减去） 
    12. 		[a-z&&[^m-p]] a 到 z，而非 m 到 p：[a-lq-z]（减去） 
    14. 	 */
    15. 	public static void main(String[] args) {
    16. 		//demo1();
    17. 		//demo2();
    18. 		//demo3();
    19. 		//demo4();
    20. 		//demo5();
    21. 		//demo6();
    22. 		demo7();
    23. 	}
    25. 	private static void demo7() {
    26. 		String regex = "[a-z&&[^m-p]]";//a-z,除了m-p
    27. 		System.out.println("m".matches(regex));
    28. 		System.out.println("a".matches(regex));
    29. 		System.out.println("z".matches(regex));
    30. 		System.out.println("n".matches(regex));
    31. 	}
    33. 	private static void demo6() {
    34. 		String regex = "[a-z&&[^bc]]";
    35. 		System.out.println("a".matches(regex));
    36. 		System.out.println("b".matches(regex));
    37. 		System.out.println("1".matches(regex));
    38. 	}
    40. 	private static void demo5() {
    41. 		String regex = "[a-z&&[def]]";						//取交集
    42. 		System.out.println("a".matches(regex));
    43. 		System.out.println("d".matches(regex));
    44. 	}
    46. 	private static void demo4() {
    47. 		String regex = "[a-d[m-p]]";
    48. 		System.out.println("a".matches(regex));
    49. 		System.out.println("m".matches(regex));
    50. 		System.out.println("n".matches(regex));
    51. 	}
    53. 	private static void demo3() {
    54. 		String regex = "[a-zA-Z]";
    55. 		System.out.println("a".matches(regex));
    56. 		System.out.println("A".matches(regex));
    57. 		System.out.println("z".matches(regex));
    58. 		System.out.println("Z".matches(regex));
    59. 		System.out.println("1".matches(regex));
    60. 		System.out.println("%".matches(regex));
    61. 	}
    63. 	private static void demo2() {
    64. 		String regex = "[^abc]";
    65. 		System.out.println("a".matches(regex));
    66. 		System.out.println("b".matches(regex));
    67. 		System.out.println("c".matches(regex));
    68. 		System.out.println("d".matches(regex));
    69. 		System.out.println("1".matches(regex));
    70. 		System.out.println("%".matches(regex));
    71. 		System.out.println("10".matches(regex));		//10代表1字符和0字符,不是单个字符
    72. 	}
    74. 	private static void demo1() {
    75. 		String regex = "[abc]";					//[]代表单个字符
    76. 		System.out.println("a".matches(regex));
    77. 		System.out.println("b".matches(regex));
    78. 		System.out.println("c".matches(regex));
    79. 		System.out.println("d".matches(regex));
    80. 		System.out.println("1".matches(regex));
    81. 		System.out.println("%".matches(regex));
    82. 	}
    84. }


    3、预定义字符类演示

    • A：预定义字符类
      •   .       任何字符(一个,两个点代表任意两个字符)
      •  \d      数字：[0-9]
      •  \w     单词字符：[a-zA-Z_0-9]
    案例:
    1. package com.zxy.regex;
    3. public class Demo3_Regex {
    5. 	/**
    6. 	 * 	. 任何字符
    7. 		\d 数字：[0-9] 
    8. 		\D 非数字： [^0-9] 
    9. 		\s 空白字符：[ \t\n\x0B\f\r] //空格,\t:制表符,\n:换行,\x0B:垂直制表符,\f:翻页,\r:回车
    10. 		\S 非空白字符：[^\s] 
    11. 		\w 单词字符：[a-zA-Z_0-9] 
    12. 		\W 非单词字符：[^\w] 
    14. 	 */
    15. 	public static void main(String[] args) {
    16. 		//demo1();
    17. 		//demo2();
    18. 		//demo3();
    19. 		//demo4();
    20. 		//demo5();
    21. 		//demo6();
    22. 		//demo7();
    23. 		System.out.println("\\");//要打印出\,并需再加一个\进行转义
    24. 	}
    26. 	private static void demo7() {
    27. 		String regex = "\\W";
    28. 		System.out.println("a".matches(regex));
    29. 		System.out.println("z".matches(regex));
    30. 		System.out.println("_".matches(regex));
    31. 		System.out.println("%".matches(regex));
    32. 	}
    34. 	private static void demo6() {
    35. 		String regex = "\\w";
    36. 		System.out.println("a".matches(regex));
    37. 		System.out.println("z".matches(regex));
    38. 		System.out.println("_".matches(regex));
    39. 		System.out.println("%".matches(regex));
    40. 	}
    42. 	private static void demo5() {
    43. 		String regex = "\\S";
    44. 		System.out.println(" ".matches(regex));
    45. 		System.out.println("	".matches(regex));
    46. 		System.out.println("a".matches(regex));
    47. 	}
    49. 	private static void demo4() {
    50. 		String regex = "\\s";
    51. 		System.out.println(" ".matches(regex));
    52. 		System.out.println("	".matches(regex)); 				//一个tab键
    53. 		System.out.println("    ".matches(regex)); 				//四个空格
    54. 	}
    56. 	private static void demo3() {
    57. 		String regex = "\\D";                                  //\D表示非字符
    58. 		System.out.println("0".matches(regex));
    59. 		System.out.println("9".matches(regex));
    60. 		System.out.println("a".matches(regex));
    61. 	}
    63. 	private static void demo2() {
    64. 		String regex = "\\d";					//\代表转义字符,如果想表示\d的话,需要\\d
    65. 		System.out.println("0".matches(regex));
    66. 		System.out.println("a".matches(regex));
    67. 		System.out.println("9".matches(regex));
    68. 	}
    70. 	private static void demo1() {
    71. 		String regex = "..";
    72. 		System.out.println("a".matches(regex));
    73. 		System.out.println("ab".matches(regex));
    74. 	}
    76. }

    4、数量词

    • A：Greedy 数量词 
      •  X?                 X，一次或一次也没有
      • X*                   X，零次或多次
      • X+                  X，一次或多次
      • X{n}               X，恰好 n 次 
      • X{n,}              X，至少 n 次 
      • X{n,m}           X，至少 n 次，但是不超过 m 次 
    案例:
    1. package com.zxy.regex;
    3. public class Demo4_Regex {
    5. 	/**
    6. 	 * Greedy 数量词 
    7. 		X?         X，一次或一次也没有 
    8. 		X*         X，零次或多次 
    9. 		X+         X，一次或多次 
    10. 		X{n}       X，恰好 n 次 
    11. 		X{n,}      X，至少 n 次 
    12. 		X{n,m}     X，至少 n 次，但是不超过 m 次 
    13. 	 */
    14. 	public static void main(String[] args) {
    15. 		//demo1();
    16. 		//demo2();
    17. 		//demo3();
    18. 		//demo4();
    19. 		//demo5();
    20. 		//demo6();
    21. 	}
    23. 	private static void demo6() {
    24. 		String regex = "[abc]{5,15}";
    25. 		System.out.println("abcba".matches(regex));
    26. 		System.out.println("abcbaabcabbabab".matches(regex));
    27. 		System.out.println("abcb".matches(regex));
    28. 		System.out.println("abcbaabaabcbaaba".matches(regex));
    29. 	}
    31. 	public static void demo5() {
    32. 		String regex = "[abc]{5,}";//>=5次
    33. 		System.out.println("abcba".matches(regex));
    34. 		System.out.println("abcbaabcabbabab".matches(regex));
    35. 		System.out.println("abcb".matches(regex));
    36. 		System.out.println("abcbaaba".matches(regex));
    37. 	}
    39. 	public static void demo4() {
    40. 		String regex = "[abc]{5}";
    41. 		System.out.println("abcba".matches(regex));
    42. 		System.out.println("abcbaabcabbabab".matches(regex));
    43. 		System.out.println("abcb".matches(regex));
    44. 		System.out.println("abcbaaba".matches(regex));
    45. 	}
    47. 	public static void demo3() {
    48. 		String regex = "[abc]+";
    49. 		System.out.println("".matches(regex));
    50. 		System.out.println("a".matches(regex));
    51. 		System.out.println("aaaaabbbbccccc".matches(regex));
    52. 	}
    54. 	public static void demo2() {
    55. 		String regex = "[abc]*";
    56. 		System.out.println("".matches(regex));
    57. 		System.out.println("abc".matches(regex));
    58. 		System.out.println("a".matches(regex));
    59. 		System.out.println("aaaa".matches(regex));
    60. 	}
    62. 	public static void demo1() {
    63. 		String regex = "[abc]?";
    64. 		System.out.println("a".matches(regex));
    65. 		System.out.println("b".matches(regex));
    66. 		System.out.println("c".matches(regex));
    67. 		System.out.println("d".matches(regex));
    68. 		System.out.println("".matches(regex));
    69. 	}
    71. }


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

    • A：正则表达式的分割功能
      • String类的功能：public String[] split(String regex)
    • B：案例演示
      • 正则表达式的分割功能
    案例:
    1. package com.zxy.regex;
    3. public class Demo5_Split {

    5. 	public static void main(String[] args) {
    6. 		//演示时先按照空格切割
    7. 		//再按点(.)切割,但是点(.)在正则表达式中代表任意字符,它具有特殊的含义
    8. 		//所以需要将点进行转义前面加\,但是要想表示出一个\,需要在前面再加一个\,
    9. 		//这样就成了\\.
    10. 		String s = "金三胖.郭美美.李dayone";
    11. 		String[] arr = s.split("\\.");				//通过正则表达式切割字符串
    12. 		
    13. 		for (int i = 0; i < arr.length; i++) {
    14. 			System.out.println(arr[i]);
    15. 		}
    16. 		
    17. 		System.out.println("11111111111111111");
    18. 	}
    20. }


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

    • A：案例演示
      •  需求：我有如下一个字符串:”91 27 46 38 50”，请写代码实现最终输出结果是：”27 38 46 50 91”
    案例:
    1. package com.zxy.test;
    3. import java.util.Arrays;
    5. public class Test1 {
    7. 	/**

    9. 	 * 分析:
    10. 	 * 1,将字符串切割成字符串数组
    11. 	 * 2,将字符串转换成数字并将其存储在一个等长度的int数组中
    12. 	 * 3,排序
    13. 	 * 4,将排序后的结果遍历并拼接成一个字符串
    14. 	 */
    15. 	public static void main(String[] args) {
    16. 		String s = "91 27 46 38 50";
    17. 		//1,将字符串切割成字符串数组
    18. 		String[] sArr = s.split(" ");
    19. 		//2,将字符串转换成数字并将其存储在一个等长度的int数组中
    20. 		int[] arr = new int[sArr.length];
    21. 		for (int i = 0; i < arr.length; i++) {
    22. 			arr[i] = Integer.parseInt(sArr[i]); 	//将数字字符串转换成数字
    23. 		}
    24. 		
    25. 		//3,排序
    26. 		Arrays.sort(arr);
    27. 		
    28. 		//4,将排序后的结果遍历并拼接成一个字符串27 38 46 50 91
    29. 		/*String str = "";
    30. 		for (int i = 0; i < arr.length; i++) {
    31. 			if(i == arr.length - 1) {
    32. 				str = str + arr[i];				//27 38 46 50 91
    33. 			}else {
    34. 				str = str + arr[i] + " ";		//27 38 46 50 
    35. 			}
    36. 		}
    37. 		
    38. 		System.out.println(str);*/
    39. 		
    40. 		StringBuilder sb = new StringBuilder();
    41. 		for (int i = 0; i < arr.length; i++) {
    42. 			if(i == arr.length - 1) {
    43. 				sb.append(arr[i]);
    44. 			}else {
    45. 				sb.append(arr[i] + " ");
    46. 			}
    47. 		}
    48. 		
    49. 		System.out.println(sb);
    50. 	}
    52. }


    7、正则表达式的替换功能

    • A：正则表达式的替换功能
      • String类的功能：public String replaceAll(String regex,String replacement)
    • B：案例演示
      • 正则表达式的替换功能
    案例:
    1. package com.zxy.regex;
    3. public class Demo6_ReplaceAll {	
    4. 	public static void main(String[] args) {
    5. 		String s = "wo111ai222zxy";
    6. 		String regex = "\\d";			//\\d代表的是任意数字
    7. 		
    8. 		String s2 = s.replaceAll(regex, "");
    9. 		System.out.println(s2);
    10. 	}
    12. }


    8、正则表达式的分组功能

    • A：正则表达式的分组功能
      • 捕获组可以通过从左到右计算其开括号来编号。例如，在表达式 ((A)(B(C))) 中，存在四个这样的组：
    1     ((A)(B(C))) 
    2     (A 
    3     (B(C)) 
    4     (C) 
    组零始终代表整个表达式。
    • B：案例演示
    a：切割
    需求：请按照叠词切割： "sdqqfgkkkhjppppkl";
    b：替换
    需求：我我....我...我.要...要要...要学....学学..学.编..编编.编.程.程.程..程
    将字符串还原成:“我要学编程”。

    (.)\\1+的含义：    表示第二个位置和(.)一样,但是第二个位置出现了1次或多次
            第一个字符是任意字符,但是第二位和第一位相同,即第二位用第一位的结果,
            所以将第一位的点(.)用括号()括起来(将要重用的部分用括号括起来,叫组),
            每组都有一个编号(从第一组开始)
    (.)通过"\"形式反向引用前面的组,\\1表示第一组的内容在\\1重新出现,可以1次或多次


    案例:
    1. package com.zxy.regex;
    3. public class Demo7_Regex {
    4. 	
    5. 	public static void main(String[] args) {
    6. 		//demo1();
    7. 		demo2();		
    8. 		//demo3();
    9. 	}
    11. 	private static void demo3() {
    12. 		/*
    13. 		 * 需求：我我....我...我.要...要要...要学....学学..学.编..编编.编.程.程.程..程
    14. 				将字符串还原成:“我要学编程”。
    15. 		 */
    16. 		String s = "我我....我...我.要...要要...要学....学学..学.编..编编.编.程.程.程..程";
    17. 		String s2 = s.replaceAll("\\.+", "");
    18. 		String s3 = s2.replaceAll("(.)\\1+", "$1");	//$1代表第一组中的内容
    19. 		System.out.println(s3);
    20. 	}
    22. 	public static void demo2() {
    23. 		//需求：请按照叠词切割： "sdqqfgkkkhjppppkl";
    24. 		String s = "sdqqfgkkkhjppppkl";
    25. 		//String regex = "(.)\\1";
    26. 		String regex = "(.)\\1+";					//+代表第一组出现一次到多次
    27. 		String[] arr = s.split(regex);
    28. 		
    29. 		for (int i = 0; i < arr.length; i++) {
    30. 			System.out.println(arr[i]);
    31. 		}
    32. 		System.out.println("---------------");
    33. 	}
    35. 	public static void demo1() {
    36. 		//叠词 快快乐乐,高高兴兴
    37. 		/*String regex = "(.)\\1(.)\\2";					//\\1代表第一组又出现一次	\\2代表第二组又出现一次
    38. 		System.out.println("快快乐乐".matches(regex));
    39. 		System.out.println("快乐乐乐".matches(regex));
    40. 		System.out.println("高高兴兴".matches(regex));
    41. 		System.out.println("死啦死啦".matches(regex));*/
    42. 		
    43. 		//叠词 死啦死啦,高兴高兴
    44. 		String regex2 = "(..)\\1";//第一组有两个字符,然后让第一组再出现一次
    45. 		System.out.println("死啦死啦".matches(regex2));
    46. 		System.out.println("高兴高兴".matches(regex2));
    47. 		System.out.println("快快乐乐".matches(regex2));
    48. 	}
    50. }

    9、Pattern和Matcher的概述

    • A：Pattern和Matcher的概述
    • B：模式和匹配器的典型调用顺序
      • 通过JDK提供的API，查看Pattern类的说明
                   典型的调用顺序是 
        • Pattern p = Pattern.compile("a*b");
        • Matcher m = p.matcher("aaaaab");
        • boolean b = m.matches();
    案例:
    1. package com.zxy.regex;
    3. import java.util.regex.Matcher;
    4. import java.util.regex.Pattern;
    6. public class Demo8_Pattern {
    7. 	
    8. 	public static void main(String[] args) {
    9. 		demo1();		
    10. 	}
    12. 	public static void demo1() {
    13. 		//"a*b":表示a出现的是0次或多次,后面跟一个b
    14. 		Pattern p = Pattern.compile("a*b");					//获取到正则表达式
    15. 		Matcher m = p.matcher("aaaaab");					//获取匹配器
    16. 		boolean b = m.matches();							//看是否能匹配,匹配就返回true
    17. 		
    18. 		System.out.println(b);
    19. 		
    20. 		System.out.println("aaaaab".matches("a*b"));  		//与上面的结果一样
    21. 	}
    23. }


    10、正则表达式的获取功能
    •  A：正则表达式的获取功能
      • Pattern和Matcher的结合使用
    •  B：案例演示
      • 需求：把一个字符串中的手机号码获取出来
    案例:
    1. package com.zxy.regex;
    3. import java.util.regex.Matcher;
    4. import java.util.regex.Pattern;
    6. public class Demo8_Pattern {
    8. 	public static void main(String[] args) {
    9. 		//demo1();
    10. 		//demo2();
    11. 		demo3();
    12. 	}
    13. 	//匹配查找邮箱
    14. 	private static void demo3() {//[1][\\d&&[012678]][\\d]{9}
    15. 		String s = "我的邮箱是[email protected],我曾经用过[email protected],我还用过[email protected]";
    16. 		//String regex = "[a-zA-Z0-9_][email protected][a-zA-Z0-9]+(\\.[a-zA-Z]+)+";//较为精确的匹配。
    17. 		String regex = "\\[email protected]\\w+(\\.\\w+)+";
    18. 		Pattern p = Pattern.compile(regex);
    19. 		Matcher matcher = p.matcher(s);
    20. 		while(matcher.find()){
    21. 			System.out.println(matcher.group());			
    22. 		}
    23. 	}
    24. 	//匹配查找手机号
    25. 	private static void demo2() {
    26. 		String s = "我的手机是18511866260,我曾用过18987654321,还用过18812345678";
    27. 		String regex = "1[3578]\\d{9}";
    28. 		
    29. 		
    30. 		Pattern p = Pattern.compile(regex);
    31. 		Matcher m = p.matcher(s);
    32. 		
    33. 		/*boolean b1 = m.find();
    34. 		System.out.println(b1);
    35. 		System.out.println(m.group());
    36. 		
    37. 		boolean b2 = m.find();
    38. 		System.out.println(b2);
    39. 		System.out.println(m.group());*/
    40. 		
    41. 		while(m.find())
    42. 			System.out.println(m.group());
    43. 	}
    44. }
































    以上是关于java正则表达式笔记的主要内容，如果未能解决你的问题，请参考以下文章

    Python学习笔记之正则表达式

    javascript学习笔记-正则表达式-少写1000行代码的正则表达式

    python基础学习笔记（十三）

    Java笔记：正则表达式

    JAVA正则表达式怎么匹配所有符合要求的子字符串

    java正则表达式笔记