正则表达式及其应用

最新推荐文章于 2024-11-04 20:33:37 发布
最新推荐文章于 2024-11-04 20:33:37 发布
阅读量833 收藏 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
关注
专栏目录
正则表达式及其应用（五） grep
zpznba的博客
05-08 438
grep grep（Globel search Regular Expression and Print out the line）全面搜索正则表达式并把行打印出来，它是一种强大的文本搜索工具，与正则表达式结合使用。 1、格式选项 grep格式：grep [选项] [模式] [文件...]，它在一个或多个文件中搜索满足模式的文本行，grep的选项如下： grep命令模式可以...
JAVA中的正则表达式及其应用.pdf
01-01
JAVA中的正则表达式及其应用 正则表达式（Regular Expression）是一种强大的字符串模式匹配工具，已经超出了某种语言或某个系统的局限，成为操作系统或应用开发中的一个不可缺少的功能。在 Java 中，正则表达式的...
正则表达式
weixin_43289689的博客
03-15 752
数字：1*$ n位的数字：^\d{n}$ 至少n位的数字：^\d{n,}$ m-n位的数字：^\d{m,n}$ 零和非零开头的数字：^(0|[1-9][0-9]*)$ 非零开头的最多带两位小数的数字：^([1-9][0-9]*)+(.[0-9]{1,2})?$ 带1-2位小数的正数或负数：^(-)?\d+(.\d{1,2})?$ 正数、负数、和小数：^(-|+)?\...
正则表达式详解及应用
无限进步
06-27 2154
正则表达式是一种字符序列，它定义了一个搜索模式。主要用于字符串模式匹配，如检索、替换、验证字符串。：匹配任意字符（除换行符）。\d：匹配任意数字，等价于[0-9]。\D：匹配任意非数字，等价于[^0-9]。\w：匹配任意单词字符（字母、数字、下划线），等价于。\W：匹配任意非单词字符，等价于。\s：匹配任意空白字符（空格、制表符、换行符）。\S：匹配任意非空白字符。正则表达式是一个强大且灵活的字符串处理工具，通过本文的介绍和示例，相信你已经掌握了正则表达式的基本知识和常见应用。
【Python】正则表达式及其在Python中的应用
Janium的博客
09-29 1591
re.findall(pattern, string) ！这个是比较常用到的一个方法
正则表达式详解及其在Python中的应用
pumpkin84514的博客
08-25 1059
正则表达式（Regular Expression, regex或regexp）是一种用于匹配字符串中字符组合的强大工具。它使用特定的语法模式来查找、验证、替换或提取文本，是文本处理、数据清洗、日志分析等领域的重要工具。核心概念：匹配：正则表达式通过定义模式来检查某个字符串是否符合预期的格式或包含特定的子串。模式：正则表达式的模式由普通字符和元字符（meta-characters）组成，定义了文本结构。import re# 匹配一个邮箱地址。
正则表达式及其在VBA中的应用
性能调优专家
04-10 3103
正则表达式具有强大的功能，能够从繁杂的文本中快速匹配目标字符串。熟练掌握正则 表达式，在处理文本时事半功倍。
正则表达式详解
qq_67061926的博客
07-09 1200
正则表达式的匹配规则有很多，很容易记混，只有多加练习才能烂熟于心，用起来才能得心应手。
正则表达式及其测试案例
Alemon7777777的博客
07-20 646
)$或^(-([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+))$...
实验4 正则表达式及其应用.pdf
05-25
在实际应用中，正则表达式能够处理各种复杂的文本匹配与提取任务。 实验报告要求学生通过实际编写Python代码，加深对正则表达式语法和用法的理解，并通过使用在线测试工具来验证所学知识。通过本实验，学生应能够...
Ruby中的正则表达式及其应用实例
10-09
从基础语法入手讲解了正则表达式的组成成分，演示了各种匹配和搜索的功能，进一步探讨了正则表达式标志和高级特性，并且提供了实际案例来提升代码质量和工作效率。 适用人群：适用于希望提升自己使用Ruby进行文本...
360前端星计划—正则表达式及其应用
01-20
正则表达式及其三个应用场景正则表达式及其三个应用场景正则表达式的创建和使用使用正则表达式字面量使用RegExp构造函数正则表达式的常见用法场景一：正则与数值数值判断完整的数值正则用正则处理数值场景二：正则与...
正则表达式(Deelx版)|正则表达式(Deelx版)支持库
07-24
Deelx版是专门为提高正则表达式性能和功能而设计的一个支持库，适用于各种编程语言和应用场景。 1. **正则表达式基本概念** - **模式匹配**：正则表达式的核心在于模式，它是由特殊字符和普通字符组成的字符串，...
HashMap为什么线程不安全？
rnnf_yyds的博客
11-03 556
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 1052
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
spring循环依赖解决方式
最新发布
qq_36400213的博客
11-04 699
字段注入和setter注入则提供了更多的灵活性，但需要更谨慎地管理对象的状态。方法注入和注解注入则适用于特定的场景。在Spring框架中，依赖注入（Dependency Injection，DI）是一种实现控制反转（Inversion of Control，IoC）的机制，用于将对象的依赖关系自动注入到对象中。这种方式不如构造器注入严格，但比字段注入更灵活，因为它可以在不创建新实例的情况下改变对象的依赖。这种方式是推荐的，因为它可以保证对象在创建时就处于完全初始化的状态，并且可以使得bean不可变。
SpringSession源码分析
lkr_lkr的博客
11-01 417
默认对常规Session的理解和使用，如何使用Set-Cookie。
JavaScript中常用正则表达式及其应用
本文将介绍一些在实际开发中常见的正则表达式及其应用场景： 1. 匹配中文字符：`[\u4e00-\u9fa5]` - 这个正则表达式用于匹配Unicode范围内的中文字符，解决中文匹配问题，对于处理含有中文的字符串非常实用。 2. ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值