Java总结反射+正则

1.反射：Java反射机制是在运行状态中，对于任意一个类（class文件），都能够知道这个类的所有属性和方法;对于任意一个对象，都能够调用它的任意一个方法和属性，这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。PS：所谓框架就是对外提供一些接口，也就是功能扩展的标准，由实现类按照这个接口的标准去实现。框架内部如果需要操纵这些实现类的对象完成某些操作，那么只需要把这些实现类的包名+类名写在某个配置文件中，框架代码只需要读取这个配置文件，就可以获取这个实现类的字节码文件，然后利用反射技术去创建这个实现类的对象并且调用相应的方法完成一些操作。用于描述字节码的类就是Class类，创建对象，可以提取字节码文件中的内容，如字段，构造函数，一般函数，该类就可以获取字节码中的所有内容，反射依靠该类实现。
2.反射获取Class，字节码文件的方法:

public class ReflectDemo {
    public static void main(String[] args) throws Exception {
        // 获取字节码方式：
        // 方式一：通过对象获取该类的字节码
        Person p1 = new Person();
        Class clazz1 = p1.getClass();
        Person p2 = new Person();
        Class clazz2 = p2.getClass();
        System.out.println(clazz1 == clazz2);
        // 方式二：从类本身的静态成员.class获取到
        Class clazz3 = Person.class;
        // 方式三：通过给定的类名的字符串名称就可以获取该类，更为扩展
        String className = "com.itcast.Person";
        Class clazz4 = Class.forName(className);
        System.out.println(clazz4 == clazz3);
    }
}

3.通过反射获取构造函数，字段，方法：示例：

public class ReflectDemo {
    public static void main(String[] args) throws 
                ClassNotFoundException, 
                InstantiationException, 
                IllegalAccessException, 
                NoSuchMethodException, 
                SecurityException, 
                IllegalArgumentException, 
                InvocationTargetException, 
                NoSuchFieldException {
        //通过反射获取构造方法
        String className = "com.itcast.Person";
        Class clazz = Class.forName(className);
        //调用空的构造函数
        Object obj = clazz.newInstance();
        //获取带参数的构造函数
        Constructor constructor = 
            clazz.getConstructor(String.class,int.class);
        obj = constructor.newInstance("大雄",18);
        System.out.println("---------------------------------");
        //获取字节码中的字段
        Field field = clazz.getDeclaredField("name");
        field.setAccessible(true);
        System.out.println(field.get(obj));
        obj = clazz.newInstance();
        field.set(obj, "胖虎");
        Object name =  field.get(obj);
        System.out.println(name);
        System.out.println(field);
        System.out.println("-------------------------");
        //获取class中的方法
        //获取公共方法
        //方式一：
        //getMethods获取的都是公共的方法
        Method[] methods = clazz.getMethods();
        //只获取本类中所有方法 包括私有的
        methods = clazz.getDeclaredMethods();
        for(Method method:methods){
            System.out.println(method);
        }
        System.out.println("---------------------------------");
        //方式二
        Method method = clazz.getMethod("show", null);
        obj = clazz.newInstance();
        constructor = 
            clazz.getConstructor(String.class,int.class);
        obj = constructor.newInstance("孙悟空",888);
        method.invoke(obj,null);
        System.out.println("---------------------");
        //方式三：
        method = clazz.getDeclaredMethod("privateMethod", null);
        method.setAccessible(true);
        method.invoke(obj, null);
    }
}

4.反射示例：

package com.itcast;

public class Person {
    private String name;
    private int age;
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
        System.out.println("param construc...run");
    }
    public Person() {
        super();
        System.out.println("default construc....run");
    }

    public void show(){

        System.out.println(this.name
                +"----show ---   run   ----"+this.age);
    }
    private void privateMethod(){
        System.out.println("p--method--run");
    }
    public void publicMethod(String name,int age){
        System.out.println("para....pub....run...."
                                        +name+"....."+age);
    }
    public static void staticMethod(){
        System.out.println("staticMethod....run");
    }
}

package com.itcast;

