A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

感觉对你有用就给个鼓励吧~~
  1. package cn.fuxi._03regex;
  2. /**
  3. * 正则表达式.
  4. *
  5. * 正则表达式用于操作字符串数据.
  6. * 通过一些特定的符号来体现的.
  7. * 所以我们为了掌握正确的表达式,必须要学习一些符号.
  8. * 虽然简化了,但是阅读性差.
  9. */

  10. public class _01RegexDemo {
  11.         public static void main(String[] args) {
  12.                 String qq = "1234567890";
  13.                 checkQQ(qq);
  14.                 System.out.println("-----------------");
  15.                 //正则表达式.
  16.                 String regex = "[1-9][0-9]{4,14}";
  17.                 boolean b = qq.matches(regex);
  18.                 System.out.println(qq+":"+b);
  19.         }
  20.         /*
  21.          * 需求:定义一个功能对qq好进行校验.
  22.          * 需求:长度5~15,只能死数字,0不能开头.
  23.          */
  24.         public static void checkQQ(String qq){
  25.                 int len = qq.length();
  26.                 if(len>=5 && len<=15){
  27.                         if(!qq.startsWith("0")){
  28.                                 try{
  29.                                         long l = Long.parseLong(qq);
  30.                                         System.out.println(l+":正确");
  31.                                 }catch(NumberFormatException e){
  32.                                         System.out.println(qq+":含有非法字符");
  33.                                 }
  34.                         }else{
  35.                                 System.out.println(qq+":不能以0开头");
  36.                         }
  37.                 }else {
  38.                         System.out.println(qq+":长度错误");
  39.                 }
  40.         }
  41. }
复制代码
输出结果:
1234567890:正确
-----------------
1234567890:true
  1. package cn.fuxi._03regex;
  2. /**
  3. * 正则表达式常用构造摘要
  4. *
  5. * 字符类
  6. * [abc]a,b或c(简单类)
  7. * [^abc]任何字符,除了a,b,c
  8. * [a-zA-Z]a到z或A到Z,两头的字母包括在内(范围)
  9. *
  10. * 预定义字符类.
  11. * .任何字符(与行结束符可能匹配也可能不匹配)
  12. * \d数字:[0-9]
  13. * \D非数字:[^0-9]
  14. * \s空白字符:[\t\n\x0b\f\r]
  15. * \S非空白字符:[^\s]
  16. * \w单词字符:[a-zA-Z_0-9]
  17. * \W非单词字符:[^\w]
  18. *
  19. * Greedy数量词
  20. * X? X,一次或一次也没有
  21. * X* X,零次或多次
  22. * X+ X,一次或多次
  23. * X{n}        X,恰好n次
  24. * X{n,} X,至少n次
  25. * X{n,m} X,至少n此,但是不超过m次
  26. *
  27. * 边界匹配器
  28. * ^行的开头
  29. * &行的结尾
  30. * \b单词边界
  31. * \B非单词边界
  32. * \A输入的开头
  33. * \G上一个匹配的结尾
  34. * \Z输入的结尾,仅用于最后的结束符(如果有的话)
  35. * \z输入的结尾
  36. */

  37. public class _02RegexDemo02 {
  38.         public static void main(String[] args) {
  39.                 String str = "aoob";
  40.                 String reg = "ao?b";//o出现了0次或一次?否,两次
  41.                 boolean b = str.matches(reg);
  42.                 System.out.println(str+":"+b);
  43.                
  44.                 reg = "ao+b";
  45.                 b = str.matches(reg);//o出现了一次以上?是,两次
  46.                 System.out.println(str+":"+b);

  47.                 str="ab";
  48.                 reg = "ao+b";//o出现了一次以上?否,0次
  49.                 b=str.matches(reg);
  50.                 System.out.println(str+":"+b);
  51.                
  52.                 str = "ab";
  53.                 reg = "ao*b";//o出现了0次或多次?是,0次
  54.                 b = str.matches(reg);
  55.                 System.out.println(str+":"+b);
  56.                
  57.                 str="aoooooooooob";
  58.                 reg = "ao{4,}b";//o出现了4次以上?是,10次
  59.                 b = str.matches(reg);
  60.                 System.out.println(str+":"+b);

  61.                 reg = "ao{4,6}b";//o出现了4次到6次?否,10次
  62.                 b = str.matches(reg);
  63.                 System.out.println(str+":"+b);               
  64.         }
  65. }
