java中的正则表达式和异常

正则表达式：

作用一：用来校验数据格式是否合法

作用二：在文本中查找满足要求的内容

不用正则表达式：检验QQ号是否合法，要求全部是数字，长度在6-20，不能以0开头

public class test {
    public static void main(String[] args) {
        //检验QQ号是否合法，要求全部是数字，长度在6-20，不能以0开头
        String qq="12345678";
        System.out.println(checkqq(qq));//true
        String qq2="24253fsaf";
        System.out.println(checkqq(qq2));//false
        
        
        
    }
    public static boolean checkqq(String qq)
    {
        //1判断qq是否为空
        if(qq==null||qq.length()<6||qq.length()>20||qq.startsWith("0"))
        {
            return false;
        }
        for (int i = 0; i < qq.length(); i++) {
            char c=qq.charAt(i);
            if(c<'0'||c>'9')
            {
                return false;
            }
        }
        return true;
    }
}

String提供了一个匹配正则表达式的方法

public boolean matches(String regex)//判断字符串是否符合正则表达式，符合返回true

正则表达式的规则：

这里面的X就是上面两张图片的内容  

"(?!)abc"-->abc忽略大小写 

例子1：校验数据格式是否合法

public class test2 {
    public static void main(String[] args) {
        //checkPhone();
        checkEmail();

    }
    public static void checkPhone()
    {
        Scanner sa=new Scanner(System.in);
        while (true) {
            System.out.println("请输入手机号或者座机号");
            String phone=sa.nextLine();
            //18288997799  //010-3525252 0105262366
            if(phone.matches("(1[3-9]\\d{9})|(0\\d{2,7}-?\\d{4,19})"))
            {
                System.out.println("你输入的手机号或座机号有效");
                break;
            }
            else {
                System.out.println("你输入的手机号或座机号无效");
                continue;
            }
        }
    }
    public static void checkEmail()
    {
        Scanner sa=new Scanner(System.in);
        while (true) {
            System.out.println("请输入邮箱号");
            String phone=sa.nextLine();
            //deilfa225@163.com
            //414242532@qq.com
            //iamhh@hh.com.cn
            if(phone.matches("\\w{2,}@\\w{2,10}(\\.\\w{2,10}){1,2}"))
            //  单独的一个点.是通配字符，要加上转义字符\告诉它就是一个点，还要再加一个\告诉第一个\你就是单纯的转义字符\,
                //不然\.会看成一个整体，这样会报错
            {
                System.out.println("你输入的邮箱号有效");
                break;
            }
            else {
                System.out.println("你输入的邮箱号无效");
                continue;
            }
        }
    }
}

 例子二：在文本中查找满足要求的内容

步骤：
1:定义爬取规则

2：把正则表达式封装成Patter对象

3:通过Patter对象去获取查找内容的匹配器对象

4:定义一个循环开始爬取信息（matcher.find()有内容返回true）

public class test3 {
    public static void main(String[] args) {
        String data="i am hhh,\n"
                +"my phone is 18388889344 and 18277889933,\n"
                +"my email is 147889900@qq.com and iamhh@hh.com.cn and deilfa225@163.com,\n"
                +"我的座机电话是：010-353463,\n"
                +"热线电话：400-519-8060";
        //1:定义爬取规则
        String regex="(1[2-9]\\d{9})|(0\\d{2,7}-?[1-9]\\d{4,19})"
                +"|(\\w{2,}@\\w{2,20}(\\.\\w{2,10}){1,2})"
                +"|(400-?\\d{3,7}-?\\d{3,7})";
        //2：把正则表达式封装成Patter对象
        Pattern patter= Pattern.compile(regex);
        //3:通过Patter对象去获取查找内容的匹配器对象
        Matcher matcher= patter.matcher(data);
        //4:定义一个循环开始爬取信息
        while(matcher.find())
        {
            String rs= matcher.group();
            System.out.println(rs);
        }
    }
}

 结果：

例子三：正则表达式用于搜索替换，分割内容，需要结合String提供的方法

public String replaceAll(String regex, String replacement)

 按照正则表达式匹配的内容进行替换

public String[] split(String regex)

按照正则表达式匹配的内容进行分割字符串，返回一个字符串数组 

参数regex是 以regex 为分割符

