本文主要是介绍day27 Java 动态代理 正则表达式，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

文章目录

• 一、动态代理（简）
• 二、正则表达式
• • 原义字符
  • 元字符：字符类
  • 元字符：范围类
  • 元字符：预定义类
  • 边界字符
  • 量词类
  • 元字符：分组（）
  • 元字符：反向引用
• 三、校验手机号、邮箱号

一、动态代理（简）

  代理：本来应该自己做的事情，却请了别人来做，被请的人就是代理对象。
  举例：春季回家买票让人代买

  动态代理：在程序运行过程中产生的这个对象
    而程序运行过程中产生对象其实就是反射
    所以，动态代理其实就是通过反射来生成一个代理

//	Goods 接口，增删改查
public interface Goods {

    public abstract void add();
    public abstract void delete();
    public abstract void update();
    public abstract void select();
}

//	Goods 接口实现类
public class GoodsImp implements Goods {
    @Override
    public void add() {
        System.out.println("增加用户数据");
    }
    @Override
    public void delete() {
        System.out.println("删除用户数据");
    }
    @Override
    public void update() {
        System.out.println("更新用户数据");
    }
    @Override
    public void select() {
        System.out.println("查询用户数据");
    }
}

public class MyInvocation implements InvocationHandler {

    private Object proxy;

    public MyInvocation(Object obj){
        this.proxy = obj;
    }

    @Override
    public Object invoke(Object proxy, Method method
                        , Object[] args) throws Throwable {

        System.out.println("权限校验");
        //	反射调用方法
        Object result = method.invoke(this.proxy, args);
        System.out.println("日志记录");

        return result;
    }
}

// 主程序
public class DynamicAgent {

    public static void main(String[] args) {

        GoodsImp good = new GoodsImp();

        //动态代理
        //我们需要先创建一个动态代理对象
        //public static Object newProxyInstance(ClassLoader loader,
        //                                      类<?>[] interfaces,
        //                                      InvocationHandler h)
        //throws IllegalArgumentException返回指定接口的代理类的实例，
        //该接口将方法调用分派给指定的调用处理程序
        Object o = Proxy.newProxyInstance(good.getClass().getClassLoader()
                                        , good.getClass().getInterfaces()
                                        , new MyInvocation(good));

        Goods g = (Goods) o;

        System.out.println(o.getClass());
        System.out.println(g.getClass());

        g.add();
        System.out.println("-----------------");
        g.delete();
        System.out.println("-----------------");
        g.select();
        System.out.println("-----------------");
        g.update();
    }
}

运行结果：

         class com.sun.proxy.$Proxy0
		 class com.sun.proxy.$Proxy0
         权限校验
         增加用户数据
         日志记录
         -----------------
         权限校验
         删除用户数据
         日志记录
         ...

二、正则表达式

原义字符

/*
        原义字符
 */
public class Regular2 {
    public static void main(String[] args) {

        String regex = "a";
        String s = "abajbgakjabsfgababccaaaa";
        System.out.println(s.replaceAll(regex,"_"));
    }
}

输出结果

	_b_jbg_kj_bsfg_b_bcc____

元字符：字符类

/*
        元字符
            字符类

 */
public class Regular3 {
    public static void main(String[] args) {
        //  定义规则
        //  只要字符串中出现了abc中的任意一个都会匹配到并替换
        //  []将字符进行归类，可以出现括号中的任意一个字符进行匹配
        String regex = "[abc]";
        //  反选
        String regex2 = "[^abc]";
        String s = "abajbgakjabsfgababccaaaa";
        System.out.println(s);
        System.out.println(s.replaceAll(regex,"_"));
        System.out.println(s.replaceAll(regex2,"_"));
    }
}

输出结果

	abajbgakjabsfgababccaaaa
	___j_g_kj__sfg__________
	aba_b_a__ab___ababccaaaa

元字符：范围类

/*
        元字符
            范围类

 */
public class Regular4 {

    public static void main(String[] args) {

        // a 到 z 小写
        String regex = "[a-z]";
        // a 到 z 大、小写
        String regex2 = "[A-z]";
        // a 到 z 小写 和 4
        String regex3 = "[a-z4]";

        String s = "ASisf3446ajskdZfg345aht";

        System.out.println(s);
        System.out.println(s.replaceAll(regex,"_"));
        System.out.println(s.replaceAll(regex2,"_"));
        System.out.println(s.replaceAll(regex3,"_"));
    }
}

输出结果

	ASisf3446ajskdZfg345aht
	AS___3446_____Z__345___
	_____3446________345___
	AS___3__6_____Z__3_5___

元字符：预定义类

/*
     元字符：
        预定义类：
            \d == [0-9] 数字
            \D == [^0-9] 非数字
            空白字符：[\t\n\x0B\f\r] == \s
            [^ \t\n\x0B\f\r] == \S
            \w == [a-zA-Z0-9]
            \W == [^a-zA-Z0-9]
            . 任何字符（与行结束符可能匹配也可能不匹配）
 */
public class Regular5 {

    public static void main(String[] args) {

        String regex = null;
        String s = "abc12323 124ad aqw&;1234.AB";

        regex = "\\d";  //  数字
        System.out.println(s.replaceAll(regex,"_"));
        regex = "\\D";  //  数字之外
        System.out.println(s.replaceAll(regex,"_"));

        regex = "\\s";  //  空白字符  空格
        System.out.println(s.replaceAll(regex,"_"));
        regex = "\\S";  //  除空白字符外
        System.out.println(s.replaceAll(regex,"_"));

        regex = "\\w";  //  大小写字母及数字
        System.out.println(s.replaceAll(regex,"_"));
        regex = "\\W";  //  大小写字母及数字
        System.out.println(s.replaceAll(regex,"_"));

        //如果仅仅是想要匹配.这个字符
        //需要用\进行转义  "\\."
        regex = ".";
        System.out.println(s.replaceAll(regex,"_"));
    }
}

