当前位置:w88手机版登录-www.w88zhan.com-优德w88app官方登录 > w88手机版登录网络 > 但是面对这样一个不麻烦的验证

但是面对这样一个不麻烦的验证

文章作者:w88手机版登录网络 上传时间:2019-08-01

3.11、正则表达式(珍视)

3.11.1 、正则表明式的引出

         上边达成一个简短的主次,在头里早就疏解过那样一段代码:判别二个字符串是不是由数字构成。

范例:代码完毕

package cn.mldn.demo;

public class TestDemo {

    public static void main(String[] args) throws Exception {

        String str = " 13412a 4124214141232" ;

        if (isNumber(str)) {

            System.out.println("是由数字所组成!");

        } else {

            System.out.println("不是由数字所组成!");

        }

    }

    public static boolean isNumber(String data) {

        char arr [] = data.toCharArray() ;  // 字符串变为字符数组

        for (int x = 0; x < arr.length; x ) {

            if (arr[x] < '0' || arr[x] > '9') {

                return false ;

            }

        }

        return true ;

    }

}

         然而今后一个大致的标题就涌出了,那么些注明应该算是轻松的,可是面临这么二个不麻烦的求证,代码写了9行代码,假使是部分尤其复杂的证实呢?那么对于全体操作就进一步的难为了,今后有别的一种做法:

package cn.mldn.demo;

public class TestDemo {

    public static void main(String[] args) throws Exception {

        String str = "1341224124214141232" ;

        if (str.matches("\d ")) {

            System.out.println("是由数字所组成!");

        } else {

            System.out.println("不是由数字所组成!");

        }

    }

}

         很醒目,未来对此程序来说,第三种方法更为的粗略,而第二种办法就是使用了正则表明式的定义,而里边的“\d ”代码就属孙铎则表达式的程序代码。

         正则表达式最早是在Linux下发展起来的,然而由于其使用方便,在JDK 1.4的时候将其专门的学业引进到了Java的付出体系之中,而在JDK 1.4事先假使要想行使正则表明式,那么供给单独布置三个Apache的开荒包,而JDK 1.4随后除了引进了正则的支撑之外,同临时间也对String类进行了有个别修改,能够让其一向操作正则。

         在JDK 1.4自此特地引进了二个java.util.regex开垦包,那几个包里面有三个基本点类肩负达成正则的开销:Pattern(定义况兼编写翻译正则的极度模板)、Matcher(相配应用),之所以未来不去关怀那多个类,主要是因为JDK 1.4事后对String类的修改达到了一个很好的正则操作效能,首要运用String类实现。

3.11.2 、常用正则相称符号(背,死了都要背)

         全部的正则相称的标识都在java.util.regex.Pattern类之中实行定义,上面分别对那些常用的暗记做一些介绍。

1、   字符:匹配单个字符

         · a:表示相配字母a;

         · \:匹配转义字符“”;

         · t:匹配转义字符“t”;

         · n:相称转义字符“n”;

2、   一组字符:率性匹配里面包车型客车三个单个字符;

         · [abc]:表示或者是字母a,大概是字母b只怕是字母c;

         · [^abc]:表示不是字母a、字母b、字母c的擅自叁个;

         · [a-zA-Z]:表示整个假名中的放肆一个;

         · [0-9]:表示整个数字的任性三个;

3、   边界相配:在以后编写JavaScript的时候利用正则中要运用到;

         · ^:表示一组正则的起来;

         · $:表示一组正则的终结;

4、   简写表明式:每一种人现身的简写标识也只表示一个人;

         · .:表示任性的壹个人字符;

         · d:表示放肆的壹人数字,等价于“[0-9]”;

         · D:表示任性的一人非数字,等价于“[^0-9]”;

         · w:表示任性的一位字母、数字、_,等价于“[a-zA-Z0-9_]”;

         · W:表示狂妄的壹位非字母、数字、_,等价于“[^a-zA-Z0-9_]”;

         · s:表示任性的一人空格,举个例子:n、t等;

         · S:表示任性的壹人非空格;

5、   数量表示:在此之前的兼具正则都只是意味着一人,假使要想表示多位,则就要求多少表示。

         · 正则表明式?:此正则出现0次或1次;

         · 正则表明式*:此正则出现0次、1次或频仍;

         · 正则表明式 :此正则出现1次或频仍;

         · 正则表明式{n}:此正则出现恰恰n次;

         · 正则表明式{n,}:此正则出现n次以上;

         · 正则表明式{n,m}:此正则出现n ~ m次。

6、   逻辑表示:与、或、非

         · 正则表明式A正则表达式B:表明式A之后紧跟着表明式B;

         · 正则表达式A|正则表明式B:表示表明式A只怕是表述式B,二者任选二个冒出;

         · (正则表明式):将多个子表明式合成一个代表,作为一组出现。

3.11.3 、String类对正则的支撑

         在JDK 1.4事后,String类对正则有了平素的法子补助,只供给通过如下的多少个措施就足以操作正则。

No.

