黑马程序员_正则表达式

------- android培训、java培训、期待与您交流！ ---------

@@正则表达式:符合一定规则的表达式。
作用：用于专门操作字符串。
特点：用于一些特定的符号来表示一些代码操作。这样就简化书写。
所以学习正则表达式，就是在学习一些特殊符号的使用。

好处：可以简化对字符串的复杂操作。
弊端：符号定义越多，正则越长，阅读性越差。

字符类    
[abc]        a、b 或 c（简单类）
[^abc]        任何字符，除了 a、b 或 c（否定）
[a-zA-Z]    a 到 z 或 A 到 Z，两头的字母包括在内（范围）
[a-d[m-p]]    a 到 d 或 m 到 p：[a-dm-p]（并集）
[a-z&&[def]]    d、e 或 f（交集）
[a-z&&[^bc]]    a 到 z，除了 b 和 c：[ad-z]（减去）
[a-z&&[^m-p]]    a 到 z，而非 m 到 p：[a-lq-z]（减去）
 
预定义字符类
.    任何字符（与行结束符可能匹配也可能不匹配）
\d    数字：[0-9]
\D    非数字： [^0-9]
\s    空白字符：[ \t\n\x0B\f\r]
\S    非空白字符：[^\s]
\w    单词字符：[a-zA-Z_0-9]
\W    非单词字符：[^\w]

Greedy 数量词
X?     X，一次或一次也没有
X*     X，零次或多次
X+     X，一次或多次
X{n}     X，恰好 n 次
X{n,}     X，至少 n 次
X{n,m}     X，至少 n 次，但是不超过 m 次

组和捕获
捕获组可以通过从左到右计算其开括号来编号。
例如，在表达式 ((A)(B(C))) 中，存在四个这样的组：
左括号的顺序代表组的顺序

1     ((A)(B(C)))
2     \A
3     (B(C))
4     (C)

组零始终代表整个表达式。



具体操作功能：

1，匹配：public boolean matches(String regex)。
        用规则匹配整个字符串，只要有一处不符合规则，就匹配结束，返回false。
    
2，切割：public String[] split(String regex,int limit)
        如果表达式不匹配输入的任何部分，那么所得数组只具有一个元素，即此字符串。

        limit表示    regex的使用次数为limit-1，
        limit>0,表示regex最多使用limit-1次，数组长度最多为limit次
        limit=0,表示regex使用尽量多次，返回的数组可以是任何长度，数组结尾的所有空字符串将被丢弃。
                相当于    public String[] split(String regex)这个方法
        limit<0,表示regex使用尽量多次，返回的数组可以是任何长度

例子：字符串 "boo:and:foo" 使用这些参数可生成以下结果：

Regex     Limit            结果                数组长度
:        2        { "boo", "and:foo" }        2
:        5        { "boo", "and", "foo" }        3
:        -2        { "boo", "and", "foo" }        3
o        5        { "b", "", ":and:f", "", "" }    5
o        -2        { "b", "", ":and:f", "", "" }    5
o        0        { "b", "", ":and:f" }        3




3，替换： String replaceAll(String regex, String replacement)
          使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
      String replaceFirst(String regex, String replacement)
          使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。

      如果regex中有定义组，可以在第二参数中通过 $组数 来获取正则表达式中的已有组的具体值。


matches例子：对QQ号进行校验！ 5-15位，开头不能为0，其它各位是0-9
    public static void checkQQ()
    {
        String qq = "123a454";

        String regex = "[1-9]\\d{4,14}";

        boolean flag = qq.matches(regex);
        if(flag)
            System.out.println(qq+"...is ok");
        else
            System.out.println(qq+"... 不合法");

    }
split例子:
    public static void splitDemo(String str,String reg)
    {    
        //按照 多个空格 来进行切割
        "wzq  cdd  cs".split(" +");

        //按照 . 来切割，\.代表把.转义了，但是前面的\也需要转义，所以是\\.
        "zhang.lisi.wangwu".split("\\.");

        //按照 \\ 来进行切割
        "c:\\abc\\a.txt".split("\\\\");

        //按照    叠词 切割
        //为了让与规则匹配的具体子串被重用。
        //可以将规则封装成一个组。在regex内 用()完成。组的出现都有编号。
        //从1开始。 想要使用已有的组可以通过  \n(n就是组的编号)的形式来获取。
        "erkktyqqquizzzzzo".split("(.)\\1+");    
    }
replaceAll例子
    public static void replaceDemo(){
        //数组替换成 #
        "wer1389980234564uiod345675f".replaceAll("(.\\1+)","#");

        //将重叠的字符替换成单个字母。zzzzz->z。
        //在regex外 面用 $1 代表了regex中的第一个组的值。
        "erkktyqqquizzzzzo".replaceAll("(.)\\1+","$1");
    }
4：获取    java.util.regex包下

操作步骤：
1，将正则表达式封装成对象。
2，让正则对象和要操作的字符串相关联。
3，关联后，获取正则匹配引擎。
4，通过引擎对符合规则的子串进行操作，比如取出。

