正则表达式

正则表达式的概述和简单使用

A:正则表达式:正确规则的表达式 规则java给我们定的
是指一个用来描述或者匹配一系列符合某个句法规则的字符串的单个字符串。其实就是一种规则。有自己特殊的应用。
B:案例演示
需求：校验qq号码.
1:要求必须是5-15位数字
2:0不能开头

a:非正则表达式实现

b:正则表达式实现 

案例一：

	private static boolean checkQQ(String numQQ) {
	// 校验位数
	boolean b = false;
	// 判断长度
	if (numQQ.length() >= 5 && numQQ.length() <= 15) {
		// 判断开头不能为0
		if (!(numQQ.startsWith("0"))) {
			// 判断每一位是不是数字
			for (int i = 0; i < numQQ.length(); i++) {
				char ch = numQQ.charAt(i);
				if (ch >= '0' && ch <= '9') {

					b = true;
				} else {
					b = false;
					break; //一旦遇到不是数字的,就结束循环

				}

			}

		} else {

			b = false;
		}

	} else {

		b = false;
	}

	return b;
}

import java.util.Scanner;
public class MyTest {
    public static void main(String[] args) {
        //正则表达式：正确规则的表达式，他是一个独立的语法，很多语言都支持，他的作用就是用来校验，一段数据符不符合我定义的规则
        //
        //B:
        //案例演示
        //需求：校验qq号码.
        //1:要求必须是5 - 15 位数字
        //2:0 不能开头
        //
        //a:
        //非正则表达式实现
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你的QQ号码");
        String qqNum = sc.nextLine();
       // boolean b = checkQQNum(qqNum);

        boolean b = checkQQNum2(qqNum);
        if (b) {
            System.out.println("QQ号码规则正确");
        } else {
            System.out.println("QQ号码规则有误");
        }

    }

    private static boolean checkQQNum2(String qqNum) {
        //定义一个正则表达式
        String regx="[1-9][0-9]{4,14}";
        boolean matches = qqNum.matches(regx);
        return matches;
    }

    private static boolean checkQQNum(String qqNum) {
        //1:要求必须是5 - 15 位数字
        //2:0 不能开头
        //定义一个标记
        boolean flag = false;
        //校验位数
        if (qqNum.length() >= 5 && qqNum.length() <= 15 && !qqNum.startsWith("0")) {
            //下来校验每个位数是否是数字
            for (int i = 0; i < qqNum.length(); i++) {
                char ch = qqNum.charAt(i);
                if (ch >= '0' && ch <= '9') {
                    flag = true;
                } else {
                    flag = false;
                    break;//终止循环
                }
            }
        } else {
            flag = false;
        }
        return flag;
    }
}

正则表达式的判断功能

案例一：

import java.util.Scanner;

public class MyTest2 {
    public static void main(String[] args) {
        //手机号码，长度11位  以 1开头
        //手机号码每一位都是数字
        // 第二位 3 5 6 7 8 9  
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你的手机号码");
        String phoneNum = sc.nextLine();
        boolean b = checkPhoneNum(phoneNum);
        System.out.println(b);
        if (b) {
            System.out.println("规则正确");
        } else {
            System.out.println("规则不正确");
        }
    }

    private static boolean checkPhoneNum(String phoneNum) {
        //定义标记
        boolean flag = false;
        if (phoneNum.length() == 11 & (phoneNum.startsWith("13") || phoneNum.startsWith("15") || phoneNum.startsWith("16") || phoneNum.startsWith("17") || phoneNum.startsWith("18") || phoneNum.startsWith("19"))) {
            for (int i = 2; i < phoneNum.length(); i++) {
                char ch = phoneNum.charAt(i);
                //static boolean isDigit ( char ch)
                //确定指定字符是否为数字。
                if (Character.isDigit(ch)) {
                    flag = true;
                } else {
                    flag = false;
                    break;
                }
            }

        } else {

            flag = false;
        }


        return flag;
    }
}

正则表达式的组成规则

案例一：

