正则表达式

　　在开发中正则一定会使用，但是正则的使用难易也是看实际的开发情况，如果你只是从事于项目的功能实现，那么对于正则并不需要做过多深入的了解，如果你现在要做一些特别复杂的符号匹配操作，那么就需要通过正则表达式更深入的内容来完成了。

1.认识正则

　　要求判断一个字符串是否全部由数字组成，最初的实现是采用了拆分为字符数组，而后依次判断字符的方式实现.

package cn.Tony.demo;
public class TestDemo{
    public static void main(String[] args) throws Exception {
        System.out.println(isNumber("adc"));
        System.out.println(isNumber("123"));
    }
    public static boolean isNumber(String str) {
        char[] data=str.toCharArray();
        for(int x=0;x<data.length;x++) {
            if(data[x]<'0'||data[x]>'9') {
                return false;
            }
        }
        return true;
    }
} 

　　不方便，可以使用正则的方式处理

范例：用正则来进行验证

package cn.Tony.demo;
public class TestDemo{
    public static void main(String[] args) throws Exception {
        System.out.println("adc".matches("\\d+"));
        System.out.println("123".matches("\\d+"));
    }
} 

　　在程序中见到的“\\d+”符号就属于正则表达式的定义范畴，而有了正则表达式针对于字符串的验证就会非常的简单，

　　正则表达式最早从Linux下发展的（Perl），在JDK1.4之前正则没有引入到开发包中，当时要想使用正则就必须进行其他开发包的配置。JDK1.4开始java中提供了新的开发包：java.util.regex 如果你要想清楚正则的原理，建议好好数学 《离散数学》。

2.正则标记（重点）

　　如果想研究正则，那么首先要研究的就是正则标记，所有的正则标记都在java.util.regex.Pattern类中，进行了定义

1.【单个】描述某一个字符

　　x：表示由x（字符）组成

　　\\：匹配一个“\”

　　\t:描述的是制表符

　　\n:表示换行

2.【单个】描述一个范围：

　　[abc]:表示可能是字母a，b，c的任意一个

　　[^abc]:表示不是字母a，b,c的任意一个

　　[0-9]:"‘0’~‘9’",有数字组成

　　[a-zA-Z]:由字母组成，大小写任意

3.【单个】简化表达式：

　　“.”：表示任意的一位字符

　　“\d”:等价于“[0-9]”表示任意一位的数字

　　“\D”:等价于“[^0-9]”表示任意的非数字

　　“\s”:表示是一位空格，可能是空格\t \n

　　“\S”:表示不是一位空格

　　“\w”:等价于“[a-zA-Z0-9]”,表示字母数字下划线所组成

　　“\W”:等价于“[^a-zA-Z0-p]”

4.边界匹配（java用不到）

　　^:表示正则的开始

　　$:表示正则的结束

5.数量表达式。在之前所有的符号编写几次就出现几次，

　　正则？：表示该匹配出现0次或者1次

　　正则+：表示该匹配出现一次或者多次　　

　　正则*:表示该匹配出现0次 1次或多次

　　正则{n}:表示该匹配出现n次

　　正则{n,}:表示该匹配出现n次以上，包括n次

　　正则{n,m}:表示出现n~m次

6.逻辑匹配

　　正则A正则B：就表示与的关系，在第一个匹配之后立即匹配第二个；

　　正则|正则B：表示A或B正则出现一个

　　（正则）：按照一组正则进行处理

String类对正则的支持

　　从JDK1.4开始String类发生了一些改变，也就是说用户可以直接通过String类来进行正则的调用，在String类里面有如下几个直接支持正则开发的方法；

　　进行字符串验证的，匹配某个正则： public boolean matches(String regex)

　　根据正则替换全部：public String replaceAll(String regex,String replacement)

　　根据正则替换首个：public String replaceFirst(String regex,String replacement)

　　根据正则拆分：public String[] split(String regex,int limit)

范例：实现拆分

package cn.Tony.demo;
public class TestDemo{
    public static void main(String[] args) throws Exception {
        String str="skndsdf843238*@Hndjkand";
        String regex="[^a-zA-Z]";
        System.out.println(str.replaceAll(regex, ""));
    }
}

范例：字符串拆分

package cn.Tony.demo;
public class TestDemo{
    public static void main(String[] args) throws Exception {
        String str="a1d161d6161d889drk9";
        String regex="\\d";//正则[0-9]
        String result[]=str.split(regex);
        for(int x=0;x<result.length;x++) {
            System.out.println(result[x]);
        }
    }
}

　　在使用正则的过程之中最为麻烦的部分就是进行字符串验证结构验证

范例：验证某一个字符串是否是数子（整数或者小数），如果是则其变为Double型

范例：验证一个字符串是否为数字

