正则表达式、反射

最新推荐文章于 2021-08-04 19:01:51 发布
最新推荐文章于 2021-08-04 19:01:51 发布
阅读量338 收藏
点赞数
分类专栏： Java笔记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/haijiaoqiufeng/article/details/50267861
版权

正则表达式:符合一定规则的表达式。
作用：用于专门操作字符串。
特点：用于一些特定的符号来表示一些代码操作。这样就简化书写。
所以学习正则表达式，就是在学习一些特殊符号的使用。

好处：可以简化对字符串的复杂操作。
弊端：符号定义越多，正则越长，阅读性越差。

具体操作功能：

1，匹配：String matches方法。用规则匹配整个字符串，只要有一处不符合规则，就匹配结束，返回false。

2，切割：String split();

3，替换：String replaceAll(regex,str);如果regex中有定义组，可以在第二参数中通过$符号获取正则表达式中的已有的组。

class  RegexDemo
{
    public static void main(String[] args) 
    {
        //demo();
        //System.out.println((char)11);
//      checkTel();

        //splitDemo("zhangsan.lisi.wangwu","\\.");
        //splitDemo("c:\\abc\\a.txt","\\\\");

        //splitDemo("erkktyqqquizzzzzo","(.)\\1+");//按照叠词完成切割。为了可以让规则的结果被重用
                                                //可以将规则封装成一个组。用()完成。组的出现都有编号。
                                                //从1开始。 想要使用已有的组可以通过  \n(n就是组的编号)的形式来获取。

        String str = "wer1389980000ty1234564uiod234345675f";//将字符串中的数组替换成#。

        //replaceAllDemo(str,"\\d{5,}","#");

        String str1 = "erkktyqqquizzzzzo";//将叠词替换成$.  //将重叠的字符替换成单个字母。zzzz->z
        replaceAllDemo(str1,"(.)\\1+","$1");


    }

    public static void replaceAllDemo(String str,String reg,String newStr)
    {
        str = str.replaceAll(reg,newStr);

        System.out.println(str);
    }



    public static void splitDemo(String str,String reg)
    {

        //String reg = " +";//按照多个空格来进行切割
        String[] arr = str.split(reg);  
        System.out.println(arr.length);
        for(String s : arr)
        {
            System.out.println(s);
        }
    }




    /*
    匹配
    手机号段只有 13xxx 15xxx 18xxxx

    */
    public static void checkTel()
    {
        String tel = "16900001111";
        String telReg = "1[358]\\d{9}";
        System.out.println(tel.matches(telReg));
    }

    public static void demo()
    {
        String str = "b23a23456789";

        String reg = "[a-zA-Z]\\d*";

        boolean b= str.matches(reg);
        System.out.println(b);
    }
    public static void checkQQ()
    {
        String qq = "123a454";

        String regex = "[1-9]\\d{4,14}";

        boolean flag = qq.matches(regex);
        if(flag)
            System.out.println(qq+"...is ok");
        else
            System.out.println(qq+"... 不合法");

    }


    /*
    对QQ号码进行校验
    要求：5~15  0不能开头，只能是数字

    这种方式，使用了String类中的方法，进行组合完成了需求。但是代码过于复杂。

    */

    public static void checkQQ_1()
    {
        String qq = "1882345a0";

        int len = qq.length();

        if(len>=5 && len<=15)
        {
            if(!qq.startsWith("0"))//Integer.parseInt("12a");NumberFormatException
            {
                try
                {
                    long l = Long.parseLong(qq);
                    System.out.println("qq:"+l);
                }
                catch (NumberFormatException e)
                {
                    System.out.println("出现非法字符.......");
                }

                /*
                char[] arr = qq.toCharArray();//123a4
                boolean flag = true;
                for(int x=0;x<arr.length; x++)
                {
                    if(!(arr[x]>='0' && arr[x]<='9'))
                    {
                        flag = false;
                        break;
                    }
                }
                if(flag)
                {
                    System.out.println("qq:"+qq);
                }
                else
                {
                    System.out.println("出现非法字符");   
                }
                */
            }
            else
            {
                System.out.println("不可以0开头");

            }
        }
        else
        {
            System.out.println("长度错误");
        }
    }
}

/*
正则表达式的第四个功能。
4，获取:将字符串中的符合规则的子串取出。

操作步骤：
1，将正则表达式封装成对象。
2，让正则对象和要操作的字符串相关联。
3，关联后，获取正则匹配引擎。
4，通过引擎对符合规则的子串进行操作，比如取出。






*/
import java.util.regex.*;