获取 例子：
public static void getDemo()
{
    String str = "ming tian jiu yao fang jia le ,da jia。";
    System.out.println(str);
    String reg = "\\b[a-z]{4}\\b";    //  \b代表单词边界

    //将规则封装成对象。
    Pattern p = Pattern.compile(reg);

    //让正则对象和要作用的字符串相关联。获取匹配器对象。
    Matcher m  = p.matcher(str);    
    
    /*
    System.out.println(m.matches());//false，matches方法也进行了一次迭代
    str.matches(reg)就是Pattern.compile(reg).matcher(str).matches();
    其实String类中的matches方法。用的就是Pattern和Matcher对象来完成的。
    只不过被String的方法封装后，用起来较为简单。但是功能却单一。
    */
    
    boolean b = m.find();//进行符合规则的子串一次查找
    System.out.println(b);//有则true，没有则false
    System.out.println(m.group());    //获取到  ming
    //用于获取上次匹配后结果。所以要先匹配！可以匹配的方法有find，
    System.out.println(m.start()+"..."+m.end());// 0...4
    
    /* 与上面的代码只存在一个！那么下面的循环结果正确！
    System.out.println(m.matches());    //false
    matches方法也进行迭代 ,进行一次匹配
    */

    while(m.find())        //类似于迭代器
    {
        System.out.println(m.group()); //tian fang
        System.out.println(m.start()+"..."+m.end());//5...9 18...22
    }
}

到底用四种功能中的哪一个呢？或者哪几个呢？
@@使用regex思路：
1，如果只想知道该字符是否对是错，使用匹配。
2，想要将已有的字符串变成另一个字符串，替换。
3，想要按照自定的方式将字符串变成多个字符串。切割。获取规则以外的子串。
4，想要拿到符合需求的字符串子串，获取。获取符合规则的子串。

例子
需求：
将下列字符串转成：我要学编程.
public static void test_1()
{
    String str = "我我...我我...我要..要要...要要...学学学....学学...编编编...编程..程.程程...程...程";
    /*
    将已有字符串变成另一个字符串。使用 替换功能。
    1，可以先将 . 去掉。
    2，在将多个重复的内容变成单个内容。
    */
    str = str.replaceAll("\\.+","");
    System.out.println(str);

    str = str.replaceAll("(.)\\1+","$1");
    System.out.println(str);
}
需求：
192.68.1.254
102.49.23.013
10.10.10.10
2.2.2.2
8.109.90.30
将ip地址进行地址段顺序的排序。

还按照字符串自然顺序，只要让它们每一段都是3位即可。
1，按照每一段需要的最多的0进行补齐，那么每一段就会至少保证有3位。
2，将每一段只保留3位。这样，所有的ip地址都是每一段3位。

public static void ipSort()
{
    String ip = "192.68.1.254 102.49.23.013 10.10.10.10 2.2.2.2 8.109.90.30";

    ip = ip.replaceAll("(\\d+)","00$1");
    System.out.println(ip);

    ip = ip.replaceAll("0*(\\d{3})","$1");
    System.out.println(ip);

    String[] arr = ip.split(" ",0);
    TreeSet<String> ts = new TreeSet<String>();

    for(String s : arr)
    {
        ts.add(s);
    }

    for(String s : ts)
    {
        System.out.println(s.replaceAll("0*(\\d+)","$1"));
    }
}

需求：对邮件地址进行校验。

public static void checkMail()
{
    String mail = "abc12@sina.com";
    
    String reg = "[a-zA-Z0-9_]+@[a-zA-Z0-9]+(\\.[a-zA-Z]+){1,3}";//较为精确的匹配。
    //String reg = "\\w+@[a-zA-Z0-9]+(\\.[a-zA-Z]+){1,3}"

    System.out.println(mail.matches(reg));
}

@@网页爬虫(蜘蛛)

import java.io.*;
import java.util.regex.*;
import java.net.*;
import java.util.*;
class RegexTest2
{
    public static void main(String[] args) throws Exception
    {
        getMails_1();
    }
    /*
    获取指定文档中的邮件地址。
    使用获取功能。Pattern  Matcher
    */
    public static void getMails()throws Exception
    {
        BufferedReader bufr =
            new BufferedReader(new FileReader("mail.txt"));

        String line = null;

        String mailreg = "\\w+@\\w+(\\.\\w+)+";
        Pattern p = Pattern.compile(mailreg);

        while((line=bufr.readLine())!=null)
        {
            Matcher m = p.matcher(line);
            while(m.find())
            {
                System.out.println(m.group());
            }
        }
    }
    //从网页中获取邮箱
    public static void getMails_1()throws Exception
    {
        URL url = new URL("http://192.168.1.254:8080/myweb/mail.html");

        URLConnection conn = url.openConnection();

        BufferedReader bufIn = new BufferedReader(new InputStreamReader(conn.getInputStream()));
        
        String line = null;

        String mailreg = "\\w+@\\w+(\\.\\w+)+";
        Pattern p = Pattern.compile(mailreg);        

        while((line=bufIn.readLine())!=null)
        {
            Matcher m = p.matcher(line);
            while(m.find())
            {
                System.out.println(m.group());
            }
        }
    }
    
}

------- android培训、java培训、期待与您交流！ ----------