黑马程序员———正则表达式

------ Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

 

 

 

package cn.itcast.Regex;

/*
 * 正则表达式：符合一定规则的表达式。
 *  作用：用于专门操作字符串。
 *  特点：用于一些特定的符号表示一些代码操作，这样就简化书写。
 *   所以学习正则表达式就是在学习一些特殊符号的使用。
 *  好处：可以简化对字符串的复杂操作。
 *  弊端：符号定义越多，正则越长，阅读性越差。
 *  
 *
 *
 * 具体操作功能：
 * 1.匹配：  String  matches()方法 
 *   用规则匹配整个字符串，只要有一处不符合规则，就匹配结束，返回false。
 *
 * 2.切割：String split();
 *
 * 3，替换String replaceAll();
 *
 *
 */
public class RegexDemo
{
 public static void main(String[] args)
 {
  //splitDemo("zhangsan   lisi   wangwu"," +");
  //splitDemo("zhangsan.lisi.wangwu","\\.");
  //splitDemo("C:\\abc\\a.txt","\\\\");
  //splitDemo("deedwwwwwgjlsllr","(.)\\1+");
  //按照叠成完成切割,为了可以让规则的结果可以被重用，可以将规则封装成一个组，让小括号完成，
  //组的出现都有编号，从1开始，那么想要使用已有的组可以通过\n的形式来获取。n就是组的编号。
  //当你想要对你所要的结果重用的时候，可以封装成括号，kk,aa,-->(.)\1  第一位为组，\1，第二位引用第二位;若变为字符串则为："(.)\\1"
  
  String str="wer13800000000faefjdl12212121fjdk32243232322fkj";
  replaceAllDemo(str,"\\d{5,}","#");
  
  String str1="deedwwwwwgjlsllr";//将重叠的字母替换成单个字母，zzzz-->z
  replaceAllDemo(str1,"(.)\\1+","$1");//$1 就是拿前面规则的第一个组
 }
 
 //替换
 public static void replaceAllDemo(String str,String reg,String newStr)
 {
  str=str.replaceAll(reg, newStr);
  sop(str);
 }
 
 //切割
 public static void splitDemo(String str,String reg)
 {
  /*String str="zhangsan   lisi   wangwu";
  String reg=" +";//按照一个或多个空格进行切割*/
  
  /*String str="zhangsan.lisi.wangwu";
  String reg="\\.";//.为特殊符号，代表任意字符，所以加反斜杠、、代表不同字符.*/
  
  String[] arr=str.split(reg);
  for(String s:arr)
  {
   sop(s);
  }
 }
 /*
  * 匹配：手机号段：13XX  15XX 18XX  11位
  */
 public static void checkTel()
 {
  String tel="13222222222";
  String telReg="1[358]\\d{9}";
  sop(tel.matches(telReg));
 }
 //示例：
 public static void demo()
 {
  String str="b23a34343";
  String reg="[a-zA-Z\\d*";
  boolean b=str.matches(reg);
  sop(b);
 }
 /*
  * 对qq号进行校验，
  * 要求：5~15位，0不能为开头，只能是数字
  */
 public static void checkQQ()
 {
  String qq="100086";
  
  String regex="[1-9]\\d{4,14}";
  
  boolean flag=qq.matches(regex);
  if(flag)
   sop(qq+"合法");
  else
   sop(qq+"非法");
 }
 
 public static void checkQQ_1()
 {
  String qq="";
  int len=qq.length();
  if(len>=5&&len<=15)
  {
   if(!qq.startsWith("0"))
   {
    try
    {
     long l=Long.parseLong(qq);
     sop("qq:"+l);
    }
    catch(NumberFormatException e)
    {
     sop("出现非法字符");
    }
   }
    /*
    char[] arr=qq.toCharArray();
    boolean flag=true;
    for(int x=0;x<arr.length;x++)
    {
     if(!(arr[x]>'0' && arr[x]<='9'))
     {
      flag=false;
      break;
     }
     if(flag)
     {
      sop("qq:"+qq);
     }
     else
     {
      sop("出现非法字符");
     }
    }
   }
   
   else
   {
    sop("开头不能为0");
   }
   */
  }
  else
  {
   sop("长度非法");
  }
 }
 public static void sop(Object obj)
 {
  System.out.println(obj);
 }
}

 