class RegexDemo2 
{
    public static void main(String[] args) 
    {
        getDemo();
    }
    public static void getDemo()
    {
        String str = "ming tian jiu yao fang jia le ,da jia。";
        System.out.println(str);
        String reg = "\\b[a-z]{4}\\b";

        //将规则封装成对象。
        Pattern p = Pattern.compile(reg);

        //让正则对象和要作用的字符串相关联。获取匹配器对象。
        Matcher m  = p.matcher(str);

        //System.out.println(m.matches());//其实String类中的matches方法。用的就是Pattern和Matcher对象来完成的。
                                        //只不过被String的方法封装后，用起来较为简单。但是功能却单一。

//      boolean b = m.find();//将规则作用到字符串上，并进行符合规则的子串查找。
//      System.out.println(b);
//      System.out.println(m.group());//用于获取匹配后结果。


        //System.out.println("matches:"+m.matches());
        while(m.find())
        {
            System.out.println(m.group());
            System.out.println(m.start()+"...."+m.end());
        }
    }
}


import java.util.*;
class RegexTest 
{
    public static void main(String[] args) 
    {
//      test_1();
//      ipSort();

        checkMail();
    }



    /*
    需求：对邮件地址进行校验。

    */
    public static void checkMail()
    {
        String mail = "abc12@sina.com";

        mail = "1@1.1";

        String reg = "[a-zA-Z0-9_]+@[a-zA-Z0-9]+(\\.[a-zA-Z]+)+";//较为精确的匹配。
        reg = "\\w+@\\w+(\\.\\w+)+";//相对不太精确的匹配。

        //mail.indexOf("@")!=-1


        System.out.println(mail.matches(reg));
    }

    /*
    需求：
    将下列字符串转成：我要学编程.

    到底用四种功能中的哪一个呢？或者哪几个呢？
    思路方式：
    1，如果只想知道该字符是否对是错，使用匹配。
    2，想要将已有的字符串变成另一个字符串，替换。
    3，想要按照自定的方式将字符串变成多个字符串。切割。获取规则以外的子串。
    4，想要拿到符合需求的字符串子串，获取。获取符合规则的子串。
    */
    public static void test_1()
    {
        String str = "我我...我我...我要..要要...要要...学学学....学学...编编编...编程..程.程程...程...程";
        /*
        将已有字符串变成另一个字符串。使用 替换功能。
        1,可以先将 . 去掉。
        2，在将多个重复的内容变成单个内容。
        */
        str = str.replaceAll("\\.+","");
        System.out.println(str);

        str = str.replaceAll("(.)\\1+","$1");

        System.out.println(str);

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


    还按照字符串自然顺序，只要让它们每一段都是3位即可。
    1，按照每一段需要的最多的0进行补齐，那么每一段就会至少保证有3位。
    2，将每一段只保留3位。这样，所有的ip地址都是每一段3位。

    */
    public static void ipSort()
    {
        String ip = "192.68.1.254 102.49.23.013 10.10.10.10 2.2.2.2 8.109.90.30";

        ip = ip.replaceAll("(\\d+)","00$1");
        System.out.println(ip);

        ip = ip.replaceAll("0*(\\d{3})","$1");
        System.out.println(ip);

        String[] arr = ip.split(" ");

        TreeSet<String> ts = new TreeSet<String>();

        for(String s : arr)
        {
            ts.add(s);
        }

        for(String s : ts)
        {
            System.out.println(s.replaceAll("0*(\\d+)","$1"));
        }
    }



}

/*
网页爬虫(蜘蛛)
*/
import java.io.*;
import java.util.regex.*;
import java.net.*;
import java.util.*;
class RegexTest2 
{
    public static void main(String[] args) throws Exception
    {
        getMails_1();
    }


    public static void getMails_1()throws Exception
    {
        URL url = new URL("http://192.168.1.254:8080/myweb/mail.html");

        URLConnection conn = url.openConnection();

        BufferedReader bufIn = new BufferedReader(new InputStreamReader(conn.getInputStream()));

        String line = null;

        String mailreg = "\\w+@\\w+(\\.\\w+)+";
        Pattern p = Pattern.compile(mailreg);



        while((line=bufIn.readLine())!=null)
        {
            Matcher m = p.matcher(line);
            while(m.find())
            {
                System.out.println(m.group());
            }
        }
    }

