正则表达式快速入门

LSP522

已于 2023-04-24 12:05:29 修改

阅读量161

点赞数 1

分类专栏：技术自学笔记博客 Java速成文章标签：正则表达式

于 2023-04-24 10:27:49 首次发布

本文链接：https://blog.csdn.net/LSP522/article/details/130337139

版权

技术自学笔记博客同时被 2 个专栏收录

23 篇文章 0 订阅

订阅专栏

Java速成

9 篇文章 0 订阅

订阅专栏

title: 正则表达式
author: “\U0001F336辣椒炒饭”
tags:

正则表达式
categories: []
date: 2023-04-12 21:19:00

快速入门

正则表达式的便利

package com.jun.regexp;

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

/*
 * @Author: jun
 * @Date:2023/4/12 21:15
 * @概述：正则表达式的便利
 */
public class Regexp_ {
    public static void main(String[] args) {
        //假定，编写了爬虫，从百度页面获取了如下文本
        String content = "项目经历\n" +
                "花朵分类识别项目（使用 YOLOv5）时间范围：2022 年 1 月 - 2022 年 3 月\n" +
                "概述：在这个项目中，我使用了 YOLOv5 模型来训练一个花朵分类识别器。该模型能够接受输入的花朵图像，" +
                "并输出它所属的花卉种类。我在该项目中担任负责人，与一个团队合作完成了该项目。\n" +
                "职责和成果：\n" +
                "设计了数据集收集和清理的流程，从网络上下载了超过 4000 张不同种类的花朵图片，并进行了标注。\n" +
                "使用 PyTorch 框架实现了基于 YOLOv5 的花卉分类器，并对其进行了调优，以提高准确率和降低误差率。\n" +
                "在测试数据集上获得了 95% 的准确率，并将模型部署到 Raspberry Pi 上进行实时花朵检测。\n" +
                "撰写了项目报告和技术文档，记录了整个项目的流程、决策和结果，并展示了模型的性能和局限性。\n" +
                "技能和工具：\n" +
                "计算机视觉和深度学习算法\n" +
                "Python 编程及常用库，如 PyTorch、NumPy 和 OpenCV\n" +
                "数据集的采集和标注\n" +
                "模型调优和评估";

        //需求：提取文章中的所有英文单词
        //1.传统方法。使用遍历方式，代码量大，效率不高

        //正则表达式：
        //1.创建一个Pattern对象，模式对象，可以理解为就是一个正则表达式对象
        Pattern pattern = Pattern.compile("[a-zA-Z]+");
        //2.创建一个匹配器对象
        //理解：就是matcher匹配器按照pattern
        Matcher matcher = pattern.matcher(content);
        //3.可以开始循环匹配
        while (matcher.find()) {
            //匹配内容，文本，放到m.group(0)
            System.out.println("匹配结果："+matcher.group(0));
        }

    }
}

提取文章中所有的数字

package com.jun.regexp;

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

/*
 * @Author: jun
 * @Date:2023/4/13 8:10
 * @概述：
 */
public class Regexp_1 {
    public static void main(String[] args) {
        //需求：提取文章中所有的数字
        String content = "项目经历\n" +
                "花朵分类识别项目（使用 YOLOv5）时间范围：2022 年 1 月 - 2022 年 3 月\n" +
                "概述：在这个项目中，我使用了 YOLOv5 模型来训练一个花朵分类识别器。该模型能够接受输入的花朵图像，" +
                "并输出它所属的花卉种类。我在该项目中担任负责人，与一个团队合作完成了该项目。\n" +
                "职责和成果：\n" +
                "设计了数据集收集和清理的流程，从网络上下载了超过 4000 张不同种类的花朵图片，并进行了标注。\n" +
                "使用 PyTorch 框架实现了基于 YOLOv5 的花卉分类器，并对其进行了调优，以提高准确率和降低误差率。\n" +
                "在测试数据集上获得了 95% 的准确率，并将模型部署到 Raspberry Pi 上进行实时花朵检测。\n" +
                "撰写了项目报告和技术文档，记录了整个项目的流程、决策和结果，并展示了模型的性能和局限性。\n" +
                "技能和工具：\n" +
                "计算机视觉和深度学习算法\n" +
                "Python 编程及常用库，如 PyTorch、NumPy 和 OpenCV\n" +
                "数据集的采集和标注\n" +
                "模型调优和评估";

        //1.创建一个Pattern对象，模式对象，可以理解为就是一个正则表达式对象
        Pattern pattern = Pattern.compile("[0-9]+");
        //2.创建一个匹配器对象
        //理解：就是matcher匹配器按照pattern
        Matcher matcher = pattern.matcher(content);
        //3.可以开始循环匹配
        while (matcher.find()) {
            //匹配内容，文本，放到m.group(0)
            System.out.println("匹配结果："+matcher.group(0));
        }
    }
}