方法名称

类型

描述

1

public boolean matches(String regex)

普通

与指定正则匹配

2

public String replaceAll(String regex, String replacement)

普通

替换满足指定正则的全部内容

3

public String replaceFirst(String regex, String replacement)

普通

替换满足指定正则的首个内容

4

public String[] split(String regex)

普通

按照指定正则全拆分

5

public String[] split(String regex, int limit)

普通

按照指定的正则拆分为指定个数

Pattern类之中存在的秘技:

         · 字符串全拆分:public String[] split(CharSequence input);

         · 字符串部分拆分:public String[] split(CharSequence input, int limit);

马特erh类之中存在的法子:

         · 字符串相称:public boolean matches();

         · 字符串全替换:public String replaceAll(String replacement);

         · 字符串替换第二个:public String replaceFirst(String replacement)。

         就是因为String类接济的点子相比健全,所以在支付之中,首要的都以String类操作正则,因为低价。下边编辑若干个操作实例来进展正则的证明。

范例:字符串拆分

package cn.mldn.demo;

public class TestDemo {

    public static void main(String[] args) throws Exception {

        String str = "a1bb2ccc3dddd4eeeee5fffffff6ggggggg7" ;

        String regex = "[a-zA-Z] " ;// 字母出现1次或多次

        System.out.println(str.replaceAll(regex, ""));

        System.out.println(str.replaceFirst(regex, ""));

    }

}

范例:字符串拆分

package cn.mldn.demo;

public class TestDemo {

    public static void main(String[] args) throws Exception {

        String str = "a1bb2ccc3dddd4eeeee5fffffff6ggggggg7" ;

        String regex = "\d" ;// 数字出现1次,[0-9]

        String result [] = str.split(regex) ;

        for (int x = 0; x < result.length; x ) {

            System.out.print(result[x] "、");

        }

    }

}

         有了正则,对于字符串日后的各种操作就能变的一定的福利。而正则在应用的进度之中最为重大的有的便是印证部分,因为有的字符串必须满足于钦命的格式才方可操作。

范例:做三个大致的认证,须要字符串格式“aaaaab”,在b在此之前可以有众多多少个a,不过不可能未有,至少1个。

package cn.mldn.demo;

public class TestDemo {

    public static void main(String[] args) throws Exception {

        String str = "aaaaaab" ;

        String regex = "a b" ;

        System.out.println(str.matches(regex));

    }

}

范例:表明一(Wissu)个字符串是还是不是是整型数据,要是是则将其变成int型数据,而后实行乘法操作

package cn.mldn.demo;

public class TestDemo {

    public static void main(String[] args) throws Exception {

        String str = "123" ;

        String regex = "\d " ;

        if (str.matches(regex)) {   // 符合于验证要求

            int data = Integer.parseInt(str) ;  // 字符串变为int型数据

            System.out.println(data * data);

        } else {

            System.out.println("字符串不是数字所组成!");

        }

    }

}

范例:验证字符串是不是是小数,如若是则将其形成double型数据,而后实践乘法操作

package cn.mldn.demo;

public class TestDemo {

    public static void main(String[] args) throws Exception {

        String str = "123.1" ;

        String regex = "\d (\.\d )?" ;

        if (str.matches(regex)) {   // 符合于验证要求

            double data = Double.parseDouble(str) ; // 字符串变为double型数据

            System.out.println(data * data);

        } else {

            System.out.println("字符串不是数字所组成!");

        }

    }

}

范例:输入二个字符串,遵照年-月-日 时-分-秒的格局,假若不易,则将其变为Date型数据

package cn.mldn.demo;

import java.text.SimpleDateFormat;

import java.util.Date;

public class TestDemo {

    public static void main(String[] args) throws Exception {

        String str = "1998-09-18 10:10:10.100" ;

        String regex = "\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3}" ;

        if (str.matches(regex)) {   // 符合于验证要求

            Date date = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS")

                    .parse(str);

            System.out.println(date);

        } else {

            System.out.println("字符串不是日期!");

        }

    }

}

范例:一个用户名只好由字母、数字、_所构成,其尺寸只可以是6~15位

package cn.mldn.demo;

public class TestDemo {

    public static void main(String[] args) throws Exception {

        String str = "343234FDSF_";

        String regex = "\w{6,15}";

        if (str.matches(regex)) { // 符合于验证要求

            System.out.println("用户名合法。");

        } else {

            System.out.println("用户名非法!");

        }

    }

}

范例:现行反革命编写二个正则表明式须求验证电话号码是或不是科学,比如:未来写上大家电话号码,有如下两种写法:

         · 写法一:51283346                 è     \d{7,8};

         · 写法二:01051283346           è     (\d{3,4})?\d{7,8};

         · 写法三:010-51283346                   è     (\d{3,4})?-?\d{7,8};

         · 写法四:(010)-51283346       è     ((\d{3,4}|\(\d{3,4}\))-?)?\d{7,8};

· 写法五:(010)51283346        è     ((\d{3,4}|\(\d{3,4}\))-?)?\d{7,8}。

