正则表达式-java

1.用正则表达式心里得有两个东西的概念。第一是字符串（String），即正则表示式合作的对象。第二，正则，即需要根据规则，写一个符合条件的正则。

2.查看API

3.字符类（Character classes）

（1）[ab] ：有两个条件，第一是字符串中有满足a或b的字符，第二是字符串只能是一个字符

String regex="[abc]";
        String  a="a";
        String a1="b";
        String  a2="abc";
        System.out.print(a.matches(regex)+" ");
        System.out.print(a1.matches(regex)+" ");
        System.out.print(a2.matches(regex)+" ");
    //    true true false

（2）[^ab]：有两个条件，第一是含有除了a，b之外的字符，第二是字符串只能是一个字符

String regex="[^abc]";
        String  a="dd";
        String a1="d";
        String  a2="b";
        System.out.print(a.matches(regex)+" ");
        System.out.print(a1.matches(regex)+" ");
        System.out.print(a2.matches(regex)+" ");
        //false true false

（3）[A-Z]：有两个条件，第一是字符串只能是一个字符，第二是大写字母A-Z中的一个

String regex="[A-Z]";
        String  a="GG";
        String a1="D";
        String  a2="3";
        System.out.print(a.matches(regex)+" ");
        System.out.print(a1.matches(regex)+" ");
        System.out.print(a2.matches(regex)+" ");
        //false true false

[a-z]：有两个条件，第一是字符串只能是一个字符，第二是小写字母a-z中的一个

String regex="[a-z]";
        String  a="dd";
        String a1="d";
        String  a2="A";
        System.out.print(a.matches(regex)+" ");
        System.out.print(a1.matches(regex)+" ");
        System.out.print(a2.matches(regex)+" ");
        //false true false 

String regex="[a-zA-Z]";
        String  a="a";
        String a1="D";
        String  a2="A";
        System.out.print(a.matches(regex)+" ");
        System.out.print(a1.matches(regex)+" ");
        System.out.print(a2.matches(regex)+" ");
        //true true true 
String regex="[A-Za-z]";
        String  a="a";
        String a1="D";
        String  a2="A";
        System.out.print(a.matches(regex)+" ");
        System.out.print(a1.matches(regex)+" ");
        System.out.print(a2.matches(regex)+" ");
        //true true true
String regex="[A-z]";
        String  a="a";
        String a1="D";
        String  a2="A";
        System.out.print(a.matches(regex)+" ");
        System.out.print(a1.matches(regex)+" ");
        System.out.print(a2.matches(regex)+" ");
        //true true true 
    String regex="[a-f]";
        String  a="a";
        String a1="B";
        String  a2="g";
        System.out.print(a.matches(regex)+" ");
        System.out.print(a1.matches(regex)+" ");
        System.out.print(a2.matches(regex)+" ");
        //true false false
String regex="[a-fh-m]";
        String  a="a";
        String a1="l";
        String  a2="g";
        System.out.print(a.matches(regex)+" ");
        System.out.print(a1.matches(regex)+" ");
        System.out.print(a2.matches(regex)+" ");
        //true true false
String regex="[a-fk]";
        String  a="a";
        String a1="l";
        String  a2="k";
        System.out.print(a.matches(regex)+" ");
        System.out.print(a1.matches(regex)+" ");
        System.out.print(a2.matches(regex)+" ");
        //true false true

（4）[A-Z[a-z]]：第一总的输出结果还是只能是一个字符，第二该字符串可以是A-Z或者a-z的任意一个字符

String regex="[a-f[h-m]]";
        String  a="a";
        String a1="l";
        String  a2="g";
        System.out.print(a.matches(regex)+" ");
        System.out.print(a1.matches(regex)+" ");
        System.out.print(a2.matches(regex)+" ");
        //true true false

（5)[ab&&b]:第一是字符串只能是一个字符，第二该结果是&&两边的交集。

    String regex="[acb&&bc]";
        String  a="a";
        String a1="b";
        String  a2="c";
        System.out.print(a.matches(regex)+" ");
        System.out.print(a1.matches(regex)+" ");
        System.out.print(a2.matches(regex)+" ");
        //false true true

这个复杂的问题可以画数轴线来判断

4.Predefined character classes(预定义字符类)

（1）.（点）：第一，表示任意字符，不是字面上的点（这样就不能用来判读只能有点的字符串了）（但是在[]里面点就只是字面量了）