提取文章中所有的英文和数字

package com.jun.regexp;

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

/*
 * @Author: jun
 * @Date:2023/4/13 8:15
 * @概述：
 */
public class Regexp_2 {
    public static void main(String[] args) {
        //需求：提取文章中所有的英文和数字
        String content = "项目经历\n" +
                "花朵分类识别项目（使用 YOLOv5）时间范围：2022 年 1 月 - 2022 年 3 月\n" +
                "概述：在这个项目中，我使用了 YOLOv5 模型来训练一个花朵分类识别器。该模型能够接受输入的花朵图像，" +
                "并输出它所属的花卉种类。我在该项目中担任负责人，与一个团队合作完成了该项目。\n" +
                "职责和成果：\n" +
                "设计了数据集收集和清理的流程，从网络上下载了超过 4000 张不同种类的花朵图片，并进行了标注。\n" +
                "使用 PyTorch 框架实现了基于 YOLOv5 的花卉分类器，并对其进行了调优，以提高准确率和降低误差率。\n" +
                "在测试数据集上获得了 95% 的准确率，并将模型部署到 Raspberry Pi 上进行实时花朵检测。\n" +
                "撰写了项目报告和技术文档，记录了整个项目的流程、决策和结果，并展示了模型的性能和局限性。\n" +
                "技能和工具：\n" +
                "计算机视觉和深度学习算法\n" +
                "Python 编程及常用库，如 PyTorch、NumPy 和 OpenCV\n" +
                "数据集的采集和标注\n" +
                "模型调优和评估";

        //1.创建一个Pattern对象，模式对象，可以理解为就是一个正则表达式对象
        Pattern pattern = Pattern.compile("([0-9]+)|([a-zA-Z]+)");
        //2.创建一个匹配器对象
        //理解：就是matcher匹配器按照pattern
        Matcher matcher = pattern.matcher(content);
        //3.可以开始循环匹配
        while (matcher.find()) {
            //匹配内容，文本，放到m.group(0)
            System.out.println("匹配结果："+matcher.group(0));
        }
    }
}

ip提取

package com.jun.regexp;

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

/*
 * @Author: jun
 * @Date:2023/4/13 8:41
 * @概述：
 */
public class Regexp_4 {
    public static void main(String[] args) {
        String content = "私有地址\n" +
                "私有地址（Private address）属于非注册地址，专门为组织机构内部使用。\n" +
                "以下列出留用的内部私有地址\n" +
                "A类 10.0.0.0--10.255.255.255\n" +
                "B类 172.16.0.0--172.31.255.255\n" +
                "C类 192.168.0.0--192.168.255.255";

        //1.创建一个Pattern对象，模式对象，可以理解为就是一个正则表达式对象
        Pattern pattern = Pattern.compile("\\d+\\.\\d+\\.\\d+\\.\\d+");
        //2.创建一个匹配器对象
        //理解：就是matcher匹配器按照pattern
        Matcher matcher = pattern.matcher(content);
        //3.可以开始循环匹配
        int no = 0;
        while (matcher.find()) {
            //匹配内容，文本，放到m.group(0)
            System.out.println("匹配结果："+matcher.group(0));
            //添加编号
            System.out.println("匹配结果："+ (++no)+" "+matcher.group(0));
        }
    }
}

Java正则表达式的底层实现

package com.jun.regexp;

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

/*
 * @Author: jun
 * @Date:2023/4/13 9:18
 * @概述：Java正则表达式的底层实现
 */
