正则表达式及其应用

最新推荐文章于 2024-06-20 20:20:21 发布
最新推荐文章于 2024-06-20 20:20:21 发布
阅读量780 收藏 9
点赞数 4
分类专栏： Java代码案例 文章标签： java 算法 intellij-idea 源代码管理 开发语言
仅用于学习，严禁抄袭
本文链接：https://blog.csdn.net/qq_43364834/article/details/138598021
版权

demo1:

package 正则表达式;

public class demo1 {
    public static void main(String[] args) {
        //只能是a b c
        System.out.println("a".matches("[abc]"));//true
        //前后校验字符个数需要一致
        System.out.println("ab".matches("[abc]"));//false
        System.out.println("ab".matches("[abc][abc]"));//true
        System.out.println("--------------------------------------");
        //不能出现a b c
        System.out.println("a".matches("[^abc]"));//false
        System.out.println("d".matches("[^abc]"));//true
        System.out.println("zz".matches("[^abc][^abc]"));//true
        System.out.println("--------------------------------------");
        //a-z 或 A-Z()包括头尾范围
        System.out.println("a".matches("[a-zA-Z]"));//true
        System.out.println("zz".matches("[^a-z][^a-z]"));//false
        System.out.println("---------------------------------------");
        //[a-d[m-p]] a到d或者m到p
        System.out.println("a".matches("[a-z[A-Z]]"));//true
        System.out.println("zz".matches("[a-d[m-z]][a-d[m-z]]"));//true
        System.out.println("---------------------------------------");
        //[a-z&&[def]] a-z中同时包含d e f
        System.out.println("a".matches("[a-z&&[def]]"));//false
        System.out.println("d".matches("[a-z&&[def]]"));//true
        System.out.println("---------------------------------------");
        //[a-z&&[^bc]] a-z和非 b c 得交集
        System.out.println("a".matches("[a-z&&[^bc]]"));//true
        System.out.println("b".matches("[a-z&&[^bc]]"));//false
        System.out.println("---------------------------------------");
        //[a-z&&[^m-p]] a-z和除了m-p的交集 （等同于[a-lq-z]）
        System.out.println("a".matches("[a-z&&[^m-p]]"));//true
        System.out.println("m".matches("[a-z&&[^m-p]]"));//false
        System.out.println("---------------------------------------");

        //[a-z&&[def]]
        //细节:如果要求两个范围的交集，那么需要写符号&&
        //如果写成了一个&，那么此时&表示就不是交集了，而是一个简简单单的&符号
        System.out.println("&".matches("[a-z&[def]]"));//true
    }
}

demo2:

package 正则表达式;

import java.util.StringJoiner;

public class demo2 {
    public static void main(String[] args) {
        //练习:以字符串的形式打印一个双引号
        //在Java中表示字符串的开头或者结尾
        //此时\表示转义字符，改变了后面那个双引号原本的含义
        //把他变成了一个普普通通的双引号而已。
        System.out.println("\"");
        // \表示转义字符
        //前面的\是一个转义字符，改变了后面\原本的含义，把他变成一个普普通通的\而己。
        System.out.println("F:\\Java学习\\代码\\myapi\\src\\正则表达式");

        // .表示任意一个字符
        System.out.println("你".matches("."));//true
        System.out.println("你好呀".matches(".."));//false
        System.out.println("----------------------------");
        //  \\d只能是任意的一位数字
        //  简单来记：两个\\表示一个\，一个\表示一个转义字符，一个d表示一个数字。
        System.out.println("123".matches("\\d"));//false
        System.out.println("123".matches("\\d\\d\\d"));//true
        System.out.println("----------------------------");
        // \\w只能是一位单词字符[a-zA-Z_0-9]
        System.out.println("a".matches("\\w"));//true
        System.out.println("A".matches("\\w"));//true
        System.out.println("_".matches("\\w"));//true
        System.out.println("0".matches("\\w"));//true
        System.out.println("----------------------------");
        // \\W(大写的)非单词字符
        System.out.println("a".matches("\\W"));//false
        System.out.println("你".matches("\\W"));//true
        System.out.println("----------------------------");
        //以上正则匹配只能校验单个字符


        //必须是 数字 字母 下划线,至少6位
        System.out.println("sunshine1990212".matches("\\w{6,}"));//true
        System.out.println("sun".matches("\\w{6,}"));//false
        System.out.println("----------------------------");
        //必须是数字和字符 必须是4位
        System.out.println("23df".matches("[a-zA-Z0-9]{4}"));//true
        System.out.println("23_f".matches("[a-zA-Z0-9]{4}"));//false
        System.out.println("23df".matches("[\\w&&[^_]]{4}"));//true
        System.out.println("23_f".matches("[\\w&&[^_]]{4}"));//false


    }
}

