精华内容
下载资源
问答
  • java正则表达式在字符串中截取数字

    千次阅读 2019-04-26 10:28:35
    例如字符串:20元/周 100元/一年 获取字符串中的价格,因为价格不稳定无法通过... //匹配非数字字符,然后全部替换为空字符,剩下的自然只有数字啦 String s = Pattern.compile("[^0-9]").matcher(code).replac...

    例如字符串:
    20元/周
    100元/年

    想要获取字符串中的价格,因为价格不稳定无法通过subString来截取,只能匹配其中的数字。
    代码:

    		String code = "100元/年";
            //匹配非数字字符,然后全部替换为空字符,剩下的自然只有数字啦
            String s = Pattern.compile("[^0-9]").matcher(code).replaceAll("");
            //打印结果 100
            System.out.println(s);
    
    展开全文
  • 在本题中,匹配是指字符串的所有字符匹配整个模式。例如,字符串”aaa”与模式”a.a”和”abaca”匹配,但与”aa.a”和”ab*a”均不匹配。s 可能为,且只包含从 a-z 的小写字母。p 可能为,且只包含从 a-z 的...

    难度 困难

    a1b0ebdd7eb16dc6442037029a7bf0b2.png

    请实现一个函数用来匹配包含’. ‘和’*‘的正则表达式。模式中的字符’.’表示任意一个字符,而’*‘表示它前面的字符可以出现任意次(含0次)。在本题中,匹配是指字符串的所有字符匹配整个模式。例如,字符串”aaa”与模式”a.a”和”abaca”匹配,但与”aa.a”和”ab*a”均不匹配。

    s 可能为空,且只包含从 a-z 的小写字母。

    p 可能为空,且只包含从 a-z 的小写字母以及字符 . 和 *,无连续的 '*'。

    示例 1:

    输入:

    s = “aa”

    p = “a”

    输出: false

    解释: “a” 无法匹配 “aa” 整个字符串。

    示例 2:

    输入:

    s = “aa”

    p = “a*“

    输出: true

    解释: 因为 ‘*‘ 代表可以匹配零个或多个前面的那一个元素, 在这里前面的元素就是 ‘a’。因此,字符串 “aa” 可被视为 ‘a’ 重复了一次。

    示例 3:

    输入:

    s = “ab”

    p = “.*”

    输出: true

    解释: “.*” 表示可匹配零个或多个(’*‘)任意字符(’.’)。

    示例 4:

    输入:

    s = “aab”

    p = “c*a*b”

    输出: true

    解释: 因为 ‘*’ 表示零个或多个,这里 ‘c’ 为 0 个, ‘a’ 被重复一次。因此可以匹配字符串 “aab”。

    示例 5:

    输入:

    s = “mississippi”

    p = “mis*is*p*.”

    输出: false

    一开始的思路,,,,好吧没有思路

    f2d60f685f03d7ea20b405b40efd034f.png 只能使用字符串中关于正则的匹配API,代码如下

    class Solution {

    public boolean isMatch(String s, String p) {

    return s.matches(p);

    }

    }

    其实我们仔细考虑一下,无非就是分三种情况

    e85018eca9ce472a5295efc53560f0b3.png

    假设主串为 A,模式串为 B , A 的长度为 n ,B 的长度为 m ,关注正则表达式 B 的最后一个字符是谁,它有三种可能,正常字符,* 和 .(点),那针对这三种情况讨论即可,如下:

    如果 B 的最后一个字符是正常字符,那就是看 A[n-1] 是否等于 B[m-1],相等则看 A_{0..n-2}与 B_{0..m-2},不等则是不能匹配,这就是子问题。

    78c0e303230e9b78ad9d5e31e3ca856d.png

    如果 B 的最后一个字符是 .(点) ,它能匹配任意字符,直接看 A_{0..n-2}与 B_{0..m-2}

    cd2d1a6355893c87b69f64fb7b7f5ac1.png

    如果 B 的最后一个字符是 * ,它代表 B[m-2]=c 可以重复0次或多次,它们是一个整体 c*

    f0aa22cff46e103fad0e292aa18df796.png

    情况一:A[n-1]是 0个 c,B 最后两个字符废了,能否匹配取决A_{0..n-1}和 B_{0..m-3}是否匹配

    情况二:A[n-1]是多个 c 中的最后一个(这种情况必须 A[n−1]=c 或者 c=’.’),所以 A 匹配完往前挪一个,B 继续匹配,因为可以匹配多个,继续看 A_{0..n-2}和 B_{0..m-1}是否匹配。

    先来个某大神动态规划的思路

    bab28991a4f277f647a9ab3041eb3849.png

    转移方程

    f[i][j] 代表 A 的前 i 个和 B 的前 j 个能否匹配

    对于前面两个情况,可以合并成一种情况 f[i][j] = f[i-1][j-1]

    对于第三种情况,对于 c* 分为看和不看两种情况

    不看:直接砍掉正则串的后面两个, f[i][j] = f[i][j-2]

    看:正则串不动,主串前移一个,f[i][j] = f[i-1][j]

    特判:需要考虑空串空正则

    空串和空正则是匹配的,f[0][0] = true

    空串和非空正则,不能直接定义 true 和 false ,必须要计算出来。(比如A=” “ ,B=abc*)

    非空串和空正则必不匹配,f[1][0]=…=f[n][0]=false

    非空串和非空正则,那肯定是需要计算的了。

    大体上可以分为空正则和非空正则两种,空正则也是比较好处理的,对非空正则我们肯定需要计算,非空正则的三种情况,前面两种可以合并到一起讨论,第三种情况是单独一种,那么也就是分为当前位置是 * 和不是 * 两种情况了。

    再来个递归代码,递归代码与上面的思路其实是一样的

    package ddx.september.day29;

    public class Normal_19 {

    public boolean isMatch(String s, String p) {

    if (s.length() == 0 ) {

    //主串为空

    if (p.length() % 2 != 0) {

    //模式串长度为奇数,则一定不匹配,因为抵消不了奇数

    //例如:"." , "ab*","abc"

    return false;

    } else {

    //长度为偶数,只需要判断偶数位上是不是*即可!

    int i = 1;

    while (i < p.length()) {

    if (p.charAt(i) != '*') {

    return false;

    }

    i += 2;

    }

    return true;

    }

    } else if (p.length() == 0) {

    //模式串为空

    return false;

    } else {

    char ch1 = s.charAt(0); //s的首位

    char ch2 = p.charAt(0); //p的首位

    char ch3 = 'a'; //p的下一位

    if(p.length() > 1){

    ch3 = p.charAt(1);

    }

    //照样分情况,看看是不是*

    if(ch3 != '*'){

    if(ch2 == ch1 || ch2 == '.'){

    return isMatch(s.substring(1),p.substring(1));

    }else{

    //连正常字符和.都匹配不上

    return false;

    }

    }else{

    //难点就在于ch3是 *

    //正常字符相等,或者是.

    //即选择或者不选择!!!

    //"aa"

    //"a*a"

    //上面两个字符串,碰到*可以选择,也可以不选择

    if(ch2 == ch1 || ch2 == '.'){

    //前者是选择,后者是不选择

    return isMatch(s.substring(1),p) || isMatch(s,p.substring(2));

    }else{

    //连正常字符和.都匹配不上,那么ch2 和 ch3废了!!!!

    return isMatch(s,p.substring(2));

    }

    }

    }

    }

    }

    1591cee9f6ed888de8f7a839c5a1f291.png

    本作品采用《CC 协议》,转载必须注明作者和本文链接

    展开全文
  • Wildcard-Matching &...匹配任意一个字符,*匹配任意长度字符串包括空字符串方法一:记录*的位置,分别考虑*匹配空,匹配一个,匹配两个,三个...1 bool isMatch(const char *s, const char *p) {2 int sStar...

    Wildcard-Matching &  Regular Expression Matching

    Wildcard-Matching中?匹配任意一个字符,*匹配任意长度字符串包括空字符串

    方法一:记录*的位置,分别考虑*匹配空,匹配一个,匹配两个,三个...

    1 bool isMatch(const char *s, const char *p) {2 int sStar=-1,pStar=-1;3 int i=0,j=0;4 for(i=0;i

    5 {6 if(p[j]=='*')7 {8 sStar=i;9 pStar=j;10 j++;11 }12 else if(p[j]==s[i]||p[j]=='?')13 {14 i++;15 j++;16 }17 else if(sStar>=0)//没有匹配但之前记录sStar了

    18 {19 i = ++sStar;20 j = pStar+1;21 }22 else return false;23 }24 while(p[j]=='*')j++;25 return j==strlen(p);26 }

    方法二:DP dp[i][j]=1表示s[0:i)与p[0:j)匹配,状态转移以*划分两种情况,包含*又有两种状态转移,根据无后效性可知,有匹配空和匹配s中的一个字符这两种

    1 bool isMatch(const char *s, const char *p) {2 int dp[strlen(s)+1][strlen(p)+1];3 memset(dp,0,sizeof(dp));4 dp[0][0]=1;5 for(int j=1;j<=strlen(p);j++)6 {7 if(p[j-1]=='*')8 dp[0][j]=dp[0][j-1];9 }10 for(int i=1;i<=strlen(s);i++)11 for(int j=1;j<=strlen(p);j++)12 {13 if(p[j-1]=='*')14 dp[i][j]=dp[i][j-1]||dp[i-1][j];15 else

    16 dp[i][j]=dp[i-1][j-1]&&(s[i-1]==p[j-1]||p[j-1]=='?');17 }18 returndp[strlen(s)][strlen(p)];19 }

    Regular Expression Matching

    *表示*之前的字符可以有0个,1个或是多个

    方法一:递归

    注意不应该先判原串s为空,p为*也可以

    p[1]==* 需要匹配s中的一个字符时,注意p不能去掉首字符,因为*号前面的字符可以有无限个;

    1 bool isMatch(string s, stringp)2 {3 if(p.empty())returns.empty();4 if(p.size()>1&&p[1]=='*')5 return isMatch(s,p.substr(2))||(!s.empty() && (s[0] == p[0] || p[0] == '.') && isMatch(s.substr(1),p));6 else

    7 return !s.empty()&& (p[0]==s[0]||p[0]=='?') && isMatch(s.substr(1),p.substr(1));8 }

    方法二:DP  dp[i][j]=1表示s[0:i)与p[0:j)匹配

    1.  P[i][j] = P[i - 1][j - 1], if p[j - 1] != '*' && (s[i - 1] == p[j - 1] || p[j - 1] == '.');

    2.  P[i][j] = P[i][j - 2], if p[j - 1] == '*' and the pattern repeats for 0 times;

    3.  P[i][j] = P[i - 1][j] && (s[i - 1] == p[j - 2] || p[j - 2] == '.'), if p[j - 1] == '*' and the pattern repeats for at least 1

    1 bool isMatch(string s, stringp) {2 int m = s.size(), n =p.size();3 int dp[m+1][n+1];4 memset(dp,0,sizeof(dp));5 dp[0][0] = 1;6 for (int i = 0; i <= m; ++i) {7 for (int j = 1; j <= n; ++j) {8 if (j > 1 && p[j - 1] == '*') {9 dp[i][j] = dp[i][j - 2] || (i > 0 && (s[i - 1] == p[j - 2] || p[j - 2] == '.') && dp[i - 1][j]);10 } else{11 dp[i][j] = i > 0 && dp[i - 1][j - 1] && (s[i - 1] == p[j - 1] || p[j - 1] == '.');12 }13 }14 }15 returndp[m][n];16 }

    展开全文
  • 分析:正则表达式类型的题,主要在于理清一层层的逻辑。 import java.util.Arrays; /* 首先,考虑特殊情况: 1>... 匹配成功了,而如果第一个字符串空了,第二个字符串非空,还是可能匹配成...

    一、正则表达式匹配

    在这里插入图片描述
    分析:正则表达式类型的题,主要在于理清一层层的逻辑。

    
    import java.util.Arrays;
    
    /*
        首先,考虑特殊情况:
             1>两个字符串都为空,返回true
             2>当第一个字符串不空,而第二个字符串空了,返回false(因为这样,就无法
                匹配成功了,而如果第一个字符串空了,第二个字符串非空,还是可能匹配成
                功的,比如第二个字符串是“a*a*a*a*”,由于‘*’之前的元素可以出现0次,
                所以有可能匹配成功)
        之后就开始匹配第一个字符,这里有两种可能:匹配成功或匹配失败。但考虑到pattern
        下一个字符可能是‘*’, 这里我们分两种情况讨论:pattern下一个字符为‘*’或
        不为‘*’:
              1>pattern下一个字符不为‘*’:这种情况比较简单,直接匹配当前字符。如果
                匹配成功,继续匹配下一个;如果匹配失败,直接返回false。注意这里的
                “匹配成功”,除了两个字符相同的情况外,还有一种情况,就是pattern的
                当前字符为‘.’,同时str的当前字符不为‘\0’。
              2>pattern下一个字符为‘*’时,稍微复杂一些,因为‘*’可以代表0个或多个。
                这里把这些情况都考虑到:
                   a>当‘*’匹配0个字符时,str当前字符不变,pattern当前字符后移两位,
                    跳过这个‘*’符号;
                   b>当‘*’匹配1个或多个时,str当前字符移向下一个,pattern当前字符
                    不变。(这里匹配1个或多个可以看成一种情况,因为:当匹配一个时,
                    由于str移到了下一个字符,而pattern字符不变,就回到了上边的情况a;
                    当匹配多于一个字符时,相当于从str的下一个字符继续开始匹配)
        之后再写代码就很简单了。
    */
    public class match {
        private int i = 0;
        private int j = 0;
    
        public boolean match(char[] str, char[] pattern)
        {
            if((str==null||str.length==0)&&(pattern==null||pattern.length==0))
                return true;
            else if(str!=null&&(pattern==null||pattern.length==0))
                return false;
            if(j+1==pattern.length||pattern[j+1]!='*'){
                //pattern下一个字符不为‘*’时
                if(str!=null&&i<str.length){
                    if(pattern[j]==str[i]||pattern[j]=='.')
                        return match(Arrays.copyOfRange(str,i+1,str.length),Arrays.copyOfRange(pattern,j+1,pattern.length));
                    else
                        return false;
    
                }
                else
                    return false;
            }
            else {
                //pattern下一个字符为‘*’时
                if(str!=null&&i<str.length&&(pattern[j]==str[i]||pattern[j]=='.'))
                    return match(Arrays.copyOfRange(str,i+1,str.length),pattern)||match(str,Arrays.copyOfRange(pattern,j+2,pattern.length));
                else
                    return match(str,Arrays.copyOfRange(pattern,j+2,pattern.length));
    
            }
        }
    }
    

    二、字符流中第一个不重复的字符

    在这里插入图片描述
    分析:

    1. 利用hash的思想,ASCII字符最多也就128个,所以用一个大小为128的char数组记录每一个字符出现的次数
    2. 容易发现,字符流中不重复的字符可能同时存在多个,我们只要把这些 “不重复字符” 保存起来就可以,而无需保存那些重复出现的字符,而为了维护字符出现的顺序,我们使用队列(先进先出)这一结构,先出现的不重复字符先输出
    public class charFlow {
        char[] charCnt = new char[128];
        Queue<Character> queue = new LinkedList<>();
    
        //Insert one char from stringstream
        public void Insert(char ch)
        {
            if(charCnt[ch] == 0){
                charCnt[ch]++;
                queue.offer(ch);
            }
            else
                charCnt[ch]++;
        }
        //return the first appearence once char in current stringstream
        public char FirstAppearingOnce()
        {
            while (!queue.isEmpty()){
                if(charCnt[queue.peek()]>1){
                    queue.poll();
                }
                else
                    return queue.peek();
            }
            return '#';
        }
    }
    
    展开全文
  • 字符匹配的第一个空字符串分隔如果源文本与;比赛开始的最后一个空字符串,如果源文本与;结束不会返回;的一部分匹配的实例鉴于源文本注:所述第一线与;随后没有空格结束,用;后跟一个空格; 2017-01-02; 2017-01-03; ;...
  • 正则表达式匹配算法在leetcode玩耍遇到了这么一个题给定一个字符串 (s) 和一个字符模式 (p)。实现支持 '.'和'*'的正则表达式匹配。'.' 匹配任意单个字符。'*' 匹配零个或多个前面的元素。匹配应该覆盖整个字符串 (s)...
  • 题目描述给你一个字符串 s 和一个字符规律 p,请你来实现一个支持 '.' 和 '*' 的正则表达式匹配。'.' 匹配任意单个字符'*' 匹配零个或多个前面的那一个元素所谓匹配,是要涵盖 整个 字符串 s的,而不是部分字符串。...
  • 匹配应该覆盖整个字符串 (s) ,而不是部分字符串。说明:s 可能为,且只包含从 a-z 的小写字母。p 可能为,且只包含从 a-z 的小写字母,以及字符 . 和 *。示例 1:12345输入:s="aa"p="a"输出:...
  • Leetcode(10) - 正则表达式匹配- java版题目难度: 困难给你一个字符串 s 和一个字符规律 p,请你来实现一个支持 '.' 和 '*' 的正则表达式匹配。'.' 匹配任意单个字符'*' 匹配零个或多个前面的那一个元素所谓匹配,是...
  • 展开全部^Stringstr="q123wwwe.dd434rrd";...if(str==null||str.equals("")){System.out.println("输入为");}else{String[]arr=str.split("\\.");if(arr.length==1){result=arr[0].replaceAll("...
  • 题目描述:给定一个字符串(s) 和一...匹配应该覆盖整个字符串(s) ,而不是部分字符串。说明:s可能为,且只包含从a-z的小写字母。p可能为,且只包含从a-z的小写字母,以及字符.和*。示例 1:输入:s="aa"p="a"输出:...
  • 使用内置模块re,从内置角度可以看出来,正则的重要性。...re.findall返回一个列表,如果没有找到匹配的,则返回列表。可以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式:注意:只有是返回对象的时...
  • 匹配应该覆盖整个字符串 (s) ,而不是部分字符串。说明:s 可能为,且只包含从 a-z 的小写字母。p 可能为,且只包含从 a-z 的小写字母,以及字符 . 和 *。示例 1:输入:s = "aa"p = "a"输出: false...
  • 正则表达式是一个用于匹配字符串的模板,用于匹配字符串正则表达式语法. 小数点,可匹配\n之外的任何一个字符,要匹配小数点,用\.x x是某一具体字符,表示匹配该字符\d 匹配0-9之间的一个数字\D 匹配\d之外的...
  • 1、题目给你一个字符串 s 和一个字符规律 p,请你来实现一个支持 '.' 和 '*' 的正则表达式匹配。'.' 匹配任意单个字符'*' 匹配零个或多个前面的那一个元素所谓匹配,是要涵盖 整个 字符串 s的,而不是部分字符串。...
  • 我需要转义%字符在由用户输入的字符串中 - 用[%]取代它们,除非它们位于字符串的开始或结尾。...[^[]%[^\]]的正则表达式将匹配中间字符串百分比,但也会匹配相邻字符(在我的示例中为o%f)。是否有一个合理的正则...
  • 这是完成所有任务的一线工具:List strings = Arrays.asList...细分为:删除模式1之前的所有内容(第一项必须不要以空字符串结尾).*?在pattern2和pattern1(或输入的结尾)之间的输入(非贪婪)上分割使用实用程序方法Arr...
  • 方法java.time.Matcher.group()用于在输入序列字符串中查找与所需模式匹配的子序列。此方法返回与先前匹配匹配的子序列,该匹配项甚至可以为。给出了一个用Java正则表达式演示方法Matcher.group()的程序,如下所...
  • 1.算法题目给你一个字符串 s 和一个字符规律 p,请你来实现一个支持 '.' 和 '*' 的正则表达式匹配。'.' 匹配任意单个字符'*' 匹配零个或多个前面的那一个元素所谓匹配,是要涵盖 整个 字符串 s的,而不是部分字符串...
  • 文章目录一、题解二、代码三、总结 一、题解 给你一个字符串 s 和一个字符串 p,请你来实现一个支持 '.' 和 '*' 的正则表达式匹配。 '.' 匹配任意单个字符 '*' 匹配零个或多个前面的...边界:空字符串表示可以匹配成功
  • 空字符串也会被忽略. _还可以!该组可以包括封闭:或不包括.以下是一些测试和预期的组:"test :candidate: test" => ":candidate:""test :candidate: test:" => ":candidate:""test :c...
  • 原来正则表达式中的"."代表的是除换行以外的任意字符,如果要真正代表任意字符,需要把换行符也加进去,但是经过测试"...在匹配字符串"[tab]one[tab][tab]two[tab]"时,...
  • Java 正则表达式

    2019-05-13 23:47:00
    正则表达式是一个用于匹配字符串的模板,用于匹配字符串正则表达式语法: . 小数点,可匹配\n之外的任何一个字符,要匹配小数点,用\. x x是某一具体字符,表示匹配该字符 \d 匹配0-9之间的一个数字...
  • public String[] split(Stringregex)根据给定的正则...因此,结果数组中不包括结尾空字符串。例如,字符串 "boo:and:foo" 产生带有下面这些表达式的结果:Regex结果:{ "boo", "and", "foo" }o{ "b", "", ":and:...
  • JAVA正则表达式笔记

    2021-03-31 23:36:42
    所谓正则表达式,就是一个可以匹配N个字符串字符串模板 正则表达式是一个非常强大的字符串模板 在一般的命令行里面,经常使用a*来表示字符串模板 正则表达式支持的通配符: . 可以匹配任意字符 \s 代表任意一个...
  • JAVA 正则表达式

    热门讨论 2010-01-15 11:16:37
    Java正则表达式入门 众所周知,在程序开发中,难免会遇到需要匹配、查找、替换、判断字符串的情况发生,而这些情况有时 又比较复杂,如果用纯编码方式解决,往往会浪费程序员的时间及精力。因此,学习及使用正则...
  • 给你一个字符串 s 和一个字符规律 p,请你来实现一个支持 '.' 和 '*' 的正则表达式匹配。 '.' 匹配任意单个字符 '*' 匹配零个或多个前面的那一个元素 所谓匹配,是要涵盖 整个 字符串 s的,而不是部分字符串。 说明...
  • 正则表达式是一个用于匹配字符串的模板,用于匹配字符串正则表达式语法 . 小数点,可匹配\n之外的任何一个字符,要匹配小数点,用\. x x是某一具体字符,表示匹配该字符 \d 匹配0-9之间的一个数字 \D 匹配\...
  • Java正则表达式

    2017-03-19 16:22:16
    正则表达式一般用于字符串匹配、查找、替换、分割。例如:从网页中找出email地址,IP地址是否正确,从网页中找出连接等等。 符号 意思 \|反斜杠 \t 间隔(’\u0009’) \n 换行(’\u000A’) \r 回车(’...

空空如也

空空如也

1 2 3 4 5 ... 12
收藏数 227
精华内容 90
关键字:

java正则匹配空字符串

java 订阅