public class Demo {
    public void run(){
        System.out.println("Demo.....run");
    }
    public void runAnother(Point p){
        if(p!=null)
        {
            p.draw();
            p.clean();
        }
    }
}

name1=com.itcast.Circle
name2=com.itcast.Rectangle

package com.itcast;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.util.Properties;


public class ReflectDemo{
    public static void main(String[] args) throws Exception{
        Demo demo = new Demo();
        demo.run();
        BufferedInputStream bis = 
                new BufferedInputStream(
                new FileInputStream("prop"));
        Properties prop = new Properties();
        prop.load(bis);
        for (int i = 0; i < prop.size(); i++) {
            String className = prop.getProperty("name"+(i+1));
            Class clazz = Class.forName(className);
            Point p = (Point)clazz.newInstance();
            demo.runAnother(p);
        }
        bis.close();
    }
}

5.正则：正则表达式用于操作字符串表达式，通过一些特定的符号来表现。检查QQ是否合格：

public class RegexDemo {
    //检验qq是否符合
    //1. 0不打头
    //2. 长度为5-15
    //3. 纯数字
    public static void main(String[] args) {
        String qq = "4891135486";
        String regex = "[1-9][0-9]{4,14}";
        boolean flag = qq.matches(regex);
        System.out.println(flag);
        check(qq);
    }
    //检验QQ
    public static boolean check(String qq){
        int length = qq.length();
        if(length>=5 && length <= 15){
            if(!qq.startsWith("0")){
                try{
                    long l  = Long.parseLong(qq);
                    System.out.println(l+"---QQ正确");
                    return true;
                }catch(NumberFormatException e){
                    System.out.println("不是纯数字");
                    return false;
                }
            }else{
                System.out.println("不能用0打头");
                return false;
            }
        }else{
            System.out.println("长度超标");
            return false;
        }
    }
}

6.正则表达式常用构造摘要：字符类：[abc] a/b/c [^abc] 除abc外的任意字符 [a-zA-Z] a-z或A-Z两头的字母包括在内
7.预定义字符类： . 任何字符—– \d 数字：[0-9]—–\D 非数字：[^0-9]—–\S 非空白字符：[^\s]—–\s 空白字符：[\t\n\x0b\f\r]—–\w单词字符：[a-zA-Z_0-9]—–\W 非单词字符：[^\w].
8.Greedy数量词：X? X 一次或一次也没有 X* X，零次或多次 X+ X,一次或多次 X{n} X 恰好n次 X{n,} X 至少n次 X{n,m} X至少n次，但是不超过m次。
9.边界匹配器 ^行的开头 $行的结尾 \b 单词边界 \B非单词边界 \A 输入的开头 \G 上一个匹配的结尾 \Z 输入的结尾，仅用于最后的结尾符（如果有的话） \z 输入的结尾
10.正则示例：

public class RegexDemo{
    public static void main(String[] args) {
        String str = "aoob";
        String regex = "ao?b";
        boolean flag = str.matches(regex);
        System.out.println(flag);
        regex = "ao+b";
        flag = str.matches(regex);
        System.out.println(flag);
        str = "ab";
        regex = "ao+b";
        flag = str.matches(regex);
        System.out.println(flag);
        regex = "ao*b";
        flag = str.matches(regex);
        System.out.println(flag);
        str = "aoooob";
        regex = "ao{4,}b";
        flag = str.matches(regex);
        System.out.println(flag);
        regex = "ao{4,6}b";
        flag = str.matches(regex);
        System.out.println(flag);
    }
}

11.正则表达式常见功能：匹配，切割，替换，获取。正则的匹配，切割常用的就是String类的matches()方法，split()方法。在表达式（（A）（B（C）））中，存在四个这样的组：1.（（A）（B（C）））2.\A 3.（B（C）） 4.（C） 组零始终代表整个表达式。示例：

