Java基础正则表达式、反射

正则表达式
好处：简化了书写
弊端：虽然简化了书写，但是却降低了阅读性。
组：用小括号标示，每定义一个小括号，就是一个组，而且有自动编号，从1开始。

示例：
/*需求:对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);
                } catch (Exception e) {
                    // TODO: handle exception
                    System.out.println("含有非法字符");
                }
            }else{
                System.out.println("开头不能为0");
            }
        }
        else{
            System.out.println("长度错误");
        }
    }


//正则表达式方法：
    public static void checkQQ2(String qq){
        String regex = "[1-9][0-9]{4,14}";
        boolean b = qq.matches(regex);
        System.out.println(qq+":"+b);
    }

常用类属性：
字符类：
[abc]==》a、b或c
[^abc]==》任何字符除了abc
[a-z,A-Z]==》a到z或A到Z
[ad-z]==》a到z，除了b和c

预定义字符类：
. 任何一个字符
\d 数字
\D 非数字
\w 单词字符
\W 非单词字符

x? x一次或者一次也没有
x* x零次或者多次
x+ x一次或者多次
x{n} x刚好n次
x{n,} x至少n次
x{n,m} x至少n次，至多m次

正则表达式对字符串的常见操作有：
1.匹配

//  匹配：匹配手机号码
    String tel = "15800001111";
    String regex = "1[358]\\d{9}";
    boolean b = tel.matches(regex);
    System.out.println(b);

2.切割

//切割：切割字符串
    String str = "zhangsan    lisi    wangwu ";
    String[] names = str.split("(.)\\1+");
    for(String name : names)
    {
        System.out.println(name);   
    }

3.替换

//替换：将多次出现的字符统一替换成#
    String str = "dsakkkksajhhhhfdgyggg";
    str = str.replaceAll("(.)\\1+","#");
    System.out.println(str);

//替换：将多次出现的字符统一替换成单个原字符
    String str = "dsakkkksajhhhhfdgyggg";
    str = str.replaceAll("(.)\\1+","$1");
    System.out.println(str);

//替换：隐藏手机 号码
    String tel = "15800001111";
    tel = tel.replaceAll("(\\d{3})\\d{4}(\\d{4})","$1****$2");
    System.out.println(tel);

4.获取

//获取符合正则表达式的字符
    String str = "da jia hao , wo jiu shi li si";
    String regex = "\\b[a-z]{3}\\b";


    //1.将正则封装成对象
    Pattern p = Pattern.compile(str);
    //2.将正则对象获取匹配器对象
    Matcher m = p.matcher(str);
    //3.使用匹配器对象对字符串进行操作
    while(m.find())
    {
        System.out.println(m.group());
        System.out.println(m.start()+"....."+m.end());
    }

练习1：去除连续重复出现的字符

    String str= "黑黑黑黑....马马..老老老老..师师..您您您..辛..辛..苦..苦..了.了";
    //1去除字符串中的.
    str = str.replaceAll(".","");

    //2去除字符串中连续重复出现的字符
    str = str.replaceAll("(.)\\1+","$1");
    System.out.println(str);

练习2：IP地址排序

/*
     * 192.168.10.34 128.1.7.1 129.22.36.2 3.3.3.3  
     * */

    String ip_str = "192.168.10.34 128.1.7.1 129.22.36.2 3.3.3.3";
    //为了让ip能够按照字符串顺序比较，所以需要让ip每一段的数字相同，因为每一段ip地址最多
    //三位数，所以每一段中最前面最多添加两个0；
    ip_str = ip_str.replaceAll("(\\d+)","00$1");

    //让每一段ip长度相同保留，每一段保留数字三位
    ip_str = ip_str.replacrAll("0*(\\d{3})","$1");

    //将连续的在一起的ip地址切割为每一段独立的IP地址
    String[] ips = ip_str.split(" +");

    //存入TreeSet集合中排序
    TreeSet ts = new TreeSet();
    for(String ip : ips)
    {
        ts.add(ip);
    }

    //每一段ip长度相同，某一段ip的数字中最前面可能存在多余的0，所以要去除
    for(String ip1 : ts){
        System.out.println(ip1.replaceAll("0*(\\d+)", "$1"));
    }

练习3：对邮箱地址校验

String str = "aaa123@sina.com";
     String regex = "[a-zA-Z0-9]+@[a-zA-Z0-9]\\.[a-zA-Z]{2,3}";
     boolean b = str.matches(regex);
     System.out.println(b);

练习4：网页爬虫技术

//设置爬取链接
    URL url = new URL("http://192.168.1.100:8080/abc/mail.html");

    //通过流读取数据
    BufferedReader br = new BufferedReader(new InputStreamReader(url.openStream()));
    //读取源文件(爬取本地的邮箱)