/*
字符类
[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)

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

之所以这样命名捕获组是因为在匹配中，保存了与这些组匹配的输入序列的每个子序列。
捕获的子序列稍后可以通过 Back 引用在表达式中使用，也可以在匹配操作完成后从匹配器获取。

与组关联的捕获输入始终是与组最近匹配的子序列。如果由于量化的缘故再次计算了组，
则在第二次计算失败时将保留其以前捕获的值（如果有的话）例如，将字符串 "aba" 与表达式 (a(b)?)+ 相匹配，
会将第二组设置为 "b"。在每个匹配的开头，所有捕获的输入都会被丢弃。

以 (?) 开头的组是纯的非捕获 组，它不捕获文本，也不针对组合计进行计数。

Unicode 支持
*/

==========================================================================

package cn.itcast.Regex;

/*
 * 正则表达式的第四个功能：
 * 4获取：将字符串中符合规则的子串取出。
 *
 * 操作步骤：
 * 1.将正则表达式封装成对象。
 * 2.让正则对象和要操作的字符串相关联。
 * 3.关联后，获取正则匹配引擎。
 * 4.通过引擎对符合规则的子串进行操作。比如：取出
 *   
 */
import java.util.regex.*;
public class RegexDemo2
{
 public static void main(String[] args)
 {
  getDemo();
 }
 
 public static void getDemo()
 {
  String str = "ming tian jiu yao fang jia la , da jia.";
  String reg = "\\b[a-z]{4}\\b";
  
  //将规则封装成对象
  Pattern p = Pattern.compile(reg);
  
  //让正则对象和要作用的字符串相关联，获取匹配器对象。
  Matcher m = p.matcher(str);//
  
  //System.out.println(m.matches());其实String类的matches方法，用的就是Pattern和Matcer对象来完成。
          //只不过被String的方法封装后，用起来较为简单，但功能单一。
  
  
  while(m.find())//将规则作用到字符串上，并进行符合规则的子串查找
  {
   System.out.println(m.group());//用于获取匹配后的结果
   System.out.println(m.start()+".."+m.end());//获取
   
   /*start()
           返回以前匹配的初始索引。
   end()
           返回最后匹配字符之后的偏移量。*/
  }
 }
}
/*
static Pattern compile(String regex)
          将给定的正则表达式编译到模式中。
         
          边界匹配器
^ 行的开头
$ 行的结尾
\b 单词边界
\B 非单词边界
\A 输入的开头
\G 上一个匹配的结尾
\Z 输入的结尾，仅用于最后的结束符（如果有的话）
\z 输入的结尾

 

 

正则表达式的编译表示形式。

指定为字符串的正则表达式必须首先被编译为此类的实例。然后，可将得到的模式用于创建 Matcher 对象，依照正则表达式，该对象可以与任意字符序列匹配。执行匹配所涉及的所有状态都驻留在匹配器中，所以多个匹配器可以共享同一模式。

因此，典型的调用顺序是

 Pattern p = Pattern.compile("a*b");
 Matcher m = p.matcher("aaaaab");
 boolean b = m.matches();在仅使用一次正则表达式时，可以方便地通过此类定义 matches 方法。此方法编译表达式并在单个调用中将输入序列与其匹配。语句

 boolean b = Pattern.matches("a*b", "aaaaab");
 
 
 
 
 通过解释 Pattern 对 character sequence 执行匹配操作的引擎。

通过调用模式的 matcher 方法从模式创建匹配器。创建匹配器后，可以使用它执行三种不同的匹配操作：

matches 方法尝试将整个输入序列与该模式匹配。

lookingAt 尝试将输入序列从头开始与该模式匹配。

find 方法扫描输入序列以查找与该模式匹配的下一个子序列。

*/

------ Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------