public class MyTest {
    public static void main(String[] args) {


        String regx = "a";
        regx = "[abcdef]"; //运行出现列表中的某一个字符
        regx = "[a-z]";//允许出现26个小写字母的任意一个
        regx = "[A-Za-z]";
        regx = "[0-9]";
        regx = "[a-zA-Z0-9]";
        regx = "[^0-9]"; //把不允许出现我列表中的任意一个
        regx = ".";//通配单个任意字符
        regx = "\.";// \ 转意字符 \. 这个意思就是匹配点本身
        regx = "\|";
        regx = "\d";//"跟"[0-9]意思一样
        regx = "\w";//跟 [a-zA-Z_0-9] 意思一样
        regx = "[a-z]+"; //+ 可以出现一个或多个
        regx = "a?"; //一次或一次也没有 比如 "" 空串 就是没有
        regx = "[a-z]*";//零次或多次  大于等于1次 都算多次
        regx = "[a-z]{6}";//正好6次
        regx = "[0-9]{6,}";//至少6个
        regx = "[0-9]{6,16}";//大于等于 6 小于等于16
        boolean flag = "123499988766454343".matches(regx);
        System.out.println(flag);


        String regx2 = "[1-9][0-9]{4,14}";//

    }
}

校验用户邮箱是否满足要求

案例一：

public class MyTest2 {
    public static void main(String[] args) {
        //A:
        //正则表达式的判断功能
        //String类的功能：public boolean matches (String regex)
        //A:
        //案例演示:
        //需求：校验邮箱

        /*
         * 2843095510@qq.com
         * xibukaiyuan@163.com
         *  xibukaiyuan@sina.cn
         *   xibukaiyuan@sina.net
         *   xibukaiyuan@sina.org
         *
         *
         *
         *
         * */

        // 6 ~18 个字符，可使用字母、数字、下划线，需以字母开头

        String emailRegx = "[a-zA-Z]\w{5,17}@[1-9a-z]{3,16}\.(com|cn|net|org)";


        boolean matches = "284309510@qq.com".matches(emailRegx);
        System.out.println(matches);


    }
}

案例二：

public class MyTest3 {
    public static void main(String[] args) {
        //手机号码的正则
        String phoneRegx="[1][356789][0-9]{9}";
        System.out.println("18976543456".matches(phoneRegx));
        //校验身份证的正则
       String id="[1-9]\d{5}(18|19|20)\d{2}((0[1-9])|(1[0-2]))(([0-2][1-9])|10|20|30|31)\d{3}[0-9Xx]";

       //车牌号码的正则

        String carNum="[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领A-Z]{1}[A-Z]{1}[A-Z0-9]{4}[A-Z0-9挂学警港澳]{1}";
    }
}

正则表达式的分割功能

A:正则表达式的分割功能 split()方法

案例一：

public class MyTest {
    public static void main(String[] args) {

        //String s = str.substring(0, str.indexOf("="));
        //System.out.println(s);
        //String s1 = str.substring(str.indexOf("=") + 1, str.lastIndexOf("="));
        //
        //System.out.println(s1);
        //
        //String substring = str.substring(str.lastIndexOf("=")+1);
        //System.out.println(substring);
       // String str = "张三=男=23";
        //String[] strings = str.split("=");
        //System.out.println(strings[0]);
        //System.out.println(strings[1]);
        //System.out.println(strings[2]);
        //根据正则切割字符
        String str = "张三=aaBBB&7dfefe男=SASDfdfedfefdfd23";
        String[] strings = str.split("[=a-zA-Z]+");
        System.out.println(strings[0]);
        System.out.println(strings[1]);
        System.out.println(strings[2]);
    }
}

把给定字符串中的数字排序

A:案例演示: 需求：我有如下一个字符串:”91 27 46 38 50”，请写代码实现最终输出结果是：”27 38 46 50 91”

• 分析:
• a: 定义目标字符串"91 27 46 38 50"
• b: 对这个字符串进行切割,得到的就是一个字符串数组
• c: 把b中的字符串数组转换成int类型的数组
• (1): 定义一个int类型的数组,数组的长度就是字符串数组长度
• (2): 遍历字符串数组,获取每一个元素.将其转换成int类型的数据
• (3): 把int类型的数据添加到int类型的数组的指定位置
• d: 排序
• e: 创建一个StringBuilder对象,用来记录拼接的结果
• f: 遍历int类型的数组, 将其每一个元素添加到StringBuilder对象中
• g: 就是把StringBuilder转换成String
• h: 输出

案例一：
//A:
//案例演示:
//需求：我有如下一个字符串:”91 27 46 38 50”，请写代码实现最终输出结果是：”27 38 46 50 91”