public class RegTheory {
    public static void main(String[] args) {
        String content = "2001年是个平年。\n" +
                "但是出现了闰月，因为按照新历来说，是平年，按农历年份来说，它则是个闰年。闰四月，" +
                "也就是农历的2001年中出现了两个四月份。闰月的出现也只是为了调和农历和新历之间的差距，" +
                "使历年平均长度接近回归年。另外，它还是佛历中的第二五四五年，和黄帝纪年中的第4698年。\n" +
                "2001还是个双春年，上一年千禧年是个无春年，而到了2001则成了双春年，也就是农历出现了两个立春。" +
                "双春年又叫孤鸾年和两头春。\n" +
                "大部分为辛巳年：\n" +
                "因为新历的2001年和农历辛巳年并不完全重合，所以在新历年中有一部分还属于上一年庚辰年，下面来看看详细的划分：\n" +
                "第一种划分：按每年“立春”进行划分：\n" +
                "阳历（公历）时间：\n" +
                "2000年2月4日20时32分——2001年2月4日2时20分，农历庚辰年。\n" +
                "2001年2月4日2时20分——2002年2月4日8时8分，农历辛巳年。\n" +
                "第二种划分：按每年“初一（春节）”进行划分：\n";
        //目标：匹配所有的四个数字
        //说明
        //1. \\d 表示一个任意的数字
        String regStr = "\\d\\d\\d\\d";
        //2. 创建模式对象[即正则表达式对象]
        Pattern pattern = Pattern.compile(regStr);
        //3. 创建匹配器
        //说明：创建匹配器matcher，按照正则表达式的规则 去匹配content字符串
        Matcher matcher = pattern.matcher(content);

        //4. 匹配
        /**
         * matcher.find()   完成的任务   （考虑分组）
         * 什么是分组，比如(\d\d)(\d\d),正则表达式中有（）表示分组，第一个（）表示第一组，第二个（）表示第二组
         * 总结：
         * 1. 如果正则表达式有()即分组
         * 2. 取出匹配的字符串规则如下
         * 3. group（0）表示匹配到的字符串
         * 4. group（1）表示匹配到的字符串的第一组
         * 5. group（2）表示匹配到的字符串的第二组
         * 6. 。。。但是分组的数不能越界。
         *
         *
         * 1. 根据指定的规则，定位满足规则的子字符串(比如 2001)
         * 2. 找到后，将子字符串的开始的索引记录到matcher对象的属性 int[] groups;
         *      groups[0]=0,把该字符串的结束的索引+1的值记录到groups[1] = 4;
         *
         * 3. 同时记录oldLast的值为字符串的结束的索引+1的值即4，即下次执行find时，就从4开始匹配
         *
         * matcher.group(0)分析
         *
         *
         * public String group(int group) {
         *         if (first < 0)
         *             throw new IllegalStateException("No match found");
         *         if (group < 0 || group > groupCount())
         *             throw new IndexOutOfBoundsException("No group " + group);
         *         if ((groups[group*2] == -1) || (groups[group*2+1] == -1))
         *             return null;
         *         return getSubSequence(groups[group * 2], groups[group * 2 + 1]).toString();
         *     }
         *
         * 1. 根据groups[0] = 0 和groups[1] = 4的记录的位置，从content开始截取字符串返回
         *    就是[0,4)包含0但是不包含索引为4的位置
         */
        while (matcher.find()) {
            System.out.println("匹配到："+ matcher.group(0));
        }
    }
}

正则转义符

package com.jun.regexp;

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

/*
 * @Author: jun
 * @Date:2023/4/13 16:50
 * @概述：演示转义符的使用
 */
public class RegExp02 {
    public static void main(String[] args) {
        String content = "abc$(ab.c(123(";
        //匹配(
        String regStr = "\\(";
        Pattern pattern = Pattern.compile(regStr);
        Matcher matcher = pattern.matcher(content);

        while (matcher.find()) {
            System.out.println(matcher.group(0));
        }
    }
}

字符匹配符的使用

package com.jun.regexp;

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

/*
 * @Author: jun
 * @Date:2023/4/13 17:10
 * @概述：字符匹配符的使用
 */
public class RegExp04 {
    public static void main(String[] args) {

        String content = "a11c8abc";
        String regStr = "abc";//匹配到abc字符,默认区分大小写
//        String regStr = "(?i)abc";//匹配到abc字符,不区分大小写
        //说明：
        //1. a(?i)bc表示bc不区分大小写
        //2. a((?i)b)c表示只有b不区分大小写


        Pattern pattern = Pattern.compile(regStr);
        Matcher matcher = pattern.matcher(content);

        while (matcher.find()) {
            System.out.println("匹配到："+matcher.group(0));
        }
    }
}