第二，一个点表示一个字符。如果有两个点，那么字符串必须是两个

String regex=".";
        String  a=".";
        String a1="b";
        String  a2="c";
        System.out.print(a.matches(regex)+" ");
        System.out.print(a1.matches(regex)+" ");
        System.out.print(a2.matches(regex)+" ");
        //true true true 
    String regex="[.d]";
        String  a=".";
        String a1="d";
        String  a2="c";
        System.out.print(a.matches(regex)+" ");
        System.out.print(a1.matches(regex)+" ");
        System.out.print(a2.matches(regex)+" ");
        //true true false 
    String regex="..";
        String  a=".";
        String a1="dd";
        String  a2="c";
        System.out.print(a.matches(regex)+" ");
        System.out.print(a1.matches(regex)+" ");
        System.out.print(a2.matches(regex)+" ");
        //false true false

（2）\.：表示符合.的字符串(在这里\只是一个字符的存在，但是在字符串里\是作为转义字符，我们需要的不是转义字符，所以写的时候需要两个\\)

String regex="\\.";
        String  a=".";
        String a1="dd";
        String  a2="c";
        System.out.print(a.matches(regex)+" ");
        System.out.print(a1.matches(regex)+" ");
        System.out.print(a2.matches(regex)+" ");
        //true false false

（3）\d:跟[0-9]相同

String regex="\\d";
        String  a="10";
        String a1="4";
        String  a2="c";
        System.out.print(a.matches(regex)+" ");
        System.out.print(a1.matches(regex)+" ");
        System.out.print(a2.matches(regex)+" ");
        //false true false

（4）\D:跟[^0-9]相同（注意也只能是一个字符）

String regex="\\D";
        String  a="10";
        String a1="4";
        String  a2="c";
        System.out.print(a.matches(regex)+" ");
        System.out.print(a1.matches(regex)+" ");
        System.out.print(a2.matches(regex)+" ");
        //false false true

（5）\s：表示一个字符；表示一个空字符；tab也是一个空白字符

    String regex="\\s";
        String  a="";
        String a1=" ";
        String  a2="    ";//tab
        System.out.print(a.matches(regex)+" ");
        System.out.print(a1.matches(regex)+" ");
        System.out.print(a2.matches(regex)+" ");
        //false true true

（6）\S:跟[^\s]等价

String regex="\\S";
String a="s";
String a1=" ";
String a2="2";
System.out.print(a.matches(regex)+" ");
System.out.print(a1.matches(regex)+" ");
System.out.print(a2.matches(regex)+" ");
//true false true

（7）\w:等价于[a-zA-Z_0-9]

    String regex="\\w";
        String  a="d";
        String a1="_";
        String  a2="2";
        System.out.print(a.matches(regex)+" ");
        System.out.print(a1.matches(regex)+" ");
        System.out.print(a2.matches(regex)+" ");
        //true true true

(8)\W:[^\w]

        String regex="\\W";
        String  a="d";
        String a1="_";
        String  a2="*";
        System.out.print(a.matches(regex)+" ");
        System.out.print(a1.matches(regex)+" ");
        System.out.print(a2.matches(regex)+" ");
        //true true true

5.Greedy quantifiers(数量词)

（1）？：表示满足条件或者字符串为空

String regex="[ab]?";
        String  a="";
        String a1="a";
        String  a2="d";
        System.out.print(a.matches(regex)+" ");
        System.out.print(a1.matches(regex)+" ");
        System.out.print(a2.matches(regex)+" ");
        //true true false

（2）*：表示没有也可以，有也可以，有多个也可以

String regex="[ab]*";
        String  a="";
        String a1="aa";
        String  a2="d";
        System.out.print(a.matches(regex)+" ");
        System.out.print(a1.matches(regex)+" ");
        System.out.print(a2.matches(regex)+" ");
        //true true false

（3）+：一次或多次

    String regex="[ab]+";
        String  a="";
        String a1="aa";
        String  a2="d";
        System.out.print(a.matches(regex)+" ");
        System.out.print(a1.matches(regex)+" ");
        System.out.print(a2.matches(regex)+" ");
        //false true false

