Java基础—正则表达式

最新推荐文章于 2022-05-27 23:24:49 发布

xiao芝麻

最新推荐文章于 2022-05-27 23:24:49 发布

阅读量429

点赞数

分类专栏： Java基础文章标签：正则表达式

本文链接：https://blog.youkuaiyun.com/u013704970/article/details/46453293

版权

Java基础专栏收录该内容

14 篇文章

订阅专栏

一、正则表达式概述
正则表达式是一些符号一定规则的表达式，专门用于字符串操作，它是用一些特定的符号表示一些字符串操作代码，简化了字符串操作代码，但阅读性较若。
二、一些简单的正则表达式
1、字符类：
[abc] 该位取值只能为abc中的一个；
[^abc] 该位取值为除了abc以外的任意字符；
[a-zA-Z]   该位的取值为任意的大小字母；
[a-d[m-p]]   该位的取值要么a-d，要么m-p；
[a-g&&[e-k]] 该位的取值为efghijk中的任一字符；
2、预定义字符类：
. 任一字符
\d 数字[0-9];
\D 非数字[^0-9];
\s 空白字符：[ \t\n\x0B\f\r]
\S 非空白字符[^\s];
\w [a-zA-Z0-9_];
\W [^\w]
3、Greedy数量词：
X? 出现一次或一次都不出现；
X* 出现零次或多次；
X+   出现一次或多次；
X{n} 恰好出现n次；
X{n,} 至少出现n次；
X{n,m} 至少出现n次，最多出现m次。
三、基本的操作
1、匹配：用于判断字符串是否合法(合法自己定义的)。代码如下：

/*
1、验证手机号是否合法，
   移动：134、135、136、137、138、139、150、151、157(TD)、158、159、187、188

　　联通：130、131、132、152、155、156、185、186

　　电信：133、153、180、189、（1349卫通）
 分析：
      有上面的数字可知，手机号位数为11位，第一位只能为1，第二位只能为：3/5/8，
       其他的9位为0-9。

2、验证邮箱号是否合法，
   邮箱号规则：数字或字母@数字或字母.字母/数字或字母@数字或字母.字母.字母。
*/
class MatchesTest 
{
    //将打印语句封装
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args) 
    {
        checkTel("15559889951");
        checkMail("1396560124@qq.com");
    }
    //校验手机号是否符合规定
    public static void checkTel(String tel)
    {
        //定义规则
        String regex = "[1][358]\\d{9}";
        //校验
        boolean flag = tel.matches(regex);
        //根据校验结果输出相应的语句
        if(!flag)
            sop("手机号错误，请重新输入！");
        else
            sop("手机号码正确！");
    }
    //校验邮箱号是否符合规定
    public static void checkMail(String mail)
    {
        //定义规则
        String regex = "\\w+@[a-zA-Z0-9]+(\\.[a-zA-Z]+){1,3}";
        //调用maches方法校验
        boolean flag = mail.matches(regex);
        //根据校验结果输出相应的语句
        if(flag)
            sop("邮箱号是正确的的");
        else
            sop("邮箱号不符合规范，请重新输入！");
    }
}

2、替换：将一个字符串转换成另一个字符串，将符合规则的字符串替换成指定的字符串。代码如下：

/*
  "我我...我我...我要..要要...要要...学学学...学学...编编编...编程..程.程程...程...程"
  将该字符串转换成："我要学编程"

  分析：
       将一个字符串转换成另一个字符串，应该用替换；

  步骤：
       1、将"."去掉；
       2、将叠词换成一个字。

  其他说明：
           为了能使规则的结果可以被重用，可以将规则封装，用"()"完成，组的出现都有编号，
           从1开始，可以通过\1的方式获取元素。一个规则中有几组：看"("，规则的编号从左
           往右数："("。在规则内获取：\1，在规则外获取：$1.
*/
class ReplaceAllTest
{
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args) 
    {
        String str = "我我...我我...我要..要要...要要...学学学...学学...编编编...编程..程.程程...程...程";
        sop("原字符串："+str);
        //去除"."
        str = str.replace(".","");
        sop("去除“.”后的字符串："+str);
        //将叠词转换为一个字
        str = str.replaceAll("(.)\\1+","$1");
        //在规则内获取组元素：\n
        //在规则外获取族元素：$1
        sop("最终的字符串："+str);
    }
}

3、切割：将字符串按照一定的规则切割成多条字符串，符合规则的丢掉。代码如下：

