Java语言基础-反射机制、正则表达式

反射机制

反射机制是在运行状态中，对于任意一个类，都能知道这个类（class文件）的所有属性和方法。
对于任意一个对象，都能调用它的任意一个方法和属性。
这种动态获取信息以及动态调用对象的方法的功能称为Java语言的反射机制。

简单来说，动态获取类中的信息，就是Java的反射机制。
可以理解为对类的解剖。

Tomcat
提供了处理请求和应答的方式。
因为具体的处理动作不同，所以对外提供了接口，由开发者来实现具体的请求和应答处理。

Class类可以获取字节码文件中的所有内容，反射就是依靠该类来完成的。
想要对一个类文件进行解剖，只要获取到该类的字节码文件即可。

获取类的字节码文件：

package cn.itcast.reflect.demo;

import cn.itcast.bean.Person;

/*
 * 要想对字节码文件进行解剖，必须要有字节码文件对象
 */
public class ReflectDemo {

    /**
     * @param args
     * @throws ClassNotFoundException 
     */
    public static void main(String[] args) throws ClassNotFoundException {
        
//        getClassObject_1();
//        getClassObject_2();
        getClassObject_3();
        
    }
    /*
     * 方式三：（重点）
     * 只要通过给定的类的字符串名称，就可以获取该类，更为扩展。
     * 可以用Class类中的方法完成。
     * 该方法就是forName。
     * 各种方式只要有名称即可，更为方便，扩展性更强。
     */
    public static void getClassObject_3() throws ClassNotFoundException {
        String className="cn.itcast.bean.Person";
        
        Class clazz=Class.forName(className);
        
        System.out.println(clazz);
    }
    
    /*
     * 方式二：
     * 任何数据类型都具有一个静态的属性.class来获取其对应的Class对象。
     * 不需要构造函数。
     * 相对简单，但是还是需要明确用到类中的静态成员。
     * 不够扩展
     */
    public static void getClassObject_2() {
        Class clazz=Person.class;
        
        Class clazz1=Person.class;
        System.out.println(clazz==clazz1);

    }

    /*
     * 获取字节码对象的方式：
     * 方式一：
     * Object类中的getClass方法
     * 想要用这种方式，必须要明确具体的类，并创建对象。
     */
    public static void getClassObject_1(){
        Person p=new Person();
        Class clazz=p.getClass();
        
        Person p1=new Person();
        Class clazz1=p1.getClass();
        
        System.out.println(clazz==clazz1);
    }

}

获取Class中的构造函数：

package cn.itcast.reflect.demo;

import java.lang.reflect.Constructor;

public class ReflectDemo2 {

    /**
     * @param args
     * @throws Exception 
     */
    public static void main(String[] args) throws Exception {

        // createNewObject();
        createNewObject_2();
    }

    public static void createNewObject_2() throws Exception {

        // cn.itcast.bean.Person p = new cn.itcast.bean.Person("小强",39);
        
        /*
         * 当要获取指定名称对应类中的所体现的对象时，
         * 而该对象初始化不使用空参数构造函数
         * 既然是通过指定的构造函数进行兑现的初始化，
         * 应先获取到该构造函数。
         * 通过字节码文件即可完成
         * 该方法是：getConstructor(parameterTypes)
         */
        String name = "cn.itcast.bean.Person";
        Class clazz = Class.forName(name);
        //获取到了指定的构造函数对象
        Constructor constructor=clazz.getConstructor(String.class,int.class);
        //通过该构造器对象的newInstance方法进行对象的初始化
        Object obj=constructor.newInstance("小明",38);
    }

    public static void createNewObject() throws ClassNotFoundException,
            InstantiationException, IllegalAccessException {

        // 早期：new的时候，先根据被new的类的名称查询该类的字节码文件，并加载进内存，并创建该字节码文件对象，然后创建该字节码文件对应的Person对象
        cn.itcast.bean.Person p = new cn.itcast.bean.Person();

        // 现在：
        String name = "cn.itcast.bean.Person";
        // 找寻该名称的类文件，并加载进内存，并产生Class对象
        Class clazz = Class.forName(name);
        // 如何产生该类的对象
        Object obj = clazz.newInstance();// 创建新实例
    }

}