复制代码
输出结果:
aoob:false
aoob:true
ab:false
ab:true
aoooooooooob:true
aoooooooooob:false
  1. package cn.fuxi._03regex;

  2. import java.util.regex.Matcher;
  3. import java.util.regex.Pattern;

  4. /**
  5. * 正则表达式常见功能:匹配,切割,替换,获取
  6. */

  7. public class _03RegexDemo03 {
  8.         public static void main(String[] args) {
  9.                 functionDemo_01();
  10.                 System.out.println("------------------");
  11.                 functionDemo_02();
  12.                 System.out.println("------------------");
  13.                 functionDemo_03();
  14.                 System.out.println("------------------");
  15.                 functionDemo_04();
  16.                 System.out.println("------------------");
  17.                 functionDemo_05();
  18.                 System.out.println("------------------");
  19.                 functionDemo_06();
  20.                 System.out.println("------------------");
  21.                 functionDemo_07();       
  22.         }
  23.         /*
  24.          * 正则表达式对字符串的常见操作
  25.          * 1.匹配
  26.          *                 其实使用的就是String类中的matches方法.
  27.          * 2.切割
  28.          *                 其实使用的就是String类中的split方法.
  29.          * 3.替换
  30.          *
  31.          * 4.获取
  32.          */
  33.         //匹配
  34.         public static void functionDemo_01(){
  35.                 //匹配手机号码是否正确
  36.                 String tel = "15088888088";
  37.                 String reg = "1[3578]\\d{9}";//"\\"表示一个\
  38.                 boolean b = tel.matches(reg);
  39.                 System.out.println(tel+":"+b);
  40.                
  41.         }
  42.         //切割
  43.         public static void functionDemo_02(){
  44.                 String str = "zhangsan    xiaoqiang    wangwu   ";
  45.                 String[] names = str.split(" +");
  46.                 for(String name:names){
  47.                         System.out.println(name);
  48.                 }
  49.         }
  50.         public static void functionDemo_03(){
  51.                 String str = "hangmeimei.wentianxiang.xiaoming";
  52.                 String[] names = str.split("\\.");
  53.                 for(String name:names){
  54.                         System.out.println(name);
  55.                 }
  56.         }
  57.         /*
  58.          *在表达式((A)(B(C)))中,存在四个这样的组:
  59.          *1        ((A)(B(C)))
  60.          *2        \A
  61.          *3        (B(C))
  62.          *4        (C)
  63.          *组零始终代表整个表达式.
  64.          */
  65.         public static void functionDemo_04(){
  66.                 String str = "zhangsantttxiaoqingmmmmmmzhaoliu";
  67.                 //(.)表示一组.\\1+表示与第一组相同的出现1次以上
  68.                 String[] names = str.split("(.)\\1+");
  69.                 for(String name:names){
  70.                         System.out.println(name);
  71.                 }
  72.         }
  73.         //演示替换
  74.         public static void functionDemo_05(){
  75.                 String str = "zhangsantttxiaoqingmmmmmmzhaoliu";
  76.                 //$表示抢一个参数的第一组
  77.                 str = str.replaceAll("(.)\\1+", "$1");
  78.                 System.out.println(str);
  79.         }
  80.         public static void functionDemo_06(){
  81.                 String str="15800001111";
  82.                 str = str.replaceAll("(\\d{3})(\\d{4})(\\d{4})", "$1****$2");
  83.                 System.out.println(str);
  84.         }
  85.         /*
  86.          * 演示获取
  87.          * 将正则规则经行对象的封装.
  88.          * Pattern p = Pattern.compile("a*b");
  89.          * 通过正则对象的matches方法字符串相关联.获取要对字符串操作的匹配器对象Matcher.
  90.          * boolean b = m.matches();
  91.          */
  92.         public static void functionDemo_07(){
  93.                 String str = "da jia hao,ming tian bu shang ke";
  94.                 //\\b表示单词边界
  95.                 String regex = "\\b[a-z]{3,}\\b";//由三个小写字母构成的
  96.                 //1.将正则封装成对象
  97.                 Pattern p = Pattern.compile(regex);
  98.                 //2.通过正则对象获取匹配器对象
  99.                 Matcher m = p.matcher(str);
  100.                 //使用Matcher对象的方法对字符串经行操作
  101.                 //既然要获取三个字母组成的单词.
  102.                 //查找:find();
  103.                 while(m.find()){
  104.                         System.out.println(m.group());//获取匹配的子序列
  105.                         System.out.println(m.start()+":"+m.end());
  106.                 }
  107.         }
  108. }
  109. /*
  110. * P.S.
  111. *                 Pattern类为正则表达式的编译表示形式.指定为字符串的正则表达式必须首先被编译为此类的实例.
  112. * 然后,可将得到的模式用于创建Matcher对象,依照正则表达式,该对象可以与任意字符序列匹配.执行匹配
  113. * 所涉及的所有状态都驻留在匹配器中,所以多个匹配器可以共享同一模式.
  114. */