package cn.Tony.demo;
public class TestDemo{
    public static void main(String[] args) throws Exception {
        String str="11010";
        String regex="\\d+(\\.\\d+)?";//正则[0-9]
        if(str.matches(regex)) {
            double data=Double.parseDouble(str);
            System.out.println(data);
        }
    }
}

范例：要求验证一个字符创是否为日期或者是日期时间，如果是则将其变为Date类型

package cn.Tony.demo;

import java.text.SimpleDateFormat;

public class TestDemo{
    public static void main(String[] args) throws Exception {
        String str="2019-03-12 10:11:11";
        String regex="\\d{4}-\\d{2}-\\d{2}";//正则[0-9]
        if(str.matches(regex)) {
            System.out.println(new SimpleDateFormat("yyyy-MM-dd").parse(str));
        }else if(str.matches("\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}")) {
            System.out.println(new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").parse(str));
        }
    }
}

　　此时这种需要转换的前提下，对于正则的格式判断最好分开。

范例：现在要求判断给定的电话号码是否正确（用一个正则进行判断）

　　电话格式一：51283346；"\\d{7,8}"

　　电话格式二：01051283346；"(\\d{3,4})?\\d{7,8}"

　　电话格式三：（010）-51283346。

 

package cn.Tony.demo;
public class TestDemo{
    public static void main(String[] args) throws Exception {
        String str="(010)-51283346";
        String regex="((\\(\\d{3,4}\\)-)|(\\d{3,4}))?\\d{7,8}";//正则[0-9]
        System.out.println(str.matches(regex));
    }
}

 

范例：验证给定的字符串是否是email地址

　　简单验证：邮件地址由字母 数字 _所组成

package cn.Tony.demo;
public class TestDemo{
    public static void main(String[] args) throws Exception {
        String str="1650498553@qq.com";
        String regex="\\d{10,11}@\\w+\\.\\w+";//正则[0-9]
        System.out.println(str.matches(regex));
    }
}

　　email的用户名必须由字母开头，而且组成可以是字母 数字 _ - . 所组成，而且用户的长度必须在6~15位，域名的后缀必须是.com .net .cn .org .gov .com.cn .net.cn。

package cn.Tony.demo;
public class TestDemo{
    public static void main(String[] args) throws Exception {
        String str="amldn8-1.2@mldnjava.cn";
        String regex="[a-zA-Z][a-zA-Z\\._\\-0-9]{5,14}@[a-zA-Z\\._\\-0-9]+\\.(cn|com|net|org|com\\.cn|net\\.cn)";//正则[0-9]
        System.out.println(str.matches(regex));
    }
}

　　于我们的开发而言，正则的重大意义在于字符串的组成验证处理还是上

java.util.regex开发包

　　JDK1.4里面吧增加的开发包就是java.util.regex 但是在这个包里面只有两个类：Pattern类，Matcher类 Pattern负责编译正则，Matcher负责匹配正则。如果要做的是一般的处理，实际上不需要使用到这两个类。只需要使用String即可

1.观察Pattern

　　取得实例化对象：public static Pattern compile(String regex)

　　拆分字符串：public String[] split(CharSequence input,int limit)

　　取得Matcher类对象：public static boolean matches(String regex,CharSequence input)

范例：通过Pattern实现字符串拆分

package cn.Tony.demo;
import java.util.regex.Pattern;
public class TestDemo{
    public static void main(String[] args) throws Exception {
        String str="a|b|c";
        String regex="\\|";
        Pattern pat=Pattern.compile(regex);
        String data[]=pat.split(str);
        for(int x=0;x<data.length;x++) {
            System.out.println(data[x]);
        }
    }
}

2.Matcher负责正则匹配

　　字符串匹配：public boolean matches()

　　全部替换：public String replaceAll(String replacement)

　　替换首个：public String replaceFirst(String replacement)

package cn.Tony.demo;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class TestDemo{
    public static void main(String[] args) throws Exception {
        String str="100";
        String regex="\\d+";
        Pattern pat=Pattern.compile(regex);
        Matcher mat=pat.matcher(str);
        System.out.println(mat.matches());
    }
} 

　　在进行一些负责的正则时，String是解决不了的，就要使用Matcher来完成

package cn.Tony.demo;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class TestDemo{
    public static void main(String[] args) throws Exception {
        String str="INSERT INTO member(mid,name,age) VALUES (#{member.mid},#{member.name}.#{member.age})";
        String regex="#\\{[a-zA-Z_0-9\\.]+\\}";//分组的依据
        Pattern pat=Pattern.compile(regex);
        Matcher mat=pat.matcher(str);
        while(mat.find()) {//依次进行比较，如果复合则取出内容
            System.out.println(mat.group(0));
        }
    }
} 

　　基本上开发中最为常用的正则都在String类中定义了，而如果一些复杂的操作才会使用到Matcher Pattern

总结：

1.正则标记

2.String类对正则的开发支持。