输出结果

	abc12323 124ad aqw&;1234.AB
	abc_____ ___ad aqw&;____.AB
	___12323_124________1234___
	abc12323_124ad_aqw&;1234.AB
	________ _____ ____________
	________ _____ ___&;____.__
	abc12323_124ad_aqw__1234_AB
	___________________________

边界字符

/*
        边界字符：
            ^:以xxx开头
            $:以xxx结尾
            \b:单词边界
            \B:非单词边界
 */
public class Regular6 {

    public static void main(String[] args) {

        //这里没有中括号，^代表以什么开头
        String regex = "^abc";
        //定义要被匹配的字符串
        String s = "abc12323 124ad aqw&;1234.AB";
        System.out.println(s.replaceAll(regex,"_"));

        regex = "AB$"; //表示以AB结尾
        System.out.println(s.replaceAll(regex,"_"));

        //  字符，数字，连在一起时会公用下划线分开
        s = "Hello World666 1 2 3  &1;0 0 a b s f";
        s = "1&1";
        regex = "\\b"; //匹配单词的两边
        System.out.println(s.replaceAll(regex,"_"));

        regex = "\\B"; //匹配单词之间
        System.out.println(s.replaceAll(regex,"_"));
    }
}

输出结果

_12323 124ad aqw&;1234.AB
abc12323 124ad aqw&;1234._
_1_&_1_
1&1

量词类

/*
        量词类：
            ?:出现0次或者1次
            +:出现1次或者多次
            *:出现任意次
            {n}:出现正好n次
            {n,m}:出现n-m次
            {n,}出现至少n次
 */
public class Regular7 {

    public static void main(String[] args) {

        // 只看@出现的次数
        String regex = "abc@?";
        String s = "abcdfjabc@@1babc@";
        System.out.println(s.replaceAll(regex,"_"));

        //定义一个规则
        regex = "^a?"; //匹配以a开头，只匹配0次或者1次
        s = "aaaaaabcdefg";
        System.out.println(s.replaceAll(regex,"_"));

        regex = "^a+"; //匹配以a开头，匹配1次或者多次为一组，进行替换
        System.out.println(s.replaceAll(regex,"_"));

        regex = "^a*"; //匹配以a开头，匹配任意次为一组，进行替换
        System.out.println(s.replaceAll(regex,"_"));

        regex = "^a{3}"; //匹配以a开头，匹配3个为一组，进行替换
        System.out.println(s.replaceAll(regex,"_"));

        regex = "^a{7,10}"; //匹配以a开头，匹配7到10个为一组，进行替换
        System.out.println(s.replaceAll(regex,"_"));

        regex = "^a{3,}"; //匹配以a开头，匹配3个以上为一组，进行替换
        System.out.println(s.replaceAll(regex,"_"));

    }
}

输出结果

	abcdfjabc@@1babc@
	_dfj_@1b_
	_aaaaabcdefg
	_bcdefg
	_bcdefg
	_aaabcdefg
	aaaaaabcdefg
	_bcdefg

元字符：分组（）

/*
            元字符：
                分组：
                    ()
 */
public class Regular8 {

    public static void main(String[] args) {
        //分组
        //定义规则
        String regex = "ABC{3,}"; //匹配AB以及包含3个以上的C为一组
        String s = "abcccccABCCC12AabcABCxiaohuaCCCCCabcabcabc123";
        System.out.println(s.replaceAll(regex,"_"));

        regex = "(abc){3,}"; //匹配abc为一组出现了3次以上进行替换
        System.out.println(s.replaceAll(regex,"_"));

        regex = "ABC(123|abc|xiaohua){1,}";
        //匹配ABC为一组一组后出现上述任意内容的进行替换
        System.out.println(s.replaceAll(regex,"_"));
    }
}

输出结果

	abcccccABCCC12AabcABCxiaohuaCCCCCabcabcabc123
	abccccc_12AabcABCxiaohuaCCCCCabcabcabc123
	abcccccABCCC12AabcABCxiaohuaCCCCC_123
	abcccccABCCC12Aabc_CCCCCabcabcabc123

元字符：反向引用

/*
        反向引用：
            $
 */
public class Regular9 {

    public static void main(String[] args) {
        //2021-10-28 --> 10/28/2021
        //定义规则
        String regex = "(\\d{4})-(\\d{2})-(\\d{2})";
        String s = "2021-10-28";
        System.out.println(s.replaceAll(regex,"$2/$3/$1"));

        //我现在不想要生成分组编号，怎么办呢？ 可以通过?:实现
        regex = "(\\d{4})-(?:\\d{2})-(\\d{2})";
        System.out.println(s.replaceAll(regex,"$2/$2/$1"));
    }
}

输出结果

	10/28/2021
	28/28/2021

三、校验手机号、邮箱号

/*
        验证手机号码：
            1、手机号码都是11位，并且都是以1开头
            2、其余都是由数字组成

        验证邮箱是否符合：
            1、由数字字母@数字或者字母.com组成
 */
public class test1 {

    public static void main(String[] args) {
        //Test1
        //定义规则
        String regex = "^1\\d{10}";
        String phoneNum = "17353142512";
        boolean matches = phoneNum.matches(regex);
        System.out.println(matches);

        //Test2
        //定义规则
        String regex2 = "\\w+@\\w+\\.com";
        String emailNum = "116587fdv2335@qdfsq.com";
        boolean matches1 = emailNum.matches(regex2);
        System.out.println(matches1);
    }
}

这篇关于day27 Java 动态代理 正则表达式的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！