复制代码
输出结果:
15088888088:true
------------------
zhangsan
xiaoqiang
wangwu
------------------
hangmeimei
wentianxiang
xiaoming
------------------
zhangsan
xiaoqing
zhaoliu
------------------
zhangsantxiaoqingmzhaoliu
------------------
158****0000
------------------
jia
3:6
hao
7:10
ming
11:15
tian
16:20
shang
24:29

  1. package cn.fuxi._03regex;

  2. import java.util.TreeSet;

  3. /*
  4. * 1.治疗口吃:我我...我我..我我我哦我..要要要....要要要要..要要..学学学学学...学学学学编编编....编...编...编编.程...程..程程..程程程
  5. * 2.对ip地址排序
  6. * 3.对邮件地址校验
  7. */
  8. public class _04RegexTest01 {
  9.         public static void main(String[] args) {
  10.                 test01();//治疗口吃
  11.                 System.out.println("------------------");
  12.                 test02();//对ip地址排序
  13.                 System.out.println("------------------");
  14.                 test03();//对邮箱地址校验
  15.         }
  16.         public static void test01(){
  17.                 String str = "我我...我我..我我我我..要要要....要要要要..要要..学学学学学...学学学学编编编....编...编...编编.程...程..程程..程程程";
  18.                 //1.将字符串中的点去掉,用替换
  19.                 str = str.replaceAll("\\.+", "");
  20.                 //2.替换叠词
  21.                 str = str.replaceAll("(.)\\1+", "$1");
  22.                 System.out.println(str);
  23.         }
  24.         /*
  25.          * ip地址排序.
  26.          * 192.168.10.34 127.0.0.1 3.3.3.3 105.70.11.55
  27.          */
  28.         public static void test02(){
  29.                 String ip = "192.168.10.34 127.0.0.1 3.3.3.3 105.70.11.55";
  30.                 System.out.println(ip);
  31.                 //1.为了让ip可以按照字符串顺次比较,只要让ip的每一段的位数相同.
  32.                 //所以,补零,按照每一位所需最多0进行补充,每一段都加两个0.
  33.                
  34.                 ip = ip.replaceAll("(\\d+)", "00$1");
  35.                 //然后每一段保留数字后三位
  36.                 ip = ip.replaceAll("0*(\\d{3})", "$1");
  37.                 //2.将ip地址切割出来
  38.                 String[] ips = ip.split(" +");
  39.                 //3.用TreeSet装入,并自然排序
  40.                 TreeSet<String> ts = new TreeSet<String>();
  41.                 for(String ip1 : ips){
  42.                         ts.add(ip1);
  43.                 }
  44.                 for(String ip1:ts){
  45.                         System.out.println(ip1.replaceAll("0*(\\d+)", "$1"));
  46.                 }
  47.         }
  48.         //对邮箱地址校验
  49.         public static void test03(){
  50.                 String mail = "abc@sina.com";
  51.                 String regex = "[a-zA-Z0-9_]+@[a-zA-Z0-9]+([\\.[a-zA-Z]{1,3}])+";
  52.                 boolean b = mail.matches(regex);
  53.                 System.out.println(mail+":"+b);
  54.         }
  55. }
复制代码
输出结果:
我要学编程
------------------
192.168.10.34 127.0.0.1 3.3.3.3 105.70.11.55
3.3.3.3
105.70.11.55
127.0.0.1
192.168.10.34
------------------
abc@sina.com:true


感觉对你有用就给个鼓励吧~~


3 个回复

倒序浏览
辛苦编辑的别沉啦哈哈~
回复 使用道具 举报
给你顶一个
回复 使用道具 举报
非常好
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马