（4）{n}：就规定有n次（出现的字符只要满足要求，不规定必须出现的是同一个字符）

        String regex="[ab]{3}";
        String  a="abb";
        String a1="aaa";
        String  a2="aaab";
        System.out.print(a.matches(regex)+" ");
        System.out.print(a1.matches(regex)+" ");
        System.out.print(a2.matches(regex)+" ");
        //true true false

（5）{n，}：至少n次

String regex="[ab]{3,}";
        String  a="abb";
        String a1="aaa";
        String  a2="aaab";
        System.out.print(a.matches(regex)+" ");
        System.out.print(a1.matches(regex)+" ");
        System.out.print(a2.matches(regex)+" ");
        //true true true

（6）{m，n}：包含m，n在内的次数范围

    String regex="[ab]{3,4}";
        String  a="ab";
        String a1="aaa";
        String  a2="aaab";
        System.out.print(a.matches(regex)+" ");
        System.out.print(a1.matches(regex)+" ");
        System.out.print(a2.matches(regex)+" ");
        //false true true

6.拆分字符串

（1）根据空字符串拆分字符串

String a="my name is sun";
        String [] arr=a.split(" ");
        for(int i=0;i<arr.length;i++) {
            System.out.println(arr[i]);

        }
/*
my
name
is
sun
*/

（2）根据点来拆分

String a="my.name.is.sun";

        String [] arr=a.split("\\.");
        for(int i=0;i<arr.length;i++) {
            System.out.println(arr[i]);
        }
          /*
           * my
            name
            is
             sun
           */
String a="my.name.is.sun";

        String [] arr=a.split(".");
        for(int i=0;i<arr.length;i++) {
            System.out.println(arr[i]);
        }      //表示里面的每一个字符都被消去，所以最后是什么都没有

7.排序字符串（需要将字符串切割成数组才能排序）

String a="12 45 56 78 5 8 10";
        String b[]=a.split(" ");
        int arr[] =new int[b.length];
        for(int i=0;i<arr.length;i++) {
            arr[i]=Integer.parseInt(b[i]);
        }
        Arrays.sort(arr);
         String atr="";
         for(int i=0;i<arr.length;i++) {
             if(i==arr.length-1)
                 atr=atr+arr[i];
             else atr=atr+arr[i]+" ";
         }
         System.out.println(atr);
         //5 8 10 12 45 56 78

8.替换功能

String s="ef43vft65";
        String m=s.replaceAll("\\d", "");
        System.out.println(m);

//efvft

9.组（分组就是针对重复的字符的解决办法）（就是一个字符同时出现多少次的方法，上面都没提到）

String regex="(...)\\1";
        String a="&*(&*(";

        System.out.println(a.matches(regex));
String regex="(.)\\1+";
        String a="asssdfflgggm";
        String[] b=a.split(regex);
        for(int i=0;i<b.length;i++)
        System.out.println(b[i]);

/*
a
d
l
m
*/
String regex="\\.";
        String a="m...m..yy..nnaa..mme..iiiss.sun.";
        String m=a.replaceAll(regex,"").replaceAll("(.)\\1+", "$1");
        System.out.println(m);//mynameisun

出现几个点本来就要出现几个字符，然后用括号标志起来就成为一个整体，看作一个字符，不能拆分，然后后面说重复一次，字符个数就翻一倍，而且前后两组都应该相同。

10.在一个字符串里获取我们需要的一定规则的字符串（也就是我们的正则的对象是在一个字符串里面，不是整个字符串）

String regex="(..)\\1+";
        Pattern p=Pattern.compile(regex);

        Matcher m=p.matcher("每天我都是欢喜欢喜的，我很开心");
        m.find();
        System.out.println(m.group());
    //欢喜欢喜
时间： 2024-10-27 13:03:17

正则表达式-java的相关文章

匹配html img 标签的正则表达式 java

