正则表达式贪婪模式，单词边界 ，多行模式，子表达式（java版）

@Test
           public void test3(){
             //参考博客：http://blog.csdn.net/gnail_oug/article/details/51260216
               // 正则表达式知识详解之贪婪模式和非贪婪模式 (java版示例)   
             //提取td元素里的内容
               String str="<table><tr><td>hello world</td><td>hello regex</td></tr></table>";

               //贪婪模式   * + {n,} 默认情况下是贪婪模式匹配
               System.out.println("======贪婪模式=======");
               Pattern p=Pattern.compile("<td>.*</td>");
               Matcher m=p.matcher(str);
               while(m.find()){
                   System.out.println(m.group()+"   位置：["+m.start()+","+m.end()+"]");

               }
               System.out.println("======非贪婪模式=======");
             //非贪婪模式，?跟在 * + {n,} 等的后面时，表示非贪婪模式，注意和子表达式后面的?区分开，子表达式后的?表示匹配0次或1次
                   p=Pattern.compile("<td>.*?</td>"); 
                   m=p.matcher(str);

                   while(m.find()){
                       System.out.println(m.group()+"   位置：["+m.start()+","+m.end()+"]");

                   }
           }

@Test
           public void test5(){
            /**   示例功能： 
               1、单词两边都不设置边界 
               2、单词两边都设置边界 
               3、左边设置边界 
               4、右边设置边界*/
               // 正则表达式知识详解之单词边界 (java版示例)   
               //http://blog.csdn.net/gnail_oug/article/details/51260347
               String str="the cat scattered his food catch mcat";

               System.out.println("----不设置边界-----");
               Pattern p=Pattern.compile("cat");
               Matcher m=p.matcher(str);
               while(m.find()){
                   System.out.println(m.group()+"   位置：["+m.start()+","+m.end()+"]");
               }

               // \b匹配单词边界，换句话说，\b是匹配一个位置，这个位置位于一个能够用来构成单词的字符
               // (字母、数字和下划线，也就是\w相匹配的字符)和一个不能用来构成单词的字符(也就是与\W相匹配的字符)之间。
               System.out.println("----两边都设置边界-----");
               p=Pattern.compile("\\bcat\\b");
               m=p.matcher(str);
               while(m.find()){
                   System.out.println(m.group()+"   位置：["+m.start()+","+m.end()+"]");
               }

               System.out.println("----左边设置边界-----");
               p=Pattern.compile("\\bcat");
               m=p.matcher(str);
               while(m.find()){
                   System.out.println(m.group()+"   位置：["+m.start()+","+m.end()+"]");
               }

               System.out.println("----右边设置边界-----");
               p=Pattern.compile("cat\\b");
               m=p.matcher(str);
               while(m.find()){
                   System.out.println(m.group()+"   位置：["+m.start()+","+m.end()+"]");
               }

           }

@Test
           public  void test6(){
               /**
                 * 多行模式
                 *
                 * 
                 */
                    //注意里面的换行符
                    String str="hello world\r\nhello java\r\nhello java";

                    System.out.println("===========匹配字符串开头(多行模式)===========");
                    Pattern p=Pattern.compile("^hello",Pattern.MULTILINE);//MULTILINE 翻译出来就是多行 
                    Matcher m=p.matcher(str);
                    while(m.find()){
                        System.out.println(m.group()+"   位置：["+m.start()+","+m.end()+"]");
                    }

                    System.out.println("===========匹配字符串结尾(多行模式)===========");
                    p=Pattern.compile("java$",Pattern.MULTILINE);
                    m=p.matcher(str);
                    while(m.find()){
                        System.out.println(m.group()+"   位置：["+m.start()+","+m.end()+"]");
                    }
                                                         /**结果：
                                                         ===========匹配字符串开头(多行模式)===========
                                                         hello   位置：[0,5]
                                                         hello   位置：[13,18]
                                                         hello   位置：[25,30]
                                                         ===========匹配字符串结尾(多行模式)===========
                                                         java   位置：[19,23]
                                                         java   位置：[31,35]*/
                }

@Test
           public void subexpression(){
               //正则表达式知识详解之子表达式 (java版示例)  http://blog.csdn.net/gnail_oug/article/details/51276455 
               注意里面的空格 ，假如要匹配两个 以上的空格  
               String str="hello  world,hello   java"; //两个空格    三个空格

               Pattern p=Pattern.compile(" {2,}");  //一个空格
               Matcher m=p.matcher(str);
               while(m.find()){
                   System.out.println(m.group()+"   位置：["+m.start()+","+m.end()+"]");  
               }
               //参考博客说这里应该不会匹配到东西   但是我的能........................
               System.out.println("========================切割线======");
             //使用子表达式,将 作为一个整体  
                  p=Pattern.compile("( ){2,}");  
                 m=p.matcher(str);  
                 while(m.find()){  
                       System.out.println(m.group()+"   位置：["+m.start()+","+m.end()+"]");  
                  }  
               //匹配ip地址(这里我不考虑大于255的情况，只要是1-3个数字都匹配)
                str="121.22.125.32,1.212.5.132";
                System.out.println("==========匹配IP地址==========");
                //普通方式匹配
                System.out.println("----------普通方式----------");
                p=Pattern.compile("\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}");
                m=p.matcher(str);
                while(m.find()){
                    System.out.println(m.group()+"   位置：["+m.start()+","+m.end()+"]");
                }
                //子表达式方式匹配
                System.out.println("----------子表达式方式----------");
                //由于上面的正则表达式中\\d{1,3}\\.重复了3次，所以可以用子表达式简化，匹配结果与上面相同
                p=Pattern.compile("(\\d{1,3}\\.){3}\\d{1,3}");
                m=p.matcher(str);
                while(m.find()){
                    System.out.println(m.group()+"   位置：["+m.start()+","+m.end()+"]");
                }

                //上面匹配 空格和匹配IP的两个例子，都使用了子表达式，子表达式其中一个用途就是把多个元字符或字符用小括号
                //括起来，作为一个整体(可以当成一个字符理解)，方便使用* + {n,m}等规则
                //子表达式也可以嵌套使用，下面还是通过匹配IP(不匹配大于255的IP)的例子来说明

                //合法IP地址的规则：
                //1、任何一个1位或2为的数字，即0-99
                //2、任何一个以1开头的3位数字，即100-199
                //3、任何一个以2开头并且第2位数字在0-4之间的3位数字，即200-249
                //4、任何一个以25开头并且第3位数字在0-5之间的3位数字，即250-255
                System.out.println("----------匹配合法的IP地址----------");
                str="121.22.125.32,10.212.5.132,260.33.22.44,23.45.600.4";
                //这里IP两边增加了边界匹配，如果不加类似于260.33.22.44可以匹配到60.33.22.44
                p=Pattern.compile("\\b((\\d{1,2}|1\\d{2}|2[0-4]\\d|25[0-5])\\.){3}(\\d{1,2}|1\\d{2}|2[0-4]\\d|25[0-5])\\b");
                m=p.matcher(str);
                while(m.find()){
                    System.out.println(m.group()+"   位置：["+m.start()+","+m.end()+"]");
                }


            }