3、Constructor

获取构造方法：

1）得到这个类的所有构造方法：如得到上面示例中Person类的所有构造方法

Constructor[] cons = Class.forName(“myReflect.Person”).getConstructors();

2）获取某一个构造方法：

Constructor con=Person.class.getConstructor(String.class,int.class);

括号中是参数的字节码文件对象。

import java.lang.reflect.Constructor;  
import java.lang.reflect.Field;  
  
public class ReflectField {  
    public static void main(String[] args) {  
        Class clazz = Human.class;// 获取字节码文件对象  
  
        // 获取所有的成员变量  
        // Field[] fields = c.getFields();  
        Field[] fields = clazz.getDeclaredFields();  
        for (Field field : fields) {  
            System.out.println(field);  
            /*输出：  
             * private java.lang.String Human.name  
             * private int Human.age 
             * private java.lang.String Human.address 
             */  
        }  
  
        // 获取单个的成员变量并赋值  
        try {  
            // 通过带参构造方法创建对象  
            Constructor con = clazz.getConstructor(String.class,int.class,String.class);// 这个是公共构造方法  
            Object obj = con.newInstance("天下第一",22,"中国·武汉");  
  
            // 获取address并对其赋值  
            // Field addressField = clazz.getField("address");//NoSuchFieldException  
            Field addressField = clazz.getDeclaredField("address");  
            // public void set(Object obj,Object value)  
            // 将指定对象变量上此 Field 对象表示的字段设置为指定的新值。  
            addressField.setAccessible(true);// 因为IllegalAccessException，所有要暴力访问  
            addressField.set(obj,"武汉"); // 给obj对象的addressField字段设置值为"武汉"  
  
            // 获取name并对其赋值  
            Field nameField = clazz.getDeclaredField("name");  
            nameField.setAccessible(true);// 因为IllegalAccessException，所有要暴力访问  
            nameField.set(obj,"night");  
  
            // 获取age并对其赋值  
            Field ageField = clazz.getDeclaredField("age");  
            ageField.setAccessible(true);  
            ageField.set(obj,22);  
  
            ((Human) obj).show();// :22——武汉 
  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }  
  
}  
class Human {  
    private String name;  
    private int age = 0;  
    private String address = "未填写";  
  
    private Human(String name) {  
        this.name = name;  
    }  
  
    public Human(String name,int age,String address) {  
        this.name = name;  
        this.age = age;  
        this.address = address;  
    }  
  
    public void show() {  
        System.out.println(name + ":" + age + "——" + address);  
    }  
}  

正则即是正确的规则。

正则表达式通过一些特殊的符号来操作字符串数据，可以简化书写，不过定义太多也不便于阅读。

五、正则表达式的常见操作：

1，匹配：其实用的就是String类中的matches方法。
String reg = “[1-9][0-9]{4,14}”;
boolean b = qq.matches(reg);//将正则和字符串关联对字符串进行匹配。
2，切割：其实用的就是String类中的split方法。
3，替换：其实用的就是String类中的replaceAll();
4，获取：
1），先要将正则表达式编译成正则对象。使用的是Pattern中静态方法 compile(regex);
2），通过Pattern对象获取Matcher对象。
Pattern用于描述正则表达式，可以对正则表达式进行解析。
而将规则操作字符串，需要从新封装到匹配器对象Matcher中。
然后使用Matcher对象的方法来操作字符串。
如何获取匹配器对象呢？
通过Pattern对象中的matcher方法。该方法可以正则规则和字符串想关联。并返回匹配器对象。
3），使用Matcher对象中的方法即可对字符串进行各种正则操作。

5、组和捕获

捕获组可以通过从左到右计算其开括号来编号。例如，在表达式((A)(B(C)))中，存在四个这样的组：

1 ((A)(B(C)))

2 \A

3 (B(C))

4 (C)

组零始终代表整个表达式。在替换中常用$匹配组的内容。

import java.util.regex.*;  

public class Regex    
{  
    public static void sop(Object obj)  
    {  
        System.out.println(obj);  
    }  
    public static void main(String[] args)   
    {  
        functionDemo_1();  
        sop("---------------------------");  
        functionDemo_2();  
        sop("---------------------------");  
        functionDemo_3();  
        sop("---------------------------");  
        functionDemo_4();  
        sop("---------------------------");  
        functionDemo_5();  
        sop("---------------------------");  
        functionDemo_6();  
        sop("---------------------------");  
    }  
  