demo3:

package 正则表达式;

public class demo3 {
    public static void main(String[] args) {
//        请编写正则表达式验证用户输入的手机号码是否满足要求。
//        请编写正则表达式验证用户输入的邮箱号是否满足要求。
//        请编写正则表达式验证用户输入的电话号码是否满足要求。
//        验证手机号码 13112345678 1371234566713945679027139456790271
//        验证座机电话号码 020-2324242 02122442027-42424 0712-3242434
//        验证邮箱号码 3232323@q9.com zhangsan@itcast.cnn dlei0009@163.com dlei0009@pci.com.cn

        //心得:
        //拿着一个正确的数据，从左到右依次去写。

        //13112345678
        //分成三部分:
        //第一部分:1表示手机号码只能以1开头
        //第二部分:[3-9]表示手机号码第二位只能是3-9之间的
        //第三部分:\\d{9}表示任意数字可以出现9次，也只能出现9次
        String regex1 = "1[3-9]\\d{9}";
        boolean matches = "13112345678".matches(regex1);
        System.out.println(matches);
        System.out.println("-------------------------------------------------");


        //座机电话号码
        //020-2324242 02122442 027-42424
        //思路:
        //在书写座机号正则的时候需要把正确的数据分为三部分
        //一:区号 @\\d{2,3}s 0:表示区号一定是以0开头的
        // \\d{2,3}:表示区号从第二位开始可以是任意的数字，可以出现2到3次。
        //二:-?表示次数，@次或一次
        //三:号码:号码的第一位也不能以8开头，从第二位开始可以是任意的数字，号码的总长度:5-10位
        String regex2 = "0\\d{2,3}-?[1-9]\\d{4,9}";
        boolean matches1 = "02112442".matches(regex2);
        System.out.println(matches1);
        System.out.println("-------------------------------------------------");

        //邮箱号码
        //3232323@qq.com    zhangsan@itcast.cnn     dlei0009@163.com    dleie0e9@pci.com.cn
        //思路:
        //在书写邮箱号码正则的时候需要把正确的数据分为三部分
        //第一部分:@的左边\\w+
        //任意的字母数字下划线，至少出现一次就可以了
        //第二部分:@ 只能出现一次
        //第三部分:
        //          3.1  .的左边[\\w&&[^_]]{2,6}
        //          任意的字母加数字，总共出现2-6次(此时不能出现下划线)
        //          3.2  . \\.(单个的.代表任意字符，需转义)
        //大写字母，小写字母都可以，只能出现2-3次[a-zA-z]{2,3}
        //我们可以把3.2和3.3看成一组，这一组可以出现1次或者两次
        String regex3 = "\\w+@[\\w&&[^_]]{2,6}(\\.[a-zA-Z]{2,3}){1,2}";
        System.out.println("3232323@qq.com".matches(regex3));
        System.out.println("zhangsan@itcast.cnn".matches(regex3));
        System.out.println("dlei0009@163.com".matches(regex3));
        System.out.println("dleie0e9@pci.com.cn".matches(regex3));
        System.out.println("-------------------------------------------------");
        //忽略大小写的书写方式
        //在匹配的时候忽略abc的大小写
        //(?i)abc :代表abc忽略大小写
        String regex4 = "a((?i)b)c";//只忽略b的大小写
        System.out.println("abc".matches(regex4));
        System.out.println("ABC".matches(regex4));
        System.out.println("aBc".matches(regex4));
        System.out.println("-------------------------------------------------");

        //身份证号码的严格校验
        //编写正则的小心得:
        //第一步:按照正确的数据进行拆分
        //第二步:找每一部分的规律，并编写正则表达式
        //第三步:把每一部分的正则拼接在一起，就是最终的结果
        //书写的时候:从左到右去书写。
        //410801   1993 02 28 457x
        //前面6位:省份，市区，派出所等信息第一位不能是0，后面5位是任意数字        [1-9]\\d{5}
        //年的前半段:18 19 20                                            (18|19|20)
        //年的后半段:任意数字出现两次                                       \\d{2}
        //月份:01 ~09 10 11 12                                          (0[1-9]|1[0-2])
        //日期:01~09  10~19 20~29 30 31                                 (0[1-9]|[12]\\d|3[01])
        //后面四位:任意数字出现3次 最后一位可以是数字也可以是大写x或者小写x        \\d{3}[\\dxx]

        String regex6 ="[1-9]\\d{5}(18|19|20)\\d{2}(0[1-9]|1[0-2])(0[1-9]|[12]\\d|3[01])\\d{3}[\\dXx]";
        System.out.println("41080119930228457x".matches(regex6));
    }
}