获取Class中的字段示例：
public class AccessibleObjectextends Object implements AnnotatedElement
AccessibleObject 类是 Field、Method 和 Constructor 对象的基类。它提供了将反射的对象标记为在使用时取消默认 Java 语言访问控制检查的能力。

package cn.itcast.reflect.demo;

import java.lang.reflect.Field;

public class ReflectDemo3 {

    /**
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
        getFieldDemo();
    }

    /*
     * 获取字节码文件中的字段
     */
    public static void getFieldDemo() throws Exception {

        Class clazz = Class.forName("cn.itcast.bean.Person");

        // Field field=clazz.getField("age");//该方法只能获取到public的字段

        Field field=clazz.getDeclaredField("age");//只能获取本类中的所有字段（包含私有）
        //取消字段的访问权限检查，暴力访问
        field.setAccessible(true);
        
        Object obj=clazz.newInstance();
        
        field.set(obj, 90);
        Object o=field.get(obj);
        
        System.out.println(o);
    }

}

获取Class中的方法：

package cn.itcast.reflect.demo;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

import cn.itcast.bean.Person;

public class ReflectDemo4 {

    /**
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {

        // getMethodDemo();
        // getMethodDemo_2();
        getMethodDemo_3();
    }

    public static void getMethodDemo_3() throws Exception {
        Class clazz = Class.forName("cn.itcast.bean.Person");

        Method method = clazz.getMethod("paramMethod", String.class, int.class);

        Object obj = clazz.newInstance();
        method.invoke(obj, "小强", 39);

    }

    public static void getMethodDemo_2() throws Exception {

        Class clazz = Class.forName("cn.itcast.bean.Person");

        Method method = clazz.getMethod("show", null);// 获取空参数一般方法
        // Person p=new Person();
        // p.show();

        // Object obj=clazz.newInstance();
        Constructor constructor = clazz.getConstructor(String.class, int.class);
        Object obj = constructor.newInstance("小明", 37);
        method.invoke(obj, null);
    }

    /*
     * 获取指定Class中的公共函数
     */
    public static void getMethodDemo() throws Exception {

        Class clazz = Class.forName("cn.itcast.bean.Person");

        Method[] methods = clazz.getMethods();// 获取的都是公有的方法
        methods = clazz.getDeclaredMethods();// 只获取本类中所有方法（包括私有）

        for (Method method : methods) {
            System.out.println(method);
        }

    }

}

package cn.itcast.bean;

public class Person {

    private int age;
    private String name;

    public Person(String name, int age ) {
        super();
        this.age = age;
        this.name = name;
        System.out.println("person param run..."+this.name+":"+this.age);
    }
    public Person() {
        super();
        System.out.println("person run");
    }
    
    public void show(){
        System.out.println(name+"...show run..."+age);
    }
    
    private void privateMethod(){
        System.out.println("private method run");
    }
    
    public void paramMethod(String str,int num){
        System.out.println("paramMethod run......"+str+":"+num);
    }
    
    public static void staticMethod(){
        System.out.println("staticMethod run");
    }
}

反射练习：

package cn.itcast.reflect.test;

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

/*
 * 电脑运行
 */
public class ReflectTest {

    /**
     * @param args
     * @throws Exception 
     */
    public static void main(String[] args) throws Exception {

        MainBoard mb=new MainBoard();
        mb.run();
        
        //每次添加设备都需要修改代码，传递新创建的对象
//        mb.usePCI(new SoundCard());//新增SoundCard，需要修改程序
        
        
        //不修改代码，就能够完成以上动作
        //不使用new，而是直接获取class文件，在内部实现创建对象的动作
        File configFile=new File("pci.properties");
        
        Properties prop=new Properties();
        FileInputStream fis=new FileInputStream(configFile);
        
        prop.load(fis);
        
        for(int x=0;x<prop.size();x++){
            
            String pciName=prop.getProperty("pci"+(x+1));
            
            Class clazz=Class.forName(pciName);//用Class去加载这个pci子类
            
            PCI p=(PCI) clazz.newInstance();//创建的对象肯定是PCI的子类，可以直接将创建的对象类型强转为PCI
            
            mb.usePCI(p);
        }
        fis.close();
        
        
    }
}