/*
1、按.切割；
2、按\切割；
3、按叠词切割。
*/
import java.util.*;
class SplitTest
{
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args) 
    {
        sop("按.切割字符串-------");
        split1("zhangsan.lisi.jiandan.xiaxia.jingjing.xiaoxue.xiaoxiao");
        sop("按\\切割字符串-------");
        split2("C:\\Users\\cecy\\Desktop\\javastudy\\javacode\\day25\\SplitTest.java");
        sop("按叠词切割字符串-------");
        split3("hahaccccccheiheieeheheiiihiahiabbbbbbbxixixxxxhiehie");
    }
    //按.切割
    public static void split1(String str)
    {
        //定义规则
        String regex = "\\.";
        //切割字符串
        String[] strs = str.split(regex);
        //定义一个集合，用于装字符串对象
        ArrayList<String> al = new ArrayList<String>();
        //用Arrays对数组进行排序
        //Arrays.sort(strs);
        //将字符串取出并存入集合
        for(String s : strs)
        {
            al.add(s);
            //sop(s);
        }
        //用Collections的sort方法对List集合进行排序
        Collections.sort(al);
        //用高级for将集合输出
        for(String name : al)
        {
            sop(name);
        }
    }
    //按\切割
    public static void split2(String str)
    {
        //定义规则
        String regex = "\\\\";
        //切割字符串
        String[] strs = str.split(regex);
        //将切割结果打印
        for(String path : strs)
        {
            sop(path);
        }
    }
    //按叠词切割
    public static void split3(String str)
    {
        //定义规则
        String regex = "(.)\\1+";
        //切割字符串
        String[] strs = str.split(regex);
        //将切割结果打印
        for(String s : strs)
        {
            sop(s);
        }
    }
}

4、获取：将符合规则的字符串取出。

/*
 "ming tian jiu yao fang jia le,tong xue men!"
 取出上述只有三个字母组成的单词。
*/
import java.util.regex.*;
class MatcherTest 
{
    public static void main(String[] args) 
    {
        String str = "ming tian jiu yao fang jia le,tong xue men!";
        //定义规则
        String regex = "\\b[a-z]{3}\\b";
        //将规则封装成Pattern对象
        Pattern p = Pattern.compile(regex);
        //将规则对象及要操作的字符串相关联
        Matcher m = p.matcher(str);
        //查找符合规则的字符串并将其取出
        while(m.find())
        {
            System.out.println(m.group());
            System.out.println(m.start()+"---"+m.end());
        }
    }
}

5、练习——ip地址排序

/*
    192.68.1.254 102.49.23.013 10.10.10.10 2.2.2.2 8.109.90.30
    将ip地址进行地址段顺序的排序。

    分析：简单的排序方法有三种：1、Arrays.sort();2、存储到TreeSet中（没有重复元素）；
                                3、存储到List集合中，再用Collections中的sort()方法。
    排序之前，ip地址的每段的位数要一致，不然排序出来的不符合实际。

    步骤：
         1、将ip地址段都转换成3位数；
         2、再将字符串切割；
         3、将每个ip地址存入到TreeSet中；
         4、将ip地址打印，查看是否排序正确。

    规则说明：
            ([0-9]+)：0-9的数出现一次或出现多次，并将该数封装进组，以便调用；
            0*([0-9]{3})：0出现零次或多次，0-9出现三次，并将0-9出现三次的数字封装进组，以便再次引用。
            0*([0-9]{1,3})：0出现零次或多次，0-9至少出现一次，最多出现3次，并将其封装进组，以便再次引用。

   其他说明：用到的类：TreeSet、Iterator、String
             用到的方法：TreeSet(iterator、add)
                         Iterator(hasNext、next)
                         String(replaceAll、split)
*/
import java.util.*;
class IpTest
{
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args) 
    {
        String ip = "192.68.1.254 102.49.23.013 10.10.10.10 2.2.2.2 8.109.90.30";
        sop("原ip字符串："+ip);
        //在ip地址每段前加00
        ip = ip.replaceAll("([0-9]+)","00$1");
        sop("在每段ip地址前加00后："+ip);
        //每段ip地址保留后三位
        ip = ip.replaceAll("0*([0-9]{3})","$1");
        sop("保留每个ip段的后三位："+ip);
        //切割字符串，获取ip
        String[] ips = ip.split(" +");
        //定义一个集合存放ip地址并对其进行排序
        TreeSet<String> ts = new TreeSet<String>();
        for(String i : ips)
        {
            ts.add(i);
        }
        //将ip地址取出
        Iterator<String> it = ts.iterator();
        while(it.hasNext())
        {
            sop(it.next().replaceAll("0*([0-9]{1,3})","$1"));
        }
    }
}

6、练习——网页爬虫

/*
 网页爬虫：获取邮箱地址。
 分析：
      获取网页文件中的邮箱号码，先获取网页文件，再按照规则获取邮箱。
 步骤：
      1、建立读取流，并与文件相关联；
      2、定义规则；
      3、将规则封装成Pattern对象；
      4、将规则对象和读取的网页文件相关联；
      5、查找符合规则的字符串并将其取出。
*/
import java.io.*;
import java.util.regex.*;
class WebCrawlerTest  
{
    public static void main(String[] args) 
    {
        BufferedReader bufr = null;
        try
        {
            //读取网页文件
            bufr  = new BufferedReader(new FileReader("C:\\Users\\cecy\\Desktop\\javastudy\\boke\\mail.txt"));
            String line = null;
            while((line = bufr.readLine()) != null)
            {
                //定义规则
                String regex = "\\w+@[a-zA-Z0-9]+(\\.[a-zA-Z]+){1,3}";
                //将规则封装成对象
                Pattern p = Pattern.compile(regex);
                //将规则对象和要操作的字符串相关联
                Matcher m = p.matcher(line);
                //查找符合规则的字符串并取出
                while(m.find())
                {
                    System.out.println(m.group());
                }
            }
        }
        catch (Exception e)
        {
            throw new RuntimeException("文件读取失败");
        }

    }
}