public class test4 {
    public static void main(String[] args) {
        //1:把：危险啊afaga阿凡提wwaf别别，中间的非中文字符替换成“-”
        String data="危险啊afaga阿凡提wwaf别别";
        String regex="\\w+";
        String replaced = data.replaceAll(regex, "-");
        System.out.println(replaced);

        //2:把：我我喜喜喜喜喜喜欢欢欢你！  替换成 我喜欢你！
        String data2="我我喜喜喜喜喜喜欢欢欢你";
        System.out.println(data2.replaceAll("(.)\\1+","$1"));
        /*
        1 一个.可以匹配任意通配符，(.)代表一组，即一个字为一组
        2 \\1表示该组的组号为1
        3 +表示该组出现1次或多次
        4 $1则可以取到第一组中的内容
        */

        //3：把  危险啊afaga阿凡提wwaf别别 中的中文提取出来
        String data3="危险啊afaga阿凡提wwaf别别";
        String[] split = data.split("\\w+");//参数regex是以什么为分割符
        System.out.println(Arrays.toString(split));//[危险啊, 阿凡提, 别别]

    }
}

 异常：

运行时异常：
RunTimeException及其子类，编译阶段不会出现错误提醒，运行时出现的异常

编译时异常：
编译阶段就会出现错误提醒

异常的处理：

抛出异常（throws）

在方法上使用throws关键字，可以将方法内部的异常抛给调用者处理

捕获异常（try..catch）

直接捕获程序出现的异常

自定义异常：

自定义运行异常 

定义一个异常类来继承RunTimeEexception

重写构造器

通过throw new 异常类(xx) 来创建异常对象并抛出

定义一个异常类：

package yi_chang;
//1:继承RunTimeException类
public class AgeillegalRunTimeException extends  RuntimeException{
    //2：重写构造器


    public AgeillegalRunTimeException() {
    }

    public AgeillegalRunTimeException(String message) {
        super(message);
    }
}

public class test {
    public static void main(String[] args) {
        //获取一个合法年龄
        try {
            saveAge(200);
        }catch (Exception e)
        {
            e.printStackTrace();
            System.out.println("你输入的年龄不合法");
        }
    }
    public static void saveAge(int age)
    {
        if(age>=0&&age<=180)
        {
            System.out.println(age+"被保存");
        }
        else
        {
            //3：抛出异常对象
            throw new AgeillegalRunTimeException(" age is illeegal "+age);
        }
    }
}

结果：

自定义编译时异常

定义一个异常类继承Exception

重写构造器

 通过throw new 异常类(xx) 来创建异常对象并抛出

 

//1:继承Exception类
public class AgeillegalException extends Exception{
    //2重写构造器


    public AgeillegalException() {
    }

    public AgeillegalException(String message) {
        super(message);
    }

}

public class test {
    public static void main(String[] args) {
        //获取一个合法年龄
        /*try {
            saveAge(200);
        }catch (Exception e)
        {
            e.printStackTrace();
            System.out.println("你输入的年龄不合法");
        }*/
        try {
            saveAge(20);
        }catch (Exception e)
        {
            e.printStackTrace();
            System.out.println("你输入的年龄不合法");
        }
        }
    public static void saveAge(int age) throws AgeillegalException//把该异常抛给调用该方法的地方
    {
        //3：抛出异常对象
        //throw new AgeillegalRunTimeException(" age is illeegal "+age);
        if(age>=0&&age<=180)
        {
            System.out.println(age+"被保存");
        }
        else
            throw new AgeillegalException(" age is illeegal "+age);
    }
}

尝试修复异常：
 

public class test2 {
    public static void main(String[] args) {
        //尝试修复异常

        while (true) {
            try {
                getMoney();//一旦接收到异常不执行break语句，直到没有异常产生
                break;
            } catch (Exception e) {
                System.out.println("请你输入合适的价格！");
            }
        }
    }
    public static void getMoney()
    {
        Scanner sa=new Scanner(System.in);
        System.out.println("请输入合适的价格");
        while(true)
        {
            double d=sa.nextDouble();
            if(d>0.0)
            {
                System.out.println("输入正确");
            }
            else
            {
                throw new MoneyillegnalRunTimeException("价格不合法");
            }
        }
        
    }
}