public class RegexDemo {
    public static void main(String[] args) {
        // String tel = "15800001110";
        String str = "15011111111";
        String regex = "1[358]\\b[0-9]{9}\\b";
        boolean flag = str.matches(regex);
        System.out.println(flag);
        System.out.println("-------------------------");
        str = "zhangsan xiaoqiang zhaoliu";
        String[] names = str.split(" +");
        for (String name : names)
            System.out.println(name);
        System.out.println("-------------------------");
        str = "zhangsan.xiaoqiang.zhaoliu";
        names = str.split("\\.");
        for (String name : names)
            System.out.println(name);
        System.out.println("-------------------------");
        str = "zhangsanttttxiaoqiangmmmmmzhaoliu";
        names = str.split("(.)\\1+");
        for (String name : names)
            System.out.println(name);
        System.out.println("-------------------------");
        // 替换
        str = str.replaceAll("(.)\\1+", "$1");
        System.out.println(str);
        System.out.println("-------------------------");
        str = "15800001111";
        str = str.replaceAll("(\\d{3})(\\d{4})(\\d{4})", "$1****$2");
        System.out.println(str);
        System.out.println("-------------------------");
        // 演示获取
        // 将正则规则进行对象的封装
        str = "da jia hao,ming tian bu fang jia";
        regex = "\\b[a-z]{3}\\b";
        //将正则封装成对象
        Pattern p = Pattern.compile(regex);
        //通过正则对象获取匹配器对象
        Matcher m = p.matcher(str);
        //使用Matcher对象的方法对字符串进行操作
        //查找
        while(m.find()){
            //获取匹配的子序列
            System.out.println(m.group());
            System.out.println(m.start()+":"+m.end());
        }
        //Pattern类为正则表达式的编译表示形式，指定为字符串的正则表达式必须先被编译为此类的实例
        //然后 可将可到的模式用于创建Matcher对象，依照正则表达式，该对象可以与任意字符序列匹配
        //执行匹配所涉及的所有状态都驻留在匹配器中，所以多个匹配器可以共享同意模式
    }
}

12.正则练习：

public class RegexDemo {
    public static void main(String[] args) {
        // 去口吃
        String str = "我我...我我...我我我我...要要要要...要要要要...学学学学学...学学编编...编编编编..编..编...程程...程程程";
        str = str.replaceAll("(\\.)+", "");
        System.out.println(str);
        str = str.replaceAll("(.)\\1+", "$1");
        System.out.println(str);
        // IP地址排序
        String IP = "192.168.10.34 127.0.0.1 3.3.3.3 105.70.11.55";
        IP = IP.replaceAll("(\\d+)", "00$1");
        System.out.println(IP);
        IP = IP.replaceAll("0*(\\d{3})", "$1");
        System.out.println(IP);
        String[] IPs = IP.split(" ");
        TreeSet<String> set = new TreeSet<String>();
        for(String ip:IPs){
            set.add(ip);
        }
        for(String ip:set){
            System.out.println(ip.replaceAll("0*(\\d+)", "$1"));
        }
        //对邮件地址校检
        String mail = "abc1@sina.com";
        String regex = "[a-zA-Z0-9_]+@[a-zA-Z0-9]+(\\.[A-Za-z]{1,3})+";
        boolean flag = mail.matches(regex);
        System.out.println(flag);
    }
}

13.爬虫示例：

public class RegexDemo{
    public static void main(String[] args) throws Exception{
        //网页爬虫：程序用于在互联网中获取符合指定规则的数据
        //爬去邮箱地址
        BufferedReader br = 
                new BufferedReader(new FileReader(""));
        //设置规则
        String mail_regex = "\\w+@\\w+(\\.\\w+)+";
        List<String> list = new ArrayList<String>();
        Pattern pattern = Pattern.compile(mail_regex);
        Matcher matcher = null;
        String htmlStr = null;
        while((htmlStr = br.readLine())!=null){
            matcher = pattern.matcher(htmlStr);
            while(matcher.find()){
                list.add(matcher.group());
            }
        }
        for(String string:list){
            System.out.println(string);
        }
        //从互联网上爬去邮箱
        URL url = new URL("www.baidu.com");
        br = new BufferedReader(
                new InputStreamReader(url.openStream()));
        while((htmlStr = br.readLine())!=null){
            matcher = pattern.matcher(htmlStr);
            while(matcher.find()){
                list.add(matcher.group());
            }
        }
        for(String string:list){
            System.out.println(string);
        }
    }
}