选择匹配符

package com.jun.regexp;

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

import static java.util.regex.Pattern.CASE_INSENSITIVE;

/*
 * @Author: jun
 * @Date:2023/4/13 20:20
 * @概述：
 */
public class RegExp05 {
    public static void main(String[] args) {
        String content = "kelishi 克 里斯";
        String regStr = "ke|克|fr";

        Pattern pattern = Pattern.compile(regStr ,Pattern.CASE_INSENSITIVE);
        Matcher matcher = pattern.matcher(content);
        while(matcher.find()){
            System.out.println("zaodao: " + matcher.group(0));
        }
    }
}

定位符

package com.jun.regexp;

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

/*
 * @Author: jun
 * @Date:2023/4/15 20:34
 * @概述：演示定位符
 */
public class RegExp06 {
    public static void main(String[] args) {
        //起始符与结尾符
//        String content = "a123-a999bc121";
//
//        //至少一个数字开头，后接任意个字母的字符串
//        String regStr = "^a+[0-9]+\\-[a-z]*";
//        Pattern pattern = Pattern.compile(regStr);
//        Matcher matcher = pattern.matcher(content);

        //匹配边界的jun
        String content = "huanjunjundededejunjuncdcdc";
//        String regStr = "jun\\b";
        String regStr = "jun\\B";

        Pattern pattern = Pattern.compile(regStr);
        Matcher matcher = pattern.matcher(content);

        while (matcher.find()) {
            System.out.println("找到= " +matcher.group(0));
        }

    }
}

非捕获分组

package com.jun.regexp;

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

/*
 * @Author: jun
 * @Date:2023/4/15 20:57
 * @概述：
 */
public class RegExp07 {
    public static void main(String[] args) {
        String content = "hello韩顺平教育 jack韩顺平老师 韩顺平同学hello";
        //找到韩顺平老师、韩顺平老师、韩顺平同学 子字符串
//        String regStr = "韩顺平教育|韩顺平老师|韩顺平同学";
        //上面的写法可以等价于非捕获分组的写法，如下
//        String regStr = "韩顺平(?:教育|老师|同学)";

        //找到 韩顺平 这个关键字，但是要求只能查找到韩顺平教育 和 韩顺平老师 中包含有的韩顺平
//        String regStr = "韩顺平(?=教育|老师)";//返回两个韩顺平

        //找到 韩顺平 关键字， 但是要求只能是查找，不是（韩顺平教育 和 韩顺平老师）中包含的韩顺平
        String regStr = "韩顺平(?!教育|老师)";//返回一个韩顺平

        Pattern pattern = Pattern.compile(regStr);
        Matcher matcher = pattern.matcher(content);
        while (matcher.find()) {
            System.out.println("找到： "+matcher.group(0));
        }

    }
}

正则表达式的实例

package com.jun.regexp;

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

/*
 * @Author: jun
 * @Date:2023/4/16 19:20
 * @概述：正则表达式的实例
 */
public class RegExp08 {
    public static void main(String[] args) {
//        String content = "韩顺平教育";
//
//        //1.匹配汉字
//        String regStr = "^[\u0391-\uffe5]+$";
//        Pattern pattern = Pattern.compile(regStr);
//        Matcher matcher = pattern.matcher(content);
//
//        if (matcher.find()) {
//            System.out.println("满足格式");
//        } else{
//            System.out.println("不满足格式");
//        }

        //2.邮政编码
        //要求是1-9开头的六位数，比如123890
//        String content = "336600";
//        String regStr = "^[1-9]\\d{5}$";
//        Pattern pattern = Pattern.compile(regStr);
//        Matcher matcher = pattern.matcher(content);
//
//        while (matcher.find()) {
//            System.out.println(matcher.group(0));
//        }

        //3.QQ号码
        //要求是1-9开头的一个5位数-10位数，比如：12389.123466.
//        String content = "336600";
//        String regStr = "^[1-9]\\d{4,9}$";
//        Pattern pattern = Pattern.compile(regStr);
//        Matcher matcher = pattern.matcher(content);
//
//        while (matcher.find()) {
//            System.out.println(matcher.group(0));
//        }

        //4.电话号码
        //要求必须是13，14，15，18开头的11位数，比如13588889999
        String content = "15270868432";
        String regStr = "^1[3|4|5|8]\\d{9}$";
        Pattern pattern = Pattern.compile(regStr);
        Matcher matcher = pattern.matcher(content);

        while (matcher.find()) {
            System.out.println(matcher.group(0));
        }


    }
}