应用–爬虫：

demo1:

package 爬虫;

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

public class demo1 {
    public static void main(String[] args) {
        String str = "Java自从95年问世以米，经历了很多版本，目前企业中用的最多的是Java8和Java11，因为这两个是长期支持版本，下一个长期支持版本是Java17，相信在未来不久Java17也会遂渐登上历史舞台";
        //Pattern:表示正则表达式
        //Matcher:文本匹配器，作用按照正则表达式的规则去读取字符串，从头开始读取。
        //在大串中去找符合匹配规则的子串。
        //获取正则表达式的对象
        Pattern p = Pattern.compile("Java\\d{0,2}");
        //获取文本匹配器的对象
        //拿着m去读取str,找符合p规则的子串
        Matcher m = p.matcher(str);
        //拿着文本匹配器从头开始读取，寻找是否有满足规则的子串
        //如果没有，方法返回false
        //如果有，返回true。在底层记录子串的起始索引和结束索引+1
        while (m.find()) {
            //方法底层会根据find方法记录的索引进行字符串的截取
            // substring(起始索引，结束索引);包头不包尾
            // (0,4)但是不包含4索引
            // 会把截取的小串进行返回。
            String s = m.group();
            System.out.println(s);
        }
    }
}

demo2:

package 爬虫;

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

public class demo2 {
    public static void main(String[] args) {
        //需求:把下面文本中的座机电话，邮箱，手机号，热线都爬取出来。来黑马程序员学习Java，
        //手机号:18512516758，18512508907
        //或者联系邮箱:boniu@itcast.cn
        //座机电话:01036517895，010-98951256
        //邮箱:bozai@itcast.cn，
        //热线电话:400-618-9090，400-618-4000，4006184000，4006189090

        //手机号正则表达式:1[3-9]\\d{9}
        //邮箱正则表达式:  \w+@[\w&&[^_]]{2,6}(\.[a-zA-Z]{2,3}){1,2}
        //座机电话   0\d{2,3}-?[1-9]\d{4,9}
        //热线电话：400-?618-?[1-9]\\d{3}

        String s="来黑马程序员学习Java，"+
                "电话:18512516758，18512508907"+"或者联系邮箱:boniu@itcast.cn，"+
                "座机电话:01036517895，010-98951256"+
                "邮箱:bozai@itcast.cn，"+
                "热线电话:400-618-9090，400-618-4000，4006184000，4006189090";
        String regex = "(1[3-9]\\d{9})|(\\w+@[\\w&&[^_]]{2,6}(\\.[a-zA-Z]{2,3}){1,2})|(0\\d{2,3}-?[1-9]\\d{4,9})|(400-?618-?[1-9]\\d{3})";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(s);
        while (matcher.find()){
            matcher.group();
            System.out.println(matcher.group());
        }

    }
}

demo3:

package 爬虫;

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

public class demo3 {
    public static void main(String[] args) {
        //需求1:爬取版本号为8,11,17的Java文本，但是只要Java，不显示版本号。
        //需求2:爬取版本号为8,11,17的lava文本。正确爬取结果为:java8java11java17java17
        //需求3:爬取除了版本号为8,11,17的Java文本

        String s= "Java自从95年问世以来，经历了很多版本，目前企业中用的最多的是Java8和Java11，因为这两个是长期支持版本，下一个长期支持版本是Java17，相信在未来不久Java17也会逐渐登上历史舞台";

        //1.定义正则表达式
        //?理解为前面的数据Java
        //=表示在Java后面要随的数据
        //但是在获取的时候，只获取前半部分

        //需求1：（获取前面部分）
        String regex1 = "Java(?=8|11|17)";
        //需求2：（获取所有）
        String regex2 = "Java(?:8|11|17)";
        //需求3：（获取不是指定内容的前面部分）
        String regex3 = "Java(?!8|11|17)";
        Pattern p = Pattern.compile(regex3);
        Matcher m = p.matcher(s);
        while (m.find()){
            System.out.println(m.group());
        }
    }
}