package cn.itcast.reflect.test;

public class MainBoard {

    public void run() {
        System.out.println("main board run");
    }

    public void usePCI(PCI p) {//多态，提高扩展性
        if (p != null) {
            p.open();
            p.close();
        }
    }
}


package cn.itcast.reflect.test;

public interface PCI {
    
    public void open();
    public void close();
}
package cn.itcast.reflect.test;

public class SoundCard implements PCI{

    public void open(){
        System.out.println("sound open");
    }
    public void close(){
        System.out.println("sound close");
    }

}
package cn.itcast.reflect.test;

public class NetCard implements PCI{

    @Override
    public void open() {
        System.out.println("net open");
    }

    @Override
    public void close() {
        System.out.println("net close");
    }
}

pci.properties
pci1=cn.itcast.reflect.test.SoundCard
pci2=cn.itcast.reflect.test.NetCard

正则表达式
正则表达式用于操作字符串数据；
通过特定的符号来体现；
正则表达式虽然简化了书写，但是阅读性变差了。

package cn.itcast.regex.demo;

public class RegexDemo {

    /**
     * @param args
     */
    public static void main(String[] args) {

        String qq = "123456789";
        // checkQQ(qq);

        String regex = "[1-9][0-9]{4,14}";// 正则表达式
        // String regex="[1-9]\\d{4,14}";//正则表达式

        // boolean b=qq.matches(regex);
        // System.out.println(qq+":"+b);

        String str = "aoob";
        String reg = "ao+b";// o有一次或多次
        boolean b = str.matches(reg);
        System.out.println(b);

    }

    /*
     * 需求：定义一个功能对QQ号进行校验
     * 要求：长度5-15位；只能是数字；0不能开头
     */
    public static void checkQQ(String qq) {
        int len = qq.length();
        if (len >= 5 && len <= 15) {
            if (!qq.startsWith("0")) {
                try {
                    long l = Long.parseLong(qq);
                    System.out.println(qq + "正确");
                } catch (NumberFormatException e) {
                    System.out.println(qq + "含有非法字符");
                }
            } else {
                System.out.println(qq + "不能0开头");
            }
        } else {
            System.out.println("长度错误");
        }
    }

}

正则表达式对字符串的常见操作
组和捕获
捕获组可以通过从左到右计算其开括号来编号。例如，在表达式 ((A)(B(C))) 中，存在四个这样的组：

1     ((A)(B(C)))
2     \A
3     (B(C))
4     (C)

组零始终代表整个表达式。

之所以这样命名捕获组是因为在匹配中，保存了与这些组匹配的输入序列的每个子序列。捕获的子序列稍后可以通过 Back 引用在表达式中使用，也可以在匹配操作完成后从匹配器获取。

与组关联的捕获输入始终是与组最近匹配的子序列。如果由于量化的缘故再次计算了组，则在第二次计算失败时将保留其以前捕获的值（如果有的话）例如，将字符串 "aba" 与表达式 (a(b)?)+ 相匹配，会将第二组设置为 "b"。在每个匹配的开头，所有捕获的输入都会被丢弃。

以 (?) 开头的组是纯的非捕获 组，它不捕获文本，也不针对组合计进行计数。

public final class Patternextends Object implements Serializable
正则表达式的编译表示形式。
指定为字符串的正则表达式必须首先被编译为此类的实例（将正则表达式封装为对象）。然后，可将得到的模式用于创建 Matcher （匹配）对象，依照正则表达式，该对象可以与任意字符序列匹配。执行匹配所涉及的所有状态都驻留在匹配器中，所以多个匹配器可以共享同一模式。
因此，典型的调用顺序是
Pattern p = Pattern.compile("a*b");
Matcher m = p.matcher("aaaaab");
boolean b = m.matches();