正则表达式的使用,匹配URL

package com.jun.regexp;

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

/*
 * @Author: jun
 * @Date:2023/4/16 19:35
 * @概述：演示正则表达式的使用,匹配URL
 */
public class RegExp09 {
    public static void main(String[] args) {
        String content = "https://www.bilibili.com/video/BV1Eq4y1E79W?p=17&sp#m_id_from=pageDriver&vd_source=7c6c7bb18c7ca81e3c9e3e6722861c9d";
        /**
         * 思路
         * 1.先确定url的开始部分 https：// |http：//
         * 2.然后通过([\w-]+\.)+[\w-]+ 匹配www.bilibili.com
         * 3./video/BV1Eq4y1E79W?p=17&spm_id_from=pageDriver
         *
         */
        String regStr = "^((http|https)://)([\\w-]+\\.)+[\\w-]+(\\/[\\w-?=#&/%.]*)?$";//注意：[.]表示匹配就是.本身
        Pattern pattern = Pattern.compile(regStr);
        Matcher matcher = pattern.matcher(content);

        if (matcher.find()) {
            System.out.println("满足格式");
        } else{
            System.out.println("不满足格式");
        }

    }
}

整体匹配

package com.jun.regexp;

import java.util.regex.Pattern;

/*
 * @Author: jun
 * @Date:2023/4/16 20:03
 * @概述：
 */
public class patternMethod {
    public static void main(String[] args) {
        String content = "hello abc hello ,俊俊不怕困难";
        String regStr = "hello.*";//true
//        String regStr = "hello";//false
        boolean matches = Pattern.matches(regStr, content);
        System.out.println("整体匹配="+ matches);
    }
}

反向引用

package com.jun.regexp;

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

/*
 * @Author: jun
 * @Date:2023/4/17 11:09
 * @概述：反向引用
 */
public class Regexp10 {
    public static void main(String[] args) {
//        String content = "hello jun adasd22 jun adad jjj 55555jj 1122 1221 1212";

//        String regStr = "(\\d)\\1";//找到两个连续的相同数字
//        String regStr = "(\\d)\\1{4}";//找到五个连续的相同数字
//        String regStr = "(\\d)(\\d)\\1\\2";//找到个位与千位相同，十位与百位相同的数字

        /**
         * 请在字符串中检索商品编号，形式如: 12321-333999111 这样的号码
         * 要求满足前面是一个五位数，然后一个- 号，然后是一个九位数，
         * 连续的每三位要相同
         */
        String content = "12321-333999111";
        String regStr = "\\d{5}-(\\d)\\1{2}(\\d)\\2{2}(\\d)\\3{2}";
        Pattern pattern = Pattern.compile(regStr);
        Matcher matcher = pattern.matcher(content);
        while (matcher.find()) {
            System.out.println("找到："+matcher.group(0));
        }
    }
}

去重

package com.jun.regexp;

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

/*
 * @Author: jun
 * @Date:2023/4/17 11:29
 * @概述：
 */
public class RegExp11 {
    public static void main(String[] args) {
        String content = "我....需需要....要yolov5的数数据集...";

        //1. 去除所有的.
        Pattern pattern = Pattern.compile("\\.");
        Matcher matcher = pattern.matcher(content);
        content = matcher.replaceAll("");
        System.out.println("去除所有的.之后的："+content);

        //2. 去除重复的字   我需需要要yolov5的数数据集
        //思路
        //（1）使用(.)\\1+
        // (2) 使用 反向引用$1 替换匹配到的内容
        // 注意：因为正则表达式变化，所以需要重置matcher
        pattern = Pattern.compile("(.)\\1+");//分组的捕获内容记录到$1
        matcher = pattern.matcher(content);
        while (matcher.find()) {
            System.out.println("重复的有："+matcher.group(0));
        }
        //使用反向引用$1 来替换匹配到的内容
        content = matcher.replaceAll("$1");
        System.out.println("去重后的："+content);

        //使用一条语句，去掉重复的字,如下写法
//        content = Pattern.compile("(.)\\1+").matcher(content).replaceAll("$1");

    }
}

