学习笔记——正则

一、学习重点

 

二、学习内容

import java.net.Socket;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashSet;
import java.util.stream.Collectors;

public class Ch01 implements Comparable {

    public static void show() throws Exception {
        int i = 0;
        if(i < 10){
            throw new Exception();
        }
    }

    public static void main(String[] args) {
        Collection collection = new ArrayList();
        Collection collection1 = new HashSet();

    }

    @Override
    public int compareTo(Object o) {
        return 0;
    }
}

 

import org.junit.Test;

import javax.lang.model.type.ArrayType;
import java.io.Serializable;
import java.util.*;

public class Ch02 implements Serializable {

    @Test
    public void test03() {
        Map<String, String> map = new HashMap<>();
        map.put("1001","aaa");
        map.put("1002","bbb");
        map.put("1003","ccc");
        map.put("1004","ddd");

        // 1.使用keySet先拿到所有的key，再根据key获取value
        Set<String> keys = map.keySet();
        for (String key : keys) {
            System.out.println(key + "->" + map.get(key));
        }

        // 2.使用内部类Entry（推荐）
        for (Map.Entry<String, String> entry : map.entrySet()) {
            System.out.println(entry.getKey() + entry.getValue());
        }

    }

    @Test
    public void test02() {
        Set<String> set = new HashSet<>();
        set.add("a");
        set.add("b");
        set.add("c");
        set.add("d");
        set.add("e");
        set.add("f");

        // 1.增强for循环
        for (String s : set) {
            // TODO
        }

        // 2.迭代器
        Iterator<String> iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

    @Test
    public void test01(){

        List<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        list.add("f");

        // 1.for循环
        for (int i = 0; i < list.size(); i++) {
            // TODO
        }
        // 2.增强for循环
        for (String s : list) {
            // TODO
        }
        // 3.迭代器
        Iterator<String> iterator = list.iterator();
        while(iterator.hasNext()) {
            System.out.println(iterator.next());
        }

    }

}

 

三、笔记内容

正则表达式
从一个文章中找到所有的邮箱
看看输入的手机号是否合法
身份证号
又叫做规则表达式，Regular Expression Regex
判断字符串，核心功能处理文本
正则表达式不局限于某一种语言。
Hello World
元字符
.：匹配除了换行符之外的任意字符
\w：匹配字符或数字或下划线或汉字
\s：空格
\d：匹配数字
\b：匹配单词的开始或结束
^：匹配字符串的开始
$：匹配字符串的结束
匹配8位数字的QQ号：^\d\d\d\d\d\d\d\d$
匹配1开头11位数：^1\d\d\d\d\d\d\d\d\d\d$
重复限定符
*：重复零次或更多次
+：重复一次或更多次
?：重复零次或一次
{n}：重复n次
{n,}：重复n次或更多次
{n,m}：重复n到m次
匹配8位数字的QQ号：^\d{8}$
匹配1开头11位数手机号：^1\d{10}$
银行卡号14~18位：^\d{14,18}$
匹配以a开头，0个或多个b结尾的字符串^ab*$
分组
限定符的作用与它相邻的最左边的一个字符起作用，那么问题来了，
如果我想要ab同时被限定怎么办？
正则表达式中可以用小括号来分组，括号内的内容会作为一个整体。
^(ab)*$
转义
匹配字符串中包含0到多个(ab)开头：^((\ab\))*
条件
手机号：
联通：130 131 132 134 155 156 185 186
匹配一个联通的手机号。或
| 单或
联通手机号：^(130|131|132|134|155|156|185|186)\d{8}$
区间：
正则表达式提供了一个[]来表示区间
0~9：[0-9]
A~Z：[A-Z]
限定某些数字：[130]
^((13[0-2])|(15[5-6])|(18(5-6)))\d{8}$
反义：
\W：不是字母、数字，下划线、中文
\S：不是空格
\D：不是数字
\B：不是单词开头或结束
[^x]：除了x以外的任意字符
[^aeiou]：匹配除了aeiou的任意字符
常见的正则表达式：
匹配中文的字符：[]，匹配的时ASCII码
175367745@qq.com
abcdfeg-xxx@163.com.cn
邮箱：^[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)+$
国内的电话号码： 0431-81234567 010-81234567 021-12345678
^\d{3,4}-\d{8}$
QQ号：^[1-9][0-9]{4,11}$
220122199009091234
身份证号：
^[1-9]\d{5}(18|19|([23]\d))\d{2}((0[1-9])|(10|11|12))(([0-2][1-9])|10|20|30|31)\\d{3}[0-9Xx]$

public class Ch01 {

    public static void main(String[] args) {
//        String reg = "^\\d{8}";
//        System.out.println((int)'吉');
        System.out.println("\\");
        System.out.println("\\\\");
    }
}

Pattern类
Matcher类
PatternSyntaxException类

    @Test
    public void test06() {
        String regex = "[-_]";
        String str = "123-4756_qweqwe-7987_465";
        String[] split = str.split(regex);
        System.out.println(Arrays.toString(split));
    }

    @Test
    public void test05(){
        String regex = "\\d";
        String str = "1111c2222d456456456f465gh987897";

        String s = str.replaceAll(regex, "@");
        System.out.println(s);
    }

    @Test
    public void test04() {
        String regex = "^[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+(\\.[a-zA-Z0-9_-]+)+$";
        String email = "175367745@qq.com";
        System.out.println(email.matches(regex));
    }

    @Test
    public void test03() {
        String regex = "a";
        String str = "cat cat dog dog cat";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(str);

        // 统计cat在字符串中出现的次数
        int count = 0;
        System.out.println(matcher.find(str.length() - 1));
        while(matcher.find()){
            count++;
        }
        System.out.println("出现了" + count + "次");
    }

    @Test
    public void test02() {
        String regex = "^[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+(\\.[a-zA-Z0-9_-]+)+$";
        String email = "175367745@qq.";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(email);
        System.out.println(matcher.matches());
    }

    @Test
    public void test01() {
        String str = "hello,i am from jilin changchun!";
        // 必须包含jilin
        String pattern = ".*jilina.*";
        boolean b = Pattern.matches(pattern,str);
        System.out.println("字符串中是否包含了jilin：" + b);
    }