package cn.mldn.demo;

public class TestDemo {

    public static void main(String[] args) throws Exception {

        String str = "51283346";

        // 第一步:\d{7,8},因为电话号码可能是7~8位所组成;

        // 第二步:(\d{3,4})?\d{7,8},因为区号由3~4位所组成;

        // 第三步:(\d{3,4})?-?\d{7,8},因为-可能出现也可能不出现

        // 第四步:((\d{3,4}|\(\d{3,4}\))-?)?\d{7,8}

        String regex = "((\d{3,4}|\(\d{3,4}\))-?)?\d{7,8}";

        if (str.matches(regex)) { // 符合于验证要求

            System.out.println("TRUE,电话号码输入合法。");

        } else {

            System.out.println("FLASE,电话号码输入非法!");

        }

    }

}

范例:于今须求说Bellamy(Bellamy)(Dumex)个email地址,email地址的用户名由字母、数字、_、.所构成,其中不可能以数字和.初阶,何况email地址的域名只好是.com、.cn、.net

package cn.mldn.demo;

public class TestDemo {

    public static void main(String[] args) throws Exception {

        String str = "mldnqa@163.net";

        String regex = "[a-zA-Z_][a-zA-Z_0-9\.]*@[a-zA-Z_0-9\.] \.(com|cn|net)";

        if (str.matches(regex)) { // 符合于验证要求

            System.out.println("TRUE,EMAIL输入合法。");

        } else {

            System.out.println("FLASE,EMAIL输入非法!");

        }

    }

}

 

范例:到现在决断一个字符串的组成,其重组原则“姓名:年龄:战表|姓名:年龄:成绩|姓名:年龄:成绩|…”

比方,今后有多少个字符串内容如下:“SMITH:19:90.1|ALLEN:18:90.1|KING:20:95.2|”,个中姓名的构成只可以是字母,年龄只好是数字,战绩大概是小数。

第一问:写出来证实的正则表明式

package cn.mldn.demo;

public class TestDemo {

    public static void main(String[] args) throws Exception {

        String str = "SMITH:19:90.1|ALLEN:18:90.1|KING:20:95.2";

        String regex = "([a-zA-Z] :\d{1,3}:\d{1,3}(\.\d{1,2})?\|) ([a-zA-Z] :\d{1,3}:\d{1,3}(\.\d{1,2})?)?";

        if (str.matches(regex)) { // 符合于验证要求

            System.out.println("TRUE,输入合法。");

        } else {

            System.out.println("FLASE,输入非法!");

        }

    }

}

第二问:将有所的数码排序,遵照成绩由高到低排序,假如战绩一样,则遵照年龄由低到高排序

         既然是排序操作,今后能够想到的点子正是:Arrays.sort(),可是未来这几个数据足以将其成为对象数组排序,利用相比较器实现。

package cn.mldn.demo;

import java.util.Arrays;

class Student implements Comparable<Student> {

    private String name ;

    private int age ;

    private double score ;

    public Student(String name,int age,double score) {

        this.name = name ;

        this.age = age ;

        this.score = score ;

    }

    @Override

    public String toString() {

        return "Student [name=" name ", age=" age ", score=" score

                "]n";

    }

    @Override

    public int compareTo(Student o) {

        if (this.score > o.score) {

            return -1 ;

        } else if (this.score < o.score) {

            return 1 ;

        } else {

            if (this.age > o.age) {

                return 1 ;

            } else if (this.age < o.age){

                return -1 ;

            } else {

                return 0 ;

            }

        }

    }

}

public class TestDemo {

    public static void main(String[] args) throws Exception {

        String str = "SMITH:19:90.1|ALLEN:18:90.1|KING:20:95.2";

        String regex = "([a-zA-Z] :\d{1,3}:\d{1,3}(\.\d{1,2})?\|) ([a-zA-Z] :\d{1,3}:\d{1,3}(\.\d{1,2})?)?";

        if (str.matches(regex)) { // 符合于验证要求

            String result [] = str.split("\|") ;   // 拆分

            Student stu [] = new Student[result.length];    // 此时的数组大小就是对象数组大小

            for (int x = 0; x < result.length; x ) {

                String temp [] = result[x].split(":") ;

                stu[x] = new Student(temp[0], Integer.parseInt(temp[1]),

                        Double.parseDouble(temp[2]));

            }

            Arrays.sort(stu) ;

            System.out.println(Arrays.toString(stu));

        } else {

            System.out.println("FLASE,输入非法!");

        }

    }

}

         因为在后来的富有项目的支付之中,只假设输入的数码都是接纳字符串接收的,那么字符串又足以向种种数据类型转变,而要转换在此以前为了确定保障转换来功一定须求实行表达,验证最有助于的正是正则表达式。


本文由w88手机版登录-www.w88zhan.com-优德w88app官方登录发布于w88手机版登录网络,转载请注明出处:但是面对这样一个不麻烦的验证

关键词: 优德娱乐平台