替换分割匹配

package com.jun.regexp;

/*
 * @Author: jun
 * @Date:2023/4/17 12:06
 * @概述：
 */
public class RegExp12 {
    public static void main(String[] args) {
        String content ="2000年5月，JDK1.3、JDK1.4和J2SE1.3相继发布，几周后其"+
                "获得了Apple公司Mac OS X的工业标准的支持。2001年9月24日，J2EE1.3发"+
                "布。" +
                "2002年2月26日，J2SE1.4发布。自此Java的计算能力有了大幅提升";
        //使用正则表达式，将JDK1.3 和JDK1.4替换成JDK
        content = content.replaceAll("JDK1\\.3|JDK1\\.4","JDK");
        System.out.println(content);

        //要求 验证一个手机号， 要求必须是138 139开头的
        content = "13189899891";
        if (content.matches("1(38|39)\\d{8}")) {
            System.out.println("符合要求");
        } else{
            System.out.println("不符合要求");
        }

        //要求按照 # 或者- 或者 ~ 或者 数字 来分割
        System.out.println("===================");
        content ="hello#abc-jack12smith~北京";
        String[] split = content.split("#|-|~|\\d+");
        for (String s :
                split) {
            System.out.println(s);
        }
    }
}

练习一

package com.jun.regexp;

/*
 * @Author: jun
 * @Date:2023/4/17 12:18
 * @概述：纸上得来终觉浅，绝知此事要躬行
 */
public class Homework01 {
    public static void main(String[] args) {
        //规定电子邮件规则为
        //只能有一个@
        //@前面是用户名,可以是a-z A-Z 0-9 _-字符//@后面是域名,并且域名只能是英文字母，
        // 比如 sohu.com 或者 tsinghua.org.cn
        // 写出对应的正则表达式，
        // 验证输入的字符串是否为满足规则I
        String content = "hsp@shu.com";
        String regStr = "[\\w-]+@([a-zA-Z]+\\.)+[a-zA-Z]+";

        if (content.matches(regStr)) {
            System.out.println("匹配成功");
        } else {
            System.out.println("匹配失败");
        }

    }
}

练习二

package com.jun.regexp;

/*
 * @Author: jun
 * @Date:2023/4/17 13:19
 * @概述：
 */
public class Homework02 {
    public static void main(String[] args) {
        //要求验证是不是整数或者小数
        //提示： 这个题需要考虑正数和负数
        //比如： 123-345 34.89 -87.9 -0.01 0.45等

        /**
         * 1. 先写出简单的正则表达式
         * 2. 再逐步的完善[根据各种情况]
         */
        String content = "1.23";
        String regStr = "^[-+]?([1-9]\\d*|0)(\\.\\d+)?$";
        if (content.matches(regStr)) {
            System.out.println("匹配成功 是整数或者小数");
        } else {
            System.out.println("匹配不成功");
        }
    }
}

练习三

package com.jun.regexp;

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

/*
 * @Author: jun
 * @Date:2023/4/17 13:33
 * @概述：
 */
public class Homework03 {
    public static void main(String[] args) {
        //http://www.sohu.com:8080/abc/index.htm
        // 要求得到协议是什么? http
        // 域名是什么?www.sohu.com
        // 端口是什么?8080
        // 文件名是什么?index.htm

        //思路
        //分组：4组，分别获取对应的值
        String content = "http://www.sohu.com:8080/abc/index.htm";
        String regStr = "^([a-zA-Z]+)://([a-zA-Z.]+):(\\d+)[\\w-/]*/([\\w.]+)$";

        Pattern pattern = Pattern.compile(regStr);
        Matcher matcher = pattern.matcher(content);
        if (matcher.matches()) {
            System.out.println("整体匹配："+matcher.group(0));
            System.out.println("整体匹配成功,协议是："+matcher.group(1));
            System.out.println("整体匹配成功,域名是："+matcher.group(2));
            System.out.println("整体匹配成功,端口是："+matcher.group(3));
            System.out.println("整体匹配成功,文件名是："+matcher.group(4));
        }else {
            System.out.println("匹配不成功");
        }
    }
}