import java.util.Arrays;
public class MyTest2 {
    public static void main(String[] args) {
       String str="91 27 46 38 50";  //"27 38 46 50 91";
        String[] s = str.split(" ");
        //定义一个int数组
        int[] arr=new int[s.length];
        //遍历字符串数组，取出每一个元素，放到int数组里面
        for (int i = 0; i < s.length; i++) {
            arr[i]=Integer.parseInt(s[i]);
        }
        //排序
        Arrays.sort(arr);

        //遍历int数组拼串
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < arr.length; i++) {
            sb.append(arr[i]).append(" ");

        }
        String string = sb.toString().trim();
        System.out.println(string);
    }
}

给数组中添加一个元素

案例一:

import java.util.Arrays;

public class MyTest3 {
    public static void main(String[] args) {
        //给数组中添加一个元素
        int[] arr={1,3,5,6,7,8};//数组一旦定义好了之后，长度是固定的

        int num=100;
        //定义一个临时数组
        int[] tempArray=new int[arr.length+1];
        for (int i = 0; i < arr.length; i++) {
            tempArray[i]=arr[i];
        }

        tempArray[arr.length]=num;

        arr=tempArray;
        System.out.println(Arrays.toString(arr));
    }
}

给数组中删除一个元素

案例一：

import java.util.Arrays;
public class MyTest4 {
    public static void main(String[] args) {
        int[] arr = {10, 50, 60, 70, 80, 90, 100};
        int index = 2;
        //删除索引是2位置的元素
        int[] tempArr=new int[arr.length-1];
        for (int i = 0; i < tempArr.length; i++) {
            if(i<index){
                tempArr[i]=arr[i];
            }else{
                tempArr[i]=arr[i+1];
            }
        }

        arr=tempArr;
        System.out.println(Arrays.toString(arr));

    }
}

正则表达式的替换功能

A:正则表达式的替换功能
String类的功能：public String replaceAll(String regex,String replacement)
案例：
//B:
//案例演示
System.out.println(“奥巴马是美国总统”.replace(“奥巴马”, “*”));

public class MyTest {
    public static void main(String[] args) {

  System.out.println("奥巴马是美国总统".replace("奥巴马", "*"));

       String str="a12133b2323233222cewrere1243434aadfd888";
       // System.out.println(str.replace(" ", ""));

        System.out.println(str.replaceAll("[0-9]+", ""));


    }
}

Pattern和Matcher的概述

正则的获取功能需要使用的类

A:Pattern和Matcher的概述
B:模式和匹配器的典型调用顺序
通过JDK提供的API，查看Pattern类的说明

典型的调用顺序是 
Pattern p = Pattern.compile("a*b");
Matcher m = p.matcher("aaaaab");
boolean b = m.matches();

案例一：

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class MyTest {
    public static void main(String[] args) {
        //模式器与匹配器
     //   类 Pattern 模式器  可以封装一个正则表达式

        //模式器
        Pattern p = Pattern.compile("a*b");
        //匹配器
        Matcher m = p.matcher("aaaaab");
        //匹配的方法
        boolean b = m.matches();
        System.out.println(b);


        boolean matches = "aaaaab".matches("a*b");
        System.out.println(matches);


    }
}

案例二：

import com.sun.media.sound.SoftTuning;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class MyTest2 {
    public static void main(String[] args) {
       // 需求：获取下面这个字符串中由三个字符组成的单词
        //da jia ting wo shuo, jin tian yao xia yu, bu shang wan zi xi, gao xing bu?
        String str="da jia ting wo shuo, jin tian yao xia yu, bu shang wan zi xi, gao xing bu?";
        // \b 单词边界
        String regx="\b[a-z]{3}\b";
        //获取模式器
        Pattern p = Pattern.compile(regx);
        //获取匹配器
        Matcher m = p.matcher(str);
        //boolean matches = m.matches();
       // boolean find () 尝试查找与该模式匹配的输入序列的下一个子序列。
       // String group () 返回由以前匹配操作所匹配的输入子序列。
       // boolean b = m.find();
       // if(b){
       //     String s = m.group();
       //     System.out.println(s);
       // }
       // b = m.find();
       // if (b) {
       //     String s = m.group();
       //     System.out.println(s);
       // }
        //先find()后group();
        while (m.find()){
            String s = m.group();
            System.out.println(s);
        }


    }
}

最后

以上就是文艺枕头为你收集整理的正则表达式正则表达式的全部内容，希望文章能够帮你解决正则表达式正则表达式所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。