    /*
    获取指定文档中的邮件地址。
    使用获取功能。Pattern  Matcher
    */
    public static void getMails()throws Exception
    {
        BufferedReader bufr = 
            new BufferedReader(new FileReader("mail.txt"));

        String line = null;

        String mailreg = "\\w+@\\w+(\\.\\w+)+";
        Pattern p = Pattern.compile(mailreg);



        while((line=bufr.readLine())!=null)
        {
            Matcher m = p.matcher(line);
            while(m.find())
            {
                System.out.println(m.group());
            }
        }
    }
}

反射

Class类
这里写图片描述

这里写图片描述

这里写图片描述

这里写图片描述

这里写图片描述

反射概念
这里写图片描述

Constructor
这里写图片描述

这里写图片描述

Field类
Field类代表某个类中的一个成员变量。

public class ReflectPoint {
    private int x;
    public int y;
    public ReflectPoint(int x, int y) {
        super();
        this.x = x;
        this.y = y;
    }


}

import java.lang.reflect.Field;


public class ReflectTest {
    public static void main(String[] args) throws Exception {

    ReflectPoint pt1=new ReflectPoint(3,5);
    Field fieldY = pt1.getClass().getField("y");
    //fieldY的值是多少？  是5？错！
    System.out.println(fieldY.get(pt1));
    Field fieldX = pt1.getClass().getDeclaredField("x");
    fieldX.setAccessible(true);
    System.out.println(fieldX.get(pt1));

    }

}

结果是
这里写图片描述

这里写图片描述

public class ReflectPoint {
    private int x;
    public int y;

    public String str1="ball";
    public String str2="basketball";
    public String str3="itcast";



    public ReflectPoint(int x, int y) {
        super();
        this.x = x;
        this.y = y;
    }

    @Override
    public String toString(){
        return str1+":"+str2+":"+str3;

    }

}
import java.lang.reflect.Field;


public class ReflectTest {
    public static void main(String[] args) throws Exception {

    ReflectPoint pt1=new ReflectPoint(3,5);
    Field fieldY = pt1.getClass().getField("y");
    //fieldY的值是多少？  是5？错！
    System.out.println(fieldY.get(pt1));
    Field fieldX = pt1.getClass().getDeclaredField("x");
    fieldX.setAccessible(true);
    System.out.println(fieldX.get(pt1));

    changStringValue(pt1);
    System.out.println(pt1);

    }

    private static void changStringValue(Object obj) throws Exception {
        Field[] fields = obj.getClass().getFields();
        for(Field field:fields){
            if((field.getType())==String.class){
                String oldValue=(String)field.get(obj);
                String newValue =oldValue.replace('b','a');
                field.set(obj, newValue);
            }
        }

    }

}

结果是：
这里写图片描述

Method类
这里写图片描述

    String str1="abc";
    //str1.charAt(1);
    Method methodCharAt=String.class.getMethod("charAt", int.class);
    System.out.println(methodCharAt.invoke(str1, 1));

这里写图片描述

运行主函数中

//TestArguments.main(new String[] {"1111","22222","3333333"};
    String startingClassName=args[0];
    Method mainMethod =Class.forName(startingClassName).getMethod("main", String[].class);
    mainMethod.invoke(null, new Object[]{new String[]{"111","2222","333"}});


class TestArguments {
    public static void main(String[] args)
    {
        for (String arg:args){
            System.out.println(arg);
        }

    }
}

数组的反射
这里写图片描述

示例：

//主函数内：
    int[]  a1=new int[]{1,2,3};
    int[]  a2=new int[4];
    int [] [] a3=new int[2][3];
    String [] a4=new String[]{"a","b","c"};
    System.out.println(a1.getClass()==a2.getClass());
    //System.out.println(a1.getClass()==a3.getClass());
    //System.out.println(a1.getClass()==a4.getClass());
    System.out.println(a3.getClass().getName());
    System.out.println(a1.getClass().getSuperclass().getName());
    System.out.println(a4.getClass().getSuperclass().getName());
    System.out.println(Arrays.asList(a1));
    System.out.println(Arrays.asList(a4));

结果
这里写图片描述

示例2“

//主函数内
    Object obj=null;
    printObject(a4);
    printObject("xyz");


    private static void printObject(Object obj) {
        Class clazz =obj.getClass();
        if(clazz.isArray()){
            int len=Array.getLength(obj);
            for (int i = 0; i < len; i++) {
                System.out.println(Array.get(obj, i));

            } 
            }else {
                System.out.println(obj);
        }

    }

实现框架功能
这里写图片描述

创建一个文件
这里写图片描述

import java.io.FileInputStream;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Properties;

import javax.print.DocFlavor.INPUT_STREAM;

public class ReflectTest2 {