package cn.itcast.regex.demo;

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

public class RegexDemo2 {

    /**
     * @param args
     */
    public static void main(String[] args) {

        /*
         * 正则表达式对字符串的常见操作
         * 1.匹配
         * 使用的是String类中matchs方法；
         * 
         * 2.切割
         * 使用的是String类中的split方法；
         * 
         * 3.替换
         * 使用的是String类中的replaceAll方法；
         * 
         * 4.获取
         * 将正则规则进行对象的封装；
         * Pattern p = Pattern.compile("a*b");
         * 通过正则对象的matcher方法字符串相关联，获取要对字符串操作的匹配器对象Matcher
         * Matcher m = p.matcher("aaaaab");
         * 通过Matcher匹配器对象的方法对字符串进行操作
         * boolean b = m.matches();
         */
        // functionDemo1();
        // functionDemo2();
        // functionDemo3();
        functionDemo4();
    }

    /*
     * 获取示例
     */
    public static void functionDemo4() {
        String str = "da jia hao,ming tian bu fang jia!";

        String regex = "\\b[a-z]{3}\\b";// \\b-单词边界，否则会出现jia hao    min的情况

        // 1.将正则封装成对象
        Pattern p = Pattern.compile(regex);
        // 2.通过正则对象获取匹配器对象
        Matcher m = p.matcher(str);

        // 使用Matcher对象的方法对字符串进行操作
        // 既然要获取三个字母组成的单词
        // 进行查找 find()方法
        System.out.println(str);
        while (m.find()) {
            System.out.println(m.group());// 获取匹配器的子序列
            
            System.out.println(m.start()+":"+m.end());//输出开始和结束的位置
        }

    }

    /*
     * 替换示例
     */
    public static void functionDemo3() {

        String str = "zhangsantttxiaoqiangmmmmmzhaoliu";

        // str=str.replaceAll("(.)\\1+", "#");//将叠词替换为#

        str = str.replaceAll("(.)\\1+", "$1");// 将叠词替换为一个字母;$1,获取第一个参数中的第一组
        System.out.println(str);

        String tel = "15812345678";// 158****5678
        tel = tel.replaceAll("(\\d{3})\\d{4}(\\d{4})", "$1****$2");
        System.out.println(tel);
    }

    /*
     * 切割示例
     */
    public static void functionDemo2() {
        // String str="zhangsan        xiaoqiang    zhaoliu";
        // String[] names=str.split(" +");//空格出现一次或多次

        // String str="zhangsan.xiaoqiang.zhaoliu";
        // String[] names=str.split("\\.");

        String str = "zhangsantttxiaoqiangmmmmmzhaoliu";// 按ttt，mmmmm切割
        // (X) X，作为捕获组 ;\n 任何匹配的 nth 捕获组
        // 组((A) (B(C)) 最外层括号为第一组，次外层为第二组，以此类推；无括号，则为第0组
        String[] names = str.split("(.)\\1+");// 第一位是任意字符,对任意字符进行复用
        for (String name : names) {
            System.out.println(name);
        }
    }

    /*
     * 匹配示例
     */
    public static void functionDemo1() {
        // 匹配手机号码是否正确
        String tel = "15800001111";
        // String regex="1[358][0-9]{9}";
        String regex = "1[358]\\d{9}";

        boolean b = tel.matches(regex);
        System.out.println(tel + ":" + b);
    }

}

正则表达式-练习：

package cn.itcast.regex.test;

import java.util.TreeSet;

public class RegexTest {

    /**
     * @param args
     */
    public static void main(String[] args) {
        
        /*
         * 1.治疗口吃：我...我我要要...要要..要学...学...编编编程...程程...程程
         * 2.对ip地址排序
         * 3.对邮件地址校验
         */
//        test_1();
//        test_2();
        test_3();
    }
    