public static void main(String[] args) { String regex = "<\\s*img(.+?)src=[\"'](.*?)[\"']\\s*/?\\s*>"; Pattern pattern = Pattern.compile(regex, Pattern.MULTILINE); String content = "<img width=\"450\" height=\&q

正则表达式 java版

众所周知,在程序开发中,难免会遇到需要匹配.查找.替换.判断字符串的情况发生,而这些情况有时又比较复杂,如果用纯编码方式解决,往往会浪费程序员的时间及精力.因此,学习及使用正则表达式,便成了解决这一矛盾的主要手段. 大 家都知道,正则表达式是一种可以用于模式匹配和替换的规范,一个正则表达式就是由普通的字符(例如字符a到z)以及特殊字符(元字符)组成的文字模式,它 用以描述在查找文字主体时待匹配的一个或多个字符串.正则表达式作为一个模板,将某个字符模式与所搜索的字符串进行匹配.  自从jdk1.4

正则表达式——Java程序员懂你

正则表达式 关键字:正则表达式,Pattern,Matcher,字符串方法,split,replace 前文书立下了一个flag,这里要把它完成,就是正则表达式,它是一个工具,是很早就存在于标准Unix工具集之中的,例如sed和awk.然而不经常使用Unix系统的程序员们依然能够在JavaScript,java,python,perl等等地方看到它,每当我们看到手指纷飞的他人写着精妙的一小撮正则就干了我们好几篇的校验代码的时候,心里默默升起一股羡慕之情,同时只能赶紧把这一小撮正则保存下来,下次好

Java正则表达式java.util.regex类的简单使用

1.什么是正则表达式? 正则表达式(regular expression)是根据字符串集合内每个字符串共享的共同特性来描述字符串集合的一种途径.正则表达式可以用于搜索.编辑或者处理文本和数据. Java.util.regex主要包含以下三类: pattern类: pattern 对象是一个正则表达式的编译表示.Pattern 类没有公共构造方法.要创建一个 Pattern 对象,你必须首先调用其公共静态编译方法,它返回一个 Pattern 对象.该方法接受一个正则表达式作为它的第一个参数. Ma

正则表达式&lt;JAVA&gt;

正则表达式(JAVA) #什么是正则表达式? 正则表达式是一种被用于从文本中检索符合某些特定模式的文本. **元字符** 1. " . " 匹配除换行符外的任意字符 2. " [] " 字符类,匹配方括号内的任意字符 3. " [^] " 否定字符类,匹配除方括号外的所有字符 4. " * " 匹配前面的字符零次或多次 5. " + " 匹配前面的字符一次或多次 6. " ? "  匹配

正则表达式(java)规则大全

一.校验数字的表达式 1 数字:^[0-9]*$2 n位的数字:^\d{n}$3 至少n位的数字:^\d{n,}$4 m-n位的数字:^\d{m,n}$5 零和非零开头的数字:^(0|[1-9][0-9]*)$6 非零开头的最多带两位小数的数字:^([1-9][0-9]*)+(.[0-9]{1,2})?$7 带1-2位小数的正数或负数:^(\-)?\d+(\.\d{1,2})?$8 正数.负数.和小数:^(\-|\+)?\d+(\.\d+)?$9 有两位小数的正实数:^[0-9]+(.[0-9]

密码校验正则表达式(java 环境)

密码校验需求: 1) 密码控制只能输入字母.数字.特殊符号([email protected]#$%^&*()_+[]{}|\;:'",./<>?)2) 长度 6-16 位,必须包括字母.数字.特殊符号中的2种 判断密码是否包含数字:包含返回1,不包含返回0int i = newPwd.matches(".*\\d+.*") ? 1 : 0; 判断密码是否包含字母:包含返回1,不包含返回0int j = newPwd.matches(".*[a-

JAVA正则表达式：Pattern类与Matcher类详解(转)

java.util.regex是一个用正则表达式所订制的模式来对字符串进行匹配工作的类库包.它包括两个类:Pattern和Matcher Pattern 一个Pattern是一个正则表达式经编译后的表现模式. Matcher 一个Matcher对象是一个状态机器,它依据Pattern对象做为匹配模式对字符串展开匹配检查. 首先一个Pattern实例订制了一个所用语法与PERL的类似的正则表达式经编译后的模式,然后一个Matcher实例在这个给定的Pattern实例的模式控制下进行字符串的匹配工作

JAVA正则表达式：Pattern类与Matcher类详解

java.util.regex是一个用正则表达式所订制的模式来对字符串进行匹配工作的类库包.它包括两个类:Pattern和Matcher Pattern 一个Pattern是一个正则表达式经编译后的表现模式. Matcher 一个Matcher对象是一个状态机器,它依据Pattern对象做为匹配模式对字符串展开匹配检查. 首先一个Pattern实例订制了一个所用语法与PERL的类似的正则表达式经编译后的模式,然后一个Matcher实例在这个给定的Pattern实例的模式控制下进行字符串的匹配工作