//  BufferedReader br = new BufferedReader(new FileReader("c:\\mail.html"));
    //创建正则表达式
    String regex = "\\w+@\\w+(\\.\\w+)+";
    //创建正则对象
    Pattern p = Pattern.compile(regex);

    String line = null;

    List<String> list = new ArrayList<String>();
    //创建匹配器对象
    while((line = br.readLine()) != null)
    {
        Matcher m = p.matcher(line);
        while(m.find()){
            list.add(m.group());
        }
    }

Java反射
Java反射特点：

1.JAVA反射是在运行状态中，对任意一个类（class）文件都能给知道这个类的所有属性和方法

2.对于任意一个对象都能够调用它的任意一个方法和属性

3.这种动态获取信息以及动态调用对象的方法的功能成为java语言的反射机制

总结：在反射中，会将需要反射的类转为字节码文件（解剖）在字节码文件中，提供了获取内容。
例如：字段、名称、构造函数、一般函数

获取字节码文件的三种方式：

1.Object类中的getClass方法：
示例：

Person p = new Person();
Class class = p.getClass();

2.任何数据类型都具备一个静态的属性.class文件来获取其对于的Class对象，这种方法相对简单，但还是要明确用到类中的静态成员，还是不够扩展。
示例：

Class class = Person.class();

3.只要通过给定的类的字符串名称就可以获取该类，更为扩展，用Class类中的forName完成，这种方式只要有名称即可，扩展性更强。
示例：

Class class = Class.forName("cn.itcast.bean.Person")

对于创建字节码文件对象以及创建字节码文件的对应的类对象的理解：

以往学习中的创建对象思路：
new创建的时候，先格局被new创建的类的名称，寻找该类的字节码文件，并加载进内存，并创建该字节码文件的对象，并接着创建该字节码文件的对应的类对象。
示例：

cn.itcast.bean.Person p = new cn.itcast.bean.Person();

寻找创建字节码文件对象以及创建字节码文件的对应的类思路与过去创建的方式相仿：
1.寻找需要的字节码文件，并加载进内存，并创建该字节码对象
Class class = Class.forName（“new cn.itcast.bean.Person”）;

2.产生该类的对象
Object obj = class.newInstance（）;

获取字节码文件中的构造函数的方法：
//返回的是指定的构造函数
Constructor<T> getConstructot(Class<?>......paramenterTypes)

//返回的是所有的构造函数
Contructor<?>[]   getConstructot()

获取Class中的字段方法：
//只能获取共有的字段
Field getField()

//获取本类中所有字段
Field getFields（）

对私有字段的访问权限取消检查的方法：
示例：
field.setAccessible(true);//暴利访问，强制访问

设置字段属性方法：
示例：
field.set（obj，89）；

获取字段属性方法：
示例：
field.get（obj）；

获取Class中的方法:
示例：
Method method = class.get（“paramethod”，String.class，int.class）

调用方法：
示例：
Object obj = class.newInStanec（）;

method.invoke（obj，"小强",89）;

练习：

public class MainBoard implements PCI{

    public void run(){
        System.out.println("主板启动.....");
        System.out.println("主板启动成功......");
    }
    @Override
    public void open() {
        System.out.println("...open");
    }

    @Override
    public void close() {
        System.out.println("...close");
    }
    public void usePCI(PCI p){
        if(p != null){
            p.open();
            p.close();
        }
    }

public class OundCard implements PCI{

    @Override
    public void open() {
        System.out.println("...open...声卡输出");
    }

    @Override
    public void close() {
        System.out.println("...close声卡关闭");
    }

public class NetCard implements PCI{

    @Override
    public void open() {
        System.out.println("...open...网卡输出");
    }

    @Override
    public void close() {
        System.out.println("...close网卡关闭");
    }


    public static void main(String[] args) throws IOException, ClassNotFoundException, Exception, IllegalAccessException {

        MainBoard mainBoard = new MainBoard();
        mainBoard.run();

        //创建一个Properties集合（模拟后期开发中的XML配置文件）
        Properties prop = new Properties();

        //创建一个读取流读
        FileInputStream is = new FileInputStream("pci.Properties");

        //使用load()方法将将读取流读取Properties中的数据
        prop.load(is);

        //使用一个for循环，将Properties集合中读取到的数据进行字节码文件对象操作
        for (int i = 0; i < prop.size(); i++) {
            //使用setProperty方法通过键获取值
            String picName = prop.getProperty("pci"+(i+1));

            //将获取到的值，获取它的字节码文件，创建字节码文件对象
            Class clazz = Class.forName(picName);

            //通过字节码文件对象，创建向下转型的类对象
            PCI p = (PCI)clazz.newInstance();

            //将被创建出来的类对象调用MainBoard中的suePCI方法
            mainBoard.usePCI(p);

        }
        //关闭资源
        is.close();


    }

//pci.Properties中写入的数据：
pci1=p1.Text.OundCard
pci2=p1.Text.NetCard

输出的结果为：

主板启动.....
主板启动成功......
...open...声卡输出
...close声卡关闭
...open...网卡输出
...close网卡关闭