    /*
     * 邮箱地址校验
     */
    public static void test_3() {
        
        String mail="abc1@sian.com.cn";
        
        String regex="[a-zA-Z0-9_]+@[a-zA-Z0-9]+(\\.[a-zA-Z]{2,3})+";//(\\.[a-zA-Z]{2,3})+,类似于.com,.cn的组，存在一次或者多次
        regex="\\w+@a\\w+(\\.\\w+)+";//笼统式匹配
        
        boolean b=mail.matches(regex);
        
        System.out.println(mail+":"+b);
        
    }

    /*
     * ip地址排序
     * 192.168.10.34    127.0.0.1    3.3.3.3    105.70.11.55
     */
    public static void test_2() {
        
        String ip_str="192.168.10.34  127.0.0.1 3.3.3.3    105.70.11.55";
        
        //1.为了让ip可以按字符串顺序比较，只要让ip的每一段位数相同，补零
        //按照每一位所需最多的0的个数进行补充；每一段都加2个0；
        
        ip_str=ip_str.replaceAll("(\\d+)", "00$1");
//        System.out.println(ip_str);//00192.00168.0010.0034  00127.000.000.001 003.003.003.003    00105.0070.0011.0055
        
        //2.每一段保留三位数字
        ip_str=ip_str.replaceAll("0*(\\d{3})", "$1");
//        System.out.println(ip_str);//192.168.010.034  127.000.000.001 003.003.003.003    105.070.011.055
        
        //切割ip地址
        String[] ips=ip_str.split(" +");
        TreeSet<String> ts=new TreeSet<String>();
        
        for(String ip:ips){
            ts.add(ip);
        }
        
        for(String ip:ts){
            System.out.println(ip.replaceAll("0*(\\d+)", "$1"));
        }
    }
    /*
     * 治口吃
     */
    public static void test_1(){
        
        String str="我...我我要要...要要..要学...学...编编编程...程程...程程";
        
        //1.将字符串中的 “.” 去掉，使用替换
        str=str.replaceAll("\\.+", "");
        //2.替换叠词
        str=str.replaceAll("(.)\\1+", "$1");
        System.out.println(str);
    }

}

正则表达式-练习-爬虫

package cn.itcast.regex.test;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/*
 * 网页爬虫：其实是一个用于在互联网中获取符合指定规则数据的程序
 * 
 * 爬取邮箱地址
 */
public class RegexTest2 {

    /**
     * @param args
     * @throws IOException
     */
    public static void main(String[] args) throws IOException {

        // List<String> list=getMail();
        List<String> list = getMailByWeb();
        for (String mail : list) {
            System.out.println(mail);
        }

    }

    public static List<String> getMailByWeb() throws IOException {

        // 1.读取源文件
        URL url=new URL("http://iask.sina.com.cn/b/1005465.html");
        BufferedReader bufIn=new BufferedReader(new InputStreamReader(url.openStream()));

        // 2.对读取的数据进行规则的匹配，从中获取符合规则的数据
        String mail_regex = "\\w+@\\w+(\\.\\w+)+";

        List<String> list = new ArrayList<String>();

        Pattern p = Pattern.compile(mail_regex);

        String line = null;
        while ((line = bufIn.readLine()) != null) {
            Matcher m = p.matcher(line);
            while (m.find()) {
                // 3.将符合规则的数据存储到集合中
                list.add(m.group());
            }
        }
        bufIn.close();
        return list;
    }

    public static List<String> getMail() throws IOException {
        // 1.读取源文件
        BufferedReader bufr = new BufferedReader(
                new FileReader("c:\\mail.html"));

        // 2.对读取的数据进行规则的匹配，从中获取符合规则的数据
        String mail_regex = "\\w+@\\w+(\\.\\w+)+";

        List<String> list = new ArrayList<String>();

        Pattern p = Pattern.compile(mail_regex);

        String line = null;
        while ((line = bufr.readLine()) != null) {
            Matcher m = p.matcher(line);
            while (m.find()) {
                // 3.将符合规则的数据存储到集合中
                list.add(m.group());
            }
        }
        bufr.close();
        return list;
    }

}