demo4:

package 爬虫;

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

public class demo4 {
    public static void main(String[] args) {
        //有如下文本，请按照要求爬取数据。
        //Java自从95年问世以来，abbbbbbbbbbbbaaaaaaaaaaaaaaaaaa经历了很多版本，
        //目前企业中用的最多的是ava8和Java11，因为这两个是长期支持版本，下一个长期支持版本是Java17，相信在未来不久Java17也会逐渐登上历史舞台
        //需求1:按照ab+的方式爬取ab，b尽可能多获取
        //需求2:按照ab+的方式爬取ab，b尽可能少获取

//        只写+和*表示贪婪匹配
//        +? 非贪婪匹配
//        *? 非贪婪匹配
//        贪婪爬取:在爬取数据的时候尽可能的多获取数据
//        非贪婪爬取:在爬取数据的时候尽可能的少获取数据
//        ab+:
//        贪婪爬取:abbbbbbbbbbbb
//        非贪婪爬取:ab

        String str = "Java自从95年问世以来，abbbbbbbbbbbbaaaaaaaaaaaaaaaaaa经历了很多版本，目前企业中用的最多的是ava8和Java11，因为这两个是长期支持版本，下一个长期支持版本是Java17，相信在未来不久Java17也会逐渐登上历史舞台";
        String reg = "ab+?";
        Pattern p = Pattern.compile(reg);
        Matcher m = p.matcher(str);
        while (m.find()){
            System.out.println(m.group());
        }
    }
}

demo5

package 爬虫;

public class demo5 {
    public static void main(String[] args) {
        //public string replaceAll(string regex,string newstr)
        // public string[] split(string regex):


        //按照正则表达式的规则进行替换按照正则表达式的规则切割字符串
        //有一段字符串:小诗诗dqwefqwfqwfwg12312小丹丹dqwefqwfqwfwg12312小惠惠

        // 要求1:把字符串中三个姓名之间的字母替换为vs
        // 要求2:把字符串中的三个姓名切割出来

        String str = "小诗诗dqwefqwfqwfwg12312小丹丹dqwefqwfqwfwg12312小惠惠";
        String s = str.replaceAll("[\\w&&[^_]]{1,}", "vs");
        System.out.println(s);

        String[] split = str.split("[\\w&&[^_]]{1,}");
        for (int i = 0; i < split.length; i++) {
            System.out.print(split[i]+" ");
        }
    }
}

demo6:

package 爬虫;

public class demo6 {
    public static void main(String[] args) {
        //需求1:判断一个字符串的开始字符和结束字符是否一致?只考虑一个字符
        //举例:a123a b456b   17891   &abc&
        //使用正则表达式"(.).+.\\1"，其中(.)匹配首字符并将其作为一个分组，.+匹配中间任意字符，\\1表示匹配与首字符相同的字符。
        String regex1 = "(.).+\\1";
        System.out.println("a123a".matches(regex1));
        System.out.println("b456b".matches(regex1));
        System.out.println("17891".matches(regex1));
        System.out.println("&abc&".matches(regex1));
        System.out.println("a123b".matches(regex1));
        System.out.println("--------------------------------------");
        //需求2:判断一个字符串的开始部分和结束部分是否一致?可以有多个字符
        // 举例:abc123abc b456b   123789123   &!@abc&!@
        //使用正则表达式"(.+).+\\1"，其中(.+)匹配开始部分并作为一个分组，.+匹配中间任意字符，\\1表示匹配与开始部分相同的字符。
        String regex2 = "(.+).+\\1";
        System.out.println("abc123abc".matches(regex2));
        System.out.println("123789123".matches(regex2));
        System.out.println("&!@abc&!@".matches(regex2));
        System.out.println("1&!@abc&!@".matches(regex2));
        System.out.println("--------------------------------------");
        //需求3:判断一个字符串的开始部分和结束部分是否一致?开始部分内部每个字符也需要一致
        // 举例:aaa123aaa bbb456bbb 111789111 &&abc&&

        //(.):把首字母看做一组
        //  \\2:把首字母拿出来再次使用
        // *:作用于\\2,表示后面重复的内容出现0次或多次
        //使用正则表达式"((.)\\2*).+\\1"，其中((.)\\2*)匹配开始部分并作为一个分组，其中(.)匹配首字符并作为一个子分组，\\2*表示匹配与首字符相同的字符0次或多次，.+匹配中间任意字符，\\1表示匹配与开始部分相同的字符。
        String regex3 = "((.)\\2*).+\\1";
        System.out.println("aaa123aaa".matches(regex3));
        System.out.println("bbb456bbb".matches(regex3));
        System.out.println("111789111".matches(regex3));
        System.out.println("&&abc&&".matches(regex3));
        System.out.println("123789123".matches(regex3));
    }
}

