• 正则表达式

    正则表达式规则可以匹配
    A指定字符A
    \u548c指定Unicode字符和
    .任意字符a, b, &, 0, ...
    \d0-90, 1, 2, ..., 9
    \wa-z, A-Z, 0-9, _a, A, 0, _, ...
    \s空格、tab键“ ”
    \D非数字a, A, &, _, ...
    \W非\w&, @, 中, ...
    \S非\sa, A, &, _, ...
    AB*任意个数字符A, AB, ABB, ABBB
    AB+至少1个字符AB, ABB, ABBB
    AB?0个或1个字符A, AB
    AB{3}指定个数字符ABBB
    AB{1, 3}指定范围个数字符AB, ABB, ABBB
    AB{2,}至少n个字符ABB, ABBB, ...
    AB{0, 3}最多n个字符A, AB, ABB, ABBB

     

    1. // java版本：
    2. public class test {
    3.  
    4.     // 区号（3-4个数字）-电话号码（6-8个数字）
    5.     public static boolean isValidTel(String s) {
    6.         //return s.matches("\\d{3,4}\\-\\d{6,8}");
    7.         //国内区号以0开头
    8.         return s.matches("0\\d{2,3}\\-\\d{6,8}");
    9.     }
    10.  
    11.     public static void main(String[] args) {
    12.         System.out.println(isValidTel("010-123456"));
    13.         System.out.println(isValidTel("0123-12345678"));
    14.         System.out.println(isValidTel("123-0123456"));
    15.  
    16.         System.out.println("------");
    17.         System.out.println(isValidTel("010#12345678"));
    18.         System.out.println(isValidTel("010X12345678"));
    19.         System.out.println(isValidTel("01-12345678"));
    20.         System.out.println(isValidTel("01234-12345678"));
    21.         System.out.println(isValidTel("01A-12345678"));
    22.         System.out.println(isValidTel("012-1234567A"));
    23.     }
    24. }
    25.  
    26. true
    27. true
    28. false
    29. ------
    30. false
    31. false
    32. false
    33. false
    34. false
    35. false
    1. # python版本：
    2. import re
    3.  
    4. def isValidTel(str):
    5. 	# 国内区号以0开头
    6. 	# 匹配成功 re.match 方法返回一个匹配的对象，否则返回 None
    7. 	return re.match(r'^0\d{2,3}\-\d{6,8}$', str)
    8.  
    9. print(isValidTel("010-123456"));
    10. print(isValidTel("0123-12345678"));
    11. print(isValidTel("123-0123456"));
    12.  
    13. print("------");
    14. print(isValidTel("010#12345678"));
    15. print(isValidTel("010X12345678"));
    16. print(isValidTel("01-12345678"));
    17. print(isValidTel("01234-12345678"));
    18. print(isValidTel("01A-12345678"));
    19. print(isValidTel("012-1234567A"));
    20.  
    21. # re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；
    22. # 而re.search匹配整个字符串，直到找到一个匹配
    23. print("------");
    24. print(re.match(r'0\d{2,3}\-\d{6,8}', "1012-1234567A")); # None
    25. print(re.search(r'0\d{2,3}\-\d{6,8}', "1012-1234567A")); # 
    26.  
    27. print("------");
    28. pattern2 = re.compile(r'^0\d{2,3}\-\d{6,8}$')
    29. match2 = pattern2.match("0123-12345678")
    30. if match2:
    31.     print(match2.group()) # "0123-12345678"
    32.     print(match2.start()) # "0"
    33.     print(match2.end()) # "13"
    34.  
    35.  
    36. object; span=(0, 10), match='010-123456'>
    37. object; span=(0, 13), match='0123-12345678'>
    38. None
    39. ------
    40. None
    41. None
    42. None
    43. None
    44. None
    45. None
    46. ------
    47. None
    48. object; span=(1, 12), match='012-12345678'>
    49. ------
    50. 0123-12345678
    51. 0
    52. 13

    正则表达式规则可以匹配
    ^开头字符串开头
    $结尾字符串结束
    [ABC][...]内任意字符A, B, C
    [A-F0-9xy]指定范围的字符A, ..., F, 0, ..., 9, x, y
    [^A-F]指定范围外的任意字符非A, ..., F
    AB|CDAB或CDAB, CD
    AB|CD|EFGAB或CD或EFGAB, CD, EFG
    1. // java版本：
    2. public class test {
    3.  
    4.     // 区号（3-4个数字）-电话号码（6-8个数字）
    5.     public static boolean isValidTel(String s) {
    6.         //return s.matches("\\d{3,4}\\-\\d{6,8}");
    7.         //国内区号以0开头，电话号码不能以0开头
    8.         return s.matches("0\\d{2,3}\\-[1-9]\\d{5,7}");
    9.     }
    10.  
    11.     // QQ号码
    12.     public static boolean isValidQQ(String s) {
    13.         return s.matches("^[1-9]\\d{4,9}$");
    14.     }
    15.  
    16.     public static void main(String[] args) {
    17.         System.out.println(isValidQQ("10000"));
    18.         System.out.println(isValidQQ("99999"));
    19.         System.out.println(isValidQQ("1234567890"));
    20.  
    21.         System.out.println("-----");
    22.         System.out.println(isValidQQ("00001"));
    23.  
    24.         System.out.println("-----");
    25.  
    26.         System.out.println(isValidTel("010-123455"));
    27.         System.out.println(isValidTel("0123-12345678"));
    28.  
    29.         System.out.println("-----");
    30.         System.out.println(isValidTel("123-12345678"));
    31.         System.out.println(isValidTel("010-023456"));
    32.  
    33.  
    34.     }
    35. }
    36.  
    37. true
    38. true
    39. true
    40. -----
    41. false
    42. -----
    43. true
    44. true
    45. -----
    46. false
    47. false
    1. # python版本：
    2. import re
    3.  
    4. def isValidTel(str):
    5. 	# 国内区号以0开头
    6. 	# 匹配成功 re.match 方法返回一个匹配的对象，否则返回 None
    7. 	return re.match(r'^0\d{2,3}\-[1-9]\d{5,7}$', str)
    8.  
    9. def isValidQQ(str):
    10.  	# QQ号码
    11. 	return re.match(r'^[1-9]\d{4,9}$', str) 	
    12.  
    13. print(isValidQQ("10000"));
    14. print(isValidQQ("99999"));
    15. print(isValidQQ("1234567890"));
    16.  
    17. print("-----");
    18. print(isValidQQ("00001"));
    19.  
    20. print("-----");
    21.  
    22. print(isValidTel("010-123455"));
    23. print(isValidTel("0123-12345678"));
    24.  
    25. print("-----");
    26. print(isValidTel("123-12345678"));
    27. print(isValidTel("010-023456"));
    28.  
    29.  
    30. object; span=(0, 5), match='10000'>
    31. object; span=(0, 5), match='99999'>
    32. object; span=(0, 10), match='1234567890'>
    33. -----
    34. None
    35. -----
    36. object; span=(0, 10), match='010-123455'>
    37. object; span=(0, 13), match='0123-12345678'>
    38. -----
    39. None
    40. None
    • 示例：判断用户输入的年份是否是19xx年：
      • 规则：1 9 0-9 0-9
      • 正则：19\d\d
      • java字符串："19\\d\\d"
      • java代码： 
        1. # java版本：
        2. public class test {
        3.  
        4.     public static boolean is19xx(String s) {
        5.         if (s == null){
        6.             return false;
        7.         }
        8.         return s.matches("19\\d\\d");
        9.     }
        10.  
        11.     public static void main(String[] args) {
        12.         System.out.println(is19xx("1900"));
        13.         System.out.println(is19xx("1911"));
        14.         System.out.println(is19xx("1999"));
        15.         System.out.println("------");
        16.         System.out.println(is19xx(null));
        17.         System.out.println(is19xx(""));
        18.         System.out.println(is19xx("19"));
        19.         System.out.println(is19xx("190A"));
        20.         System.out.println(is19xx("19001"));
        21.         System.out.println(is19xx("1900s"));
        22.         System.out.println(is19xx("2900"));
        23.         System.out.println(is19xx("A900"));
        24.     }
        25. }
      • 运行结束： 
        1. true
        2. true
        3. true
        4. ------
        5. false
        6. false
        7. false
        8. false
        9. false
        10. false
        11. false
        12. false
        1. # python版本：
        2. import re
        3.  
        4. def is19xx(str):
        5. 	# 国内区号以0开头
        6. 	# 匹配成功 re.match 方法返回一个匹配的对象，否则返回 None
        7. 	return re.match(r'19\d\d', str)
        8.  
        9. print(is19xx("1900"));
        10. print(is19xx("1911"));
        11. print(is19xx("1999"));
        12. print("------");
        13. print(is19xx(""));
        14. print(is19xx("19"));
        15. print(is19xx("190A"));
        16. print(is19xx("19001"));
        17. print(is19xx("1900s"));
        18. print(is19xx("2900"));
        19. print(is19xx("A900"));
        20.  
        21. print("------");
        22. pattern2 = re.compile(r'^0\d{2,3}\-\d{6,8}$')
        23. match2 = pattern2.match("0123-12345678")
        24. if match2:
        25.     print(match2.group()) # "0123-12345678"
        26.     print(match2.start()) # "0"
        27.     print(match2.end()) # "13"
        28.  
        29.  
        30. object; span=(0, 4), match='1900'>
        31. object; span=(0, 4), match='1911'>
        32. object; span=(0, 4), match='1999'>
        33. ------
        34. None
        35. None
        36. None
        37. object; span=(0, 4), match='1900'>
        38. object; span=(0, 4), match='1900'>
        39. None
        40. None
        41. ------
        42. 0123-12345678
        43. 0
        44. 13

    1. import java.util.regex.Matcher;
    2. import java.util.regex.Pattern;
    3.  
    4. // java版本：
    5. public class test {
    6.     public static void main(String[] args) {
    7.  
    8.         String regex = "^\\d{3,4}\\-\\d{6,8}$";
    9.         System.out.println("010-12345678".matches(regex));
    10.  
    11.         System.out.println("------");
    12.         // 反复使用一个正则表达式字符串进行快速匹配效率较低
    13.         // （因为字符串首先得编译成Pattern对象）
    14.         // 反复使用，可以移动到方法外
    15.         Pattern pattern = Pattern.compile("^\\d{3,4}\\-\\d{6,8}$");
    16.         Matcher matcher = pattern.matcher("010-12345678");
    17.         System.out.println(matcher.matches());
    18.         System.out.println(pattern.matcher("021-123456").matches());
    19.         System.out.println(pattern.matcher("021#123456").matches());
    20.  
    21.         System.out.println("------");
    22.         //使用Matcher.group(n)可以快速提取子串
    23.         Pattern pattern1 = Pattern.compile("^(\\d{3,4})\\-(\\d{6,8})$");
    24.         Matcher matcher1 = pattern1.matcher("010-12345678");
    25.         if (matcher1.matches()){
    26.             System.out.println(matcher1.group(0)); // "010-12345678",0表示匹配的整个字符串
    27.             System.out.println(matcher1.group(1)); // "010", 1表示匹配的第1个子串
    28.             System.out.println(matcher1.group(2)); // "12345678", 2表示匹配的第2个子串
    29.         }
    30.     }
    31. }
    32.  
    33. true
    34. ------
    35. true
    36. true
    37. false
    38. ------
    39. 010-12345678
    40. 010
    41. 12345678
    1. # python版本：
    2. import re
    3.  
    4. # re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match() 就返回 none
    5. regex = "^\d{3,4}\-\d{6,8}$"
    6. print(re.match(regex, "010-12345678"))
    7.  
    8. print("----")
    9. print(re.match(regex, "021-123456"))
    10. print(re.match(regex, "021#123456"))
    11.  
    12. print("----")
    13. # re.compile感觉是完全匹配整个字符串
    14. pattern = re.compile(r'^\d{3,4}\-\d{6,8}$')
    15. print(pattern.match('021-123456A'))
    16. print(pattern.match("021-123456"))
    17.  
    18. print("----")
    19. matchObj = re.match(r'^(\d{3,4})\-(\d{6,8})$',"010-12345678")
    20. if matchObj:
    21.    print("matchObj.group() : ", matchObj.group())
    22.    print("matchObj.group(1) : ", matchObj.group(1))
    23.    print("matchObj.group(2) : ", matchObj.group(2))
    24. else:
    25.    print("No match!!")
    26.  
    27.  
    28. object; span=(0, 12), match='010-12345678'>
    29. ----
    30. object; span=(0, 10), match='021-123456'>
    31. None
    32. ----
    33. None
    34. object; span=(0, 10), match='021-123456'>
    35. ----
    36. matchObj.group() :  010-12345678
    37. matchObj.group(1) :  010
    38. matchObj.group(2) :  12345678

    1. import java.util.regex.Matcher;
    2. import java.util.regex.Pattern;
    3.  
    4. // java版本：
    5. public class test {
    6.     public static void main(String[] args) {
    7.  
    8. //        "^(\d+)(0*)$"
    9. //        正则表达式默认是使用贪婪匹配：尽可能多的向后匹配
    10.         Pattern pattern1 = Pattern.compile("^(\\d+)(0*)$");
    11.         Matcher matcher1 = pattern1.matcher("12300");
    12.         if (matcher1.matches()){
    13.             System.out.println(matcher1.group(1)); // "12300"
    14.             System.out.println(matcher1.group(2)); // ""
    15.         }
    16.  
    17.         // "^(\d+？)(0*)$"——实现非贪婪匹配
    18.         Pattern pattern2 = Pattern.compile("^(\\d+?)(0*)$");
    19.         Matcher matcher2 = pattern2.matcher("12300");
    20.         if (matcher2.matches()){
    21.             System.out.println(matcher2.group(1)); // "123"
    22.             System.out.println(matcher2.group(2)); // "00"
    23.         }
    24.  
    25.         // 区分?是0个或者1个还是非贪婪匹配
    26.         // "^(\\d??)(0*)$"：第一个?是0个或者1个，第2个?是非贪婪匹配
    27.         Pattern pattern3 = Pattern.compile("^(\\d??)(0*)$");
    28.         Matcher matcher3 = pattern3.matcher("12300");
    29.         if (matcher3.matches()){
    30.             System.out.println(matcher3.group(1)); // ""
    31.             System.out.println(matcher3.group(2)); // "12300"
    32.         }
    33.     }
    34. }

     

    1. # python版本：
    2. import re
    3.  
    4. pattern1 = re.compile(r'^(\d+)(0*)$')
    5. match1 = pattern1.match("12300")
    6. if match1:
    7.     print(match1.group(1)) # "12300"
    8.     print(match1.group(2)) # ""
    9.  
    10. # "^(\d+？)(0*)$"——实现非贪婪匹配
    11. pattern2 = re.compile(r'^(\d+?)(0*)$')
    12. match2 = pattern2.match("12300")
    13. if match2:
    14.     print(match2.group(1)) # "123"
    15.     print(match2.group(2)) # "00"
    16.  
    17.  
    18. 12300
    19.  
    20. 123
    21. 00
    1. import java.util.Arrays;
    2. import java.util.regex.Matcher;
    3. import java.util.regex.Pattern;
    4.  
    5. // java版本：
    6. public class test {
    7.  
    8.     public static void main(String[] args) {
    9.  
    10.         // 使用正则表达式分割字符串：
    11.         // String[] String.split(String regex)
    12.         System.out.println(Arrays.toString("a b c".split("\\s"))); // ["a", "b", "c"]
    13.         System.out.println(Arrays.toString("a b  c".split("\\s"))); // ["a", "b", "", "c"]
    14.         System.out.println(Arrays.toString("a b  c".split("\\s+"))); // ["a", "b", "c"]
    15.         System.out.println(Arrays.toString("a, b ;;  c".split("[\\,\\;\\s]+"))); // ["a", "b", "c"]
    16.  
    17.         System.out.println("----");
    18.         // 使用正则表达式搜索字符串：
    19.         // Matcher.find()
    20.         // Pattern.CASE_INSENSITIVE：忽略大小写
    21.         String s = "The quick brown fox jumps over the lazy dug.";
    22. //        Pattern p = Pattern.compile("the", Pattern.CASE_INSENSITIVE);
    23. //        Pattern p = Pattern.compile("\\w+", Pattern.CASE_INSENSITIVE); // 提取出每个单词
    24.         Pattern p = Pattern.compile("\\w*o\\w*", Pattern.CASE_INSENSITIVE); // 提取出单词中带有o的单词
    25.         Matcher m = p.matcher(s);
    26.         while (m.find()){
    27.             String sub = s.substring(m.start(), m. end());
    28.             System.out.println(sub+", start="+m.start()+", end="+m.end());
    29.         }
    30.  
    31.         System.out.println("-----");
    32.         // 使用正则表达式替换字符串：
    33.         // String.replaceAl()
    34.         String s1 = "The    quick brown   fox jumps   over the lazy dug.";
    35.         System.out.println(s1.replaceAll("\\s+"," "));
    36.         // 这里$1会捕获前面的分组"(\\w+)"
    37.         // The quick brown fox jumps over the lazy dug.
    38.         System.out.println(s1.replaceAll("\\s+"," ").replaceAll("(\\w+)", "$1"));
    39.     }
    40. }
    41.  
    42.  
    43. [a, b, c]
    44. [a, b, , c]
    45. [a, b, c]
    46. [a, b, c]
    47. ----
    48. brown, start=10, end=15
    49. fox, start=16, end=19
    50. over, start=26, end=30
    51. -----
    52. The quick brown fox jumps over the lazy dug.
    53. The quick brown fox jumps over the lazy dug.
    1. # python版本：
    2. import re
    3.  
    4. # 使用正则表达式分割字符串：
    5. print(re.split(r'\s',("a b c"))) # ["a", "b", "c"]
    6. print(re.split(r'\s',("a b  c"))) # ["a", "b", "", "c"]
    7. print(re.split(r'\s+',("a b  c"))) # ["a", "b", "c"]
    8. print(re.split(r'[\,\;\s]+',("a, b   c"))) # ["a", "b", "c"]
    9.  
    10. print("----")
    11. # 使用正则表达式搜索字符串：
    12. s = "The quick brown fox jumps over the lazy dug."
    13. p = re.compile(r'\w*o\w*', re.I) # 提取出单词中带有o的单词
    14. m = p.findall(s) #['brown', 'fox', 'over']
    15. print(m)
    16.  
    17. it = re.finditer(r'\w*o\w*',s, re.I) 
    18. for match in it: 
    19.     print(match.group())
    20.  
    21. print("-----")
    22. # 使用正则表达式替换字符串：
    23. s1 = "The    quick brown   fox jumps   over the lazy dug."
    24. s2 = re.sub(r'\s+',' ',s1)
    25. print(s2)
    26. # 这里$1会捕获前面的分组"(\\w+)"
    27. # The quick brown fox jumps over the lazy dug.
    28. print(re.sub(r'(\w+)','\g<1>',s2))
    29.  
    30.  
    31. ['a', 'b', 'c']
    32. ['a', 'b', '', 'c']
    33. ['a', 'b', 'c']
    34. ['a', 'b', 'c']
    35. ----
    36. ['brown', 'fox', 'over']
    37. brown
    38. fox
    39. over
    40. -----
    41. The quick brown fox jumps over the lazy dug.
    42. The quick brown fox jumps over the lazy dug.

     

  • 相关阅读:
    C#下WinForm多语种切换
    generate by chatgpt:应用上线前的checkList（部分是我自己的回答）
    数据库知识点整合
    leetcode做题笔记143. 重排链表
    linux核心知识梳理
    “2024国际数字能源展”推动绿色低碳发展，助力实现“双碳”目标
    前缀树的设计与实现
    聚类分析字符串数组
    基于springboot＋vue的戒毒所人员管理系统毕业设计源码251514
    Vue--keep-alive--使用/实例
  • 原文地址：https://blog.csdn.net/sb_jb/article/details/128081285