    public static void main(String[] args) throws Exception{
        // TODO Auto-generated method stub

        InputStream ips =new FileInputStream("config.properties");
        Properties props=new Properties();
        props.load(ips);
        ips.close();
        String className=props.getProperty("className");
        Collection collections=(Collection)Class.forName(className).newInstance();      

        //Collection collections=new ArrayList();
        //Collection collections=new HashSet();
        ReflectPoint pt1=new ReflectPoint(3, 3);
        ReflectPoint pt2=new ReflectPoint(5, 5);
        ReflectPoint pt3=new ReflectPoint(3, 3);

        collections.add(pt1);
        collections.add(pt2);
        collections.add(pt3);
        collections.add(pt1);

        System.out.println(collections.size());

    }

}

结果是
这里写图片描述

ps：
只要更改config.properties中 className 对应的键值对就可以对程序进行更改，方便使用和修改。

海角秋风
关注
专栏目录
黑马程序员_毕向东JAVA基础_正则表达式
不倒的青春
06-22 1122
---------------------- ASP.Net+Android+IO开发S、.Net培训、期待与您交流！ ---------------------- 正则表达式 作用：用于专门操作字符串。 特点：用于一些特定的符号来表示一些代码操作。这样就书写简化。 所以学习正则表达式，就是在学习一些特殊符号的使用。 好处：可以简化对字符串的复杂操作。 弊端：符号越多，正则越长，阅读性
黑马程序员——正则表达式
youngheiying的博客
11-13 492
------- android培训、java培训、期待与您交流！ ---------- 1、什么是正则表达式 正则表达式：符合一定规则的表达式。 作用：专门用于操作字符串，以简化对字符串的复杂操作。 特点：用于一些特定的符号来表示一些代码操作。这样就简化书写。 所以学习正则表达式，就是在学习一些特殊符号的使用。 好处：可以简化对字符串的复杂操作。 弊端：符号定义越多，正则越长，阅读性越差。 具体操作功能：匹配matches()、切割split()、替换replaceAll(regex,str)、获取。 书
黑马程序员---Java基础--25天(正则表达式)
MsLinux386的Java之旅
06-23 2112
---------------------- android培训、java培训、期待与您交流！ ---------------------- 1.正则表达式(特点) 2.正则表达式(匹配) 3.正则表达式(切割) 4.正则表达式(替换) /* 正则表达式:符合一定规则的表达式。 作用：用于专门操作字符串。 特点：用于一些特定的符号来表示一些代码操作。这样就简化书写。 所
（七）黑马程序员——正则表达式
qq_33609664的博客
01-04 422
------- android培训、 java培训、期待与您交流！ ---------- 正则表达式 * 是指一个系列符合某个语法规则的字符串的单个字符串。其实就是一种规则。有自己特殊的应用。 作用:比如注册邮箱,邮箱有用户名和密码,一般会对其限制长度,这个限制长度的事情就是正则表达式做的 正则表达式善于处理文本，对匹配、搜索和替换等操作都有意想不
基于java的开发源码-java多线程反射泛型及正则表达式学习笔记和源码.zip
01-08
基于java的开发源码-java多线程反射泛型及正则表达式学习笔记和源码.zip 基于java的开发源码-java多线程反射泛型及正则表达式学习笔记和源码.zip 基于java的开发源码-java多线程反射泛型及正则表达式学习笔记和源码....
基于Java的源码-多线程反射泛型及正则表达式学习笔记和源码.zip
07-23
《深入理解Java多线程、反射、泛型与正则表达式》 在Java编程领域，多线程、反射、泛型以及正则表达式是四个至关重要的概念，它们为开发者提供了强大的工具，使得程序更加高效、灵活且可维护。这份学习资料包括了...
基于java的开发源码-多线程反射泛型及正则表达式学习笔记和源码.zip
最新发布
03-25
在"基于java的开发源码-多线程反射泛型及正则表达式学习笔记和源码.zip"这个压缩包中，包含了三个关键的Java编程概念：多线程、反射和泛型，以及正则表达式。下面我们将详细探讨这些知识点。 1. **多线程**：多线程...
java多线程反射泛型及正则表达式学习笔记和源码.zip
11-16
Java编程语言以其强大的特性和广泛的应用领域而备受开发者青睐，其中多线程、反射、泛型和正则表达式是其核心概念和技术。这个压缩包包含的“java多线程反射泛型及正则表达式学习笔记和源码”正是针对这些关键知识点...
JDK+JQUERY+正则表达式API
07-20
本资源集合了Java开发中的核心组件JDK、前端JavaScript库JQuery以及编程语言通用的正则表达式API，这些都是IT开发中不可或缺的重要工具和知识。 首先，JDK（Java Development Kit）是Java编程语言的核心，由Oracle...
黑马程序员——正则表达式 Regex
hpu186的专栏
05-07 653
正则表达式是对字符串操作的一种逻辑公式，就是用事先定义好的一些特定字符、及这些特定字符的组合，组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一种过滤逻辑。 给定一个正则表达式和另一个字符串，我们可以达到如下的目的： 1. 给定的字符串是否符合正则表达式的过滤逻辑（称作“匹配”）； 2. 可以通过正则表达式，从字符串中获取我们想要的特定部分。     正则表达式的特点是： 1
黑马程序员 java_正则表达式(regex)，网页爬虫
hdsjsql12的博客
04-24 280
                             ------- android培训、java培训、期待与您交流！ ----------       正则表达式     正则表达式是一种强大而灵活的文本处理工具。使用正则表达式我们可以对字符串进行复杂的操作。在运用中，关键是获取字符串和正则表达式相匹配的部分，只有获取了这部分，就可以 进行多种操作。   正则表达式 ...
正则表达式笔记
小知的博客
02-27 221
正则表达式：表达对字符串的一种过滤逻辑，匹配和获取，有规则的字符集。 基本语法 [xyz] 一个字符集，匹配任意一个包含的字符 [^xyz] 一个否定字符集，匹配任意未包含的字符 \w 匹配字母或数字或者下划线的字符 \W 匹配不是字母，数字，下划线的字符 \s 匹配任意空白符 \S 匹配不是空白符的字符 \d 匹配数字 \D 匹配非数字的字符 \b 匹配单...
wegame显示连接服务器失败,wegame登陆失败提示错误码2怎么办？wegame错误码:2解决方案...
热门推荐
weixin_39946313的博客
08-04 1万+
登陆wegame时错误码：2应当如何解决呢？如果无法登入wegame，而又卡在登入界面，其实问题并不复杂，大部分都是因为自身的网络协议所导致的无法登入，下面由我带给大家wegame错误码2的解决方案，需要的朋友欢迎借鉴！软件名称：腾讯wegame游戏平台 v3.29.2.2230 官方免费安装版软件大小：4.01MB更新时间：2020-03-25立即下载wegame错误码:2解决方案：1、首先我们...
正则表达式__【匹配、切割、替换】【获取:Pattern & Matcher】【网页爬虫（蜘蛛）】
ie800的专栏
01-13 2037
正则表达式：即符合一定规则的表达式 作用：专门用于操作字符串 特点：用一些特定的符号来替代一些代码操作，简化书写 学习正则表达式就是在学习指定其规则的符号的使用,即如何定义规则，详细方法参见API 优点：简化字符串操作步骤 弊端：符号定义多时，正则越长，阅读性越差 具体操作功能： 1，匹配：String matches()方法；设定regex规则，只要有一处不匹配，就返回false 2，切割：String split()方法就是 将regex作为参数传入，可以定义regex实现复杂的切割 3，替换：S
黑马程序员——JAVA基础---正则表达式---概述，匹配、切割、替换、提取，网页爬虫
我的便当盒
03-23 567
-----------android培训、java培训、java学习型技术博客、期待与您交流！------------ 第一讲.概述 正则表达式：符合一定规则的表达式 用于专门操作字符串用一些特定的符号来代表一些代码操作，简化书写学习正则表达式，就是学习一些特殊符号的使用好处：简化对于字符串的复杂操作弊端：符号越多，表达式越长，阅读性差 第二讲.正则表达式的作用
继承1（覆盖、子类的实例化、抽象类、模板方法）
海角秋风
06-15 727
——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-继承的概述 多个类中存在相同属性和行为时，将这些内容抽取到 单独一个类中，那么多个类无需再定义这些属性和行 为，只要继承单独的那个类即可。 多个类可以称为子类，单独这个类称为父类或者超 类。 子类可以直接访问父类中的非私有的属性和行为。 通过extends 关键字让类与类之间产生继承关系。 clas
Java正则表达式与反射技术解析
本文主要介绍了Java中的反射、动态代理、正则表达式和注解等核心概念，重点探讨了正则表达式在字符串处理中的应用及其优缺点。 在Java编程中，由于String类提供了丰富的字符串操作方法，因此常用于存储各种数据。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值