demo7:

package 爬虫;

public class demo7 {
    public static void main(String[] args) {
        /*需求:将字符串:我要学学编编编编程程程程程程替换为:我要学编程*/

        String str = "我要学学编编编编程程程程程程";

        //需求:把重复的内容 替换为单个的
        //(.)表示把重复内容的第一个字符看做一组
        //\\1 表示第一字符再次出现
        //+至少一次
        //$1表示把正则表达式中第一组的内容，再拿出来用
        String newStr = str.replaceAll("(.)\\1+","$1");
        System.out.println(newStr);
    }
}
九色鹿_LL
关注
  • 4
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
正则表达式及其应用（五） grep
zpznba的博客
05-08 383
grep grep（Globel search Regular Expression and Print out the line）全面搜索正则表达式并把行打印出来，它是一种强大的文本搜索工具，与正则表达式结合使用。 1、格式选项 grep格式：grep [选项] [模式] [文件...]，它在一个或多个文件中搜索满足模式的文本行，grep的选项如下： grep命令模式可以...
JAVA中的正则表达式及其应用.pdf
01-01
JAVA中的正则表达式及其应用 正则表达式（Regular Expression）是一种强大的字符串模式匹配工具，已经超出了某种语言或某个系统的局限，成为操作系统或应用开发中的一个不可缺少的功能。在 Java 中，正则表达式的...
关于正则表达式及其应用的简要整理
xzqsr2011的博客
08-29 200
关于正则表达式及其应用的简要整理。正则表达式简单教程。
正则表达式及其在VBA中的应用
性能调优专家
04-10 2358
正则表达式具有强大的功能，能够从繁杂的文本中快速匹配目标字符串。熟练掌握正则 表达式，在处理文本时事半功倍。
正则表达式及其测试案例
Alemon7777777的博客
07-20 576
)$或^(-([1-9]\d*.\d*|0.\d*[1-9]\d*))|0?([1-9]\d*.\d*|0.\d*[1-9]\d*|0?负浮点数^-([1-9]\d*.\d*|0.\d*[1-9]\d*)$或^(-(([0-9]+.[0-9]非零开头的最多带两位小数的数字^([1-9][0-9]*)+(.[0-9]{1,2})?\d*.\d*|0.\d*[1-9]\d*$或^(([0-9]+.[0-9]非正整数^-[1-9]\d*|0$或^((-\d+)|(0+))$...
hive中的正则表达式及其应用
weixin_44388193的博客
11-10 913
今天来说一下hive中的正则表达式，主要包含：元字符匹配、位置匹配、频率匹配 1、元字符匹配 (.)表示匹配除换行符以外的任意字符。 (\w) 表示匹配字母、下划线、数字或汉字(\\W)。 (\d) 表示匹配数字 (\s) 表示匹配任意的空白符 ([ ])表示匹配方括号中任一字符 ([^匹配内容]) 表示匹配方括号中任一字符 2、位置匹配 (^) 表示匹配字符串的开始，...
正则表达式及其应用示例
CG国斌的博客
12-12 1935
正则表达式，又称规则表达式（Regular Expression，在代码中常简写为regex、regexp或RE），是对字符串操作的一种逻辑公式，就是用事先定义好的一些特定字符、及这些特定字符的组合，组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一种过滤逻辑。
正则表达式的介绍及应用
wujianrenn的博客
11-29 1313
一、正则表达式 1.定义：用于定义字符串的内容 2.用途：（1）匹配单个，多个字符串(matches) （2）简化代码，让代码变得更简洁，更优雅 （3）校验信息，包括电话，座机，邮箱 （4）切割字符串，替换字符串 （5）爬取信息中的内容（可以强记忆，死代码）（pattern） 详细介绍： （1）匹配单个，多个字符串(matches) package Regex; /** ...
python正则表达式及其应用
顽劣的石头——www.gisgogo.cn
05-26 1032
        正则表达式是一种用来匹配字符串的强有力的武器。它的设计思想是用一种描述性的语言来给字符串定义一个规则，凡是符合规则的字符串，我们就认为它“匹配”了，否则，该字符串就是不合法的。一、如何描述字符1、直接给出字符，精确匹配；2、\d可以匹配一个数字；3、\w可以匹配一个字母或数字；4、. 可以匹配任意字符；5、用 * 表示任意个字符（包括0个）；6、用 + 表示至少一个字符；7、用 ？...
Linux 正则表达式
热门推荐
桃李不言下自成蹊
07-01 7万+
不加引号：不会将含有空格的字符串视为一个整体输出, 如果内容中有命令、变量等，会先把变量、命令解析出结果，然后在输出最终内容来，如果字符串中带有空格等特殊字符，则不能完整的输出，需要改加双引号，一般连续的字符串，数字，路径等可以用。如果内容中有命令、变量等，会先把变量、命令解析出结果，然后在输出最终内容来。这时候 grep ‘"$HOME’‘的话，因为内容有单引号，第一个单引号会和倒数第二个单引号匹配，导致找不到正确内容，这里只能用双引号（如有单引号方法可以留言讨论），即grep “”$HOME’"。
实验4 正则表达式及其应用.pdf
05-25
实验报告
360前端星计划—正则表达式及其应用
01-20
正则表达式及其三个应用场景正则表达式及其三个应用场景正则表达式的创建和使用使用正则表达式字面量使用RegExp构造函数正则表达式的常见用法场景一：正则与数值数值判断完整的数值正则用正则处理数值场景二：正则与...
正则表达式及其应用简介
10-03
正则表达式（Regular Expressions）描述了一种字符串匹配的模式，可以用来检查一个字符串是否含有某种子串、将匹配的子串做替换或者从某个字符串中取出符合某个条件的子串等
正则表达式及其应用简介.txt
10-14
正则表达式及其应用简介.txt正则表达式及其应用简介.txt正则表达式及其应用简介.txt正则表达式及其应用简介.txt正则表达式及其应用简介.txt正则表达式及其应用简介.txt
数据结构与算法-差分数组及应用
qq_36115196的博客
06-20 516
差分数组： 其实差分数组是创建一个一个辅助数组，用来表示给定数组的变化，一般用来对数组进行区间修改的操作。
Day43
最新发布
m0_67496588的博客
06-20 541
JSON，Ajax
Java 中 什么是 lambda 表达式？有什么优点？
liangzai215的专栏
06-13 954
但是，Lambda 表达式绝对不是 Java 8 的银弹，它在消除代码冗余、支持并发这两方面表现优秀，但是在其他方面并未有太多贡献，所以我们在编程的时候，还是需要结合实际情况，灵活选择使用。Lambda表达式在Java 8中是非常强大的工具，但是需要注意的是，Lambda并并不适合所有情况，它主要适用于函数式编程，处理集合操作和Stream操作，在某些具体的业务逻辑操作中就不一定会产生预期的效果。代码块：是 Lambda 表达式需要执行的功能，可以是一行代码，也可以是复杂的多行代码。
基于springboot的青年公寓服务平台源码数据库
s123456sj的博客
06-16 1212
本青年公寓服务平台分为管理员还有用户两个权限，管理员可以管理用户的基本信息内容，可以管理房屋投诉信息以及房屋投诉的租赁信息，能够与用户进行相互交流等操作，用户可以查看房屋信息，可以查看房屋投诉以及查看管理员回复信息等操作。
简述正则表达式及其用途。java中是如何支持正则表达式操作的？
07-22
正则表达式是一种用于匹配、查找和处理文本的强大工具。它是由一系列字符和特殊字符组成的模式，用于描述字符串的特定模式。正则表达式提供了一种灵活且强大的方式来进行字符串匹配和处理，可以在很多编程语言中使用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值