    public static void functionDemo_1()  
    {  
        //匹配手机号码  
        String tel = "15072472927";  
        String regex = "1[358]\\d{9}";  
  
        Boolean b = tel.matches(regex);  
        sop(tel+":"+b);  
    }  
    public static void functionDemo_2()  
    {  
        //演示切割   
        String tel = "zhangsan   lisi             wangwu";  
        String[] gex = tel.split("\\s+");  
  
        for(String str : gex)  
        {  
            sop(str);  
        }  
    }  
    public static void functionDemo_3()  
    {  
        //演示切割   
        //(.)表示一组，\\1+表示与第1组相同的出现1次以上  
        String tel = "zhangsanttttttlisimmmmmmmmmmmwangwu";  
        String[] gex = tel.split("(.)\\1+");  
  
        for(String str : gex)  
        {  
            sop(str);  
        }  
          
    }  
    /* 
     * 演示替换 
     */  
    public static void functionDemo_4()  
    {  
        //$表示前一个参数的第一组  
        String tel = "zhangsanttttttlisimmmmmmmmmmmwangwu";  
        String gex = tel.replaceAll("(.)\\1+","$1");  
  
            sop(gex);  
          
          
    }  
    public static void functionDemo_5()  
    {  
           
        String tel = "15072472927";  
        tel = tel.replaceAll("(\\d{3})(\\d{4})(\\d{4})","$1****$3");  
  
            sop(tel);  
          
          
    }  
     /* 
     * 演示获取 
     * 将正则规则进行对象的封装。 
     * Pattern p = Pattern.compile("a*b"); 
     * 通过正则对象的matcher方法字符串相关联。获取要对字符串操作的匹配器对象Matcher。 
     * boolean b = m.matches(); 
     */  
    public static void functionDemo_6()  
    {  
         //打印三个字符的单词  
         // \\b表示单词边界  
        String tel = "da jia hao,ming tian bu fang jia";  
          
        //1. 将正则封装成对象  
        String regex = "\\b[a-z]{3}\\b";  
        Pattern p = Pattern.compile(regex);  
          
        //2. 通过正则对象获取匹配器对象  
        Matcher m = p.matcher(tel);  
  
        //使用Matcher对象的方法对字符串进行操作。  
        //既然要获取三个字母组成的单词。  
        //查找：find();  
        while (m.find())  
        {  
            sop(m.group());//获取匹配的子序列  
            sop(m.start()+":"+m.end());//字符在字符串中的索引位置  
        }  
          
          
    }  
}

/** 
 * @author LinP 
 *  网络爬虫 
 * 网页爬虫：其实就是一个程序用于在互联网中获取符合指定规则的数据。 
 * 爬取需要获取的信息。 
 */  
public class RegexDemo {  
  
    /** 
     * @param args 
     * @throws IOException  
     */  
    public static void main(String[] args) throws IOException {  
        // TODO 自动生成的方法存根  
        //getMailAddress();  
        getMailAddressByWeb();  
    }  
      
    private static void getMailAddressByWeb() throws IOException {  
        // TODO 自动生成的方法存根  
        URL url = new URL("http://bbs.itheima.com/thread-200600-1-1.html");  
          
        BufferedReader bufr = new BufferedReader(new InputStreamReader  
                (url.openStream()));  
        Pattern p = Pattern.compile("\\w+(\\.\\w+)+");  
          
        String line = null;  
        while((line = bufr.readLine())!=null){  
            Matcher m = p.matcher(line);  
            while(m.find()){  
  
                System.out.println(m.group());  
            }  
        }  
  
    }  
  
    private static void getMailAddress() throws IOException {  
        //1. 读取源文件。  
        BufferedReader bufr = new BufferedReader(new FileReader  
                ("C:/Users/LinP/Desktop/gaoxin/3-反射/3-反射.html"));  
          
        //2. 对读取的数据进行规则的匹配。从中获取符合规则的数据。  
        Pattern p = Pattern.compile("\\b\\.[a-zA-Z]{6}\\b");  
          
        ArrayList<String> list = new ArrayList<String>();  
          
        String line = null;  
        while((line = bufr.readLine())!=null){  
            Matcher m = p.matcher(line);  
            while(m.find()){  
                System.out.println(m.group());  
            }  
        }         
    }  
}