当前位置 : 首页 » 文章分类 :  开发  »  Java-正则表达式

Java-正则表达式

Java 正则表达式 笔记


正则表达式实现原理

DFA 和 NFA

正则引擎大体上可分为不同的两类:DFA 和 NFA,而 NFA 又基本上可以分为传统型 NFA 和 POSIX NFA。
DFA(Deterministic finite automaton) 确定型有穷自动机
NFA(Non-deterministic finite automaton) 非确定型有穷自动机

DFA引擎因为不需要回溯,所以匹配快速,但不支持捕获组,所以也就不支持反向引用和$number这种引用方式,目前使用DFA引擎的语言和工具主要有awk、egrep 和 lex。DFA 自动机的时间复杂度是线性的,更加稳定,但是功能有限。

POSIX NFA 主要指符合 POSIX 标准的 NFA 引擎,它的特点主要是提供 longest-leftmost 匹配,也就是在找到最左侧最长匹配之前,它将继续回溯。同 DFA 一样,非贪婪模式或者说忽略优先量词对于 POSIX NFA 同样是没有意义的。
NFA 的功能更加强大,大多数语言和工具使用的是传统型的NFA引擎,包括 Java 、.NET、Perl、Python、Ruby、PHP 等语言都使用了 NFA 去实现其正则表达式。

匹配过程

NFA 是以正则表达式为基准去匹配的。也就是说,NFA 自动机会读取正则表达式的一个一个字符,然后拿去和目标字符串匹配,匹配成功就换正则表达式的下一个字符,否则继续和目标字符串的下一个字符比较。

例 1
源字符串:abc
正则表达式:abc
匹配过程:
首先由字符“a”取得控制权,从位置0开始匹配,由“a”来匹配“a”,匹配成功,控制权交给字符“b”;由于“a”已被“a”匹配,所以“b”从位置1开始尝试匹配,由“b”来匹配“b”,匹配成功,控制权交给“c”;由“c”来匹配“c”,匹配成功。
此时正则表达式匹配完成,报告匹配成功。匹配结果为“abc”,开始位置为0,结束位置为3。

例 2
源字符串:abc
正则表达式:ab?c
量词“?”属于匹配优先量词,在可匹配可不匹配时,会先选择尝试匹配,只有这种选择会使整个表达式无法匹配成功时,才会尝试让出匹配到的内容。这里的量词“?”是用来修饰字符“b”的,所以“b?”是一个整体。
匹配过程:
首先由字符“a”取得控制权,从位置0开始匹配,由“a”来匹配“a”,匹配成功,控制权交给字符“b?”;由于“?”是匹配优先量词,所以会先尝试进行匹配,由“b?”来匹配“b”,匹配成功,控制权交给“c”,同时记录一个备选状态;由“c”来匹配“c”,匹配成功。记录的备选状态丢弃。
此时正则表达式匹配完成,报告匹配成功。匹配结果为“abc”,开始位置为0,结束位置为3。

例 3
源字符串:abd
正则表达式:ab?c

匹配过程:
首先由字符“a”取得控制权,从位置0开始匹配,由“a”来匹配“a”,匹配成功,控制权交给字符“b?”;先尝试进行匹配,由“b?”来匹配“b”,同时记录一个备选状态,匹配成功,控制权交给“c”;由“c”来匹配“d”,匹配失败,此时进行回溯,找到记录的备选状态,“b?”忽略匹配,即“b?”不匹配“b”,让出控制权,把控制权交给“c”;由“c”来匹配“b”,匹配失败。此时第一轮匹配尝试失败。

正则引擎使正则向前传动,由位置1开始尝试匹配,由“a”来匹配“b”,匹配失败,没有备选状态,第二轮匹配尝试失败。

继续向前传动,直到在位置3尝试匹配失败,匹配结束。此时报告整个表达式匹配失败。

正则基础之——NFA引擎匹配原理
https://blog.csdn.net/lxcnn/article/details/4304651


Pattern

java.util.regex.Pattern

public final class Pattern
extends Object
implements Serializable

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

因此,典型的调用顺序是:

Pattern p = Pattern.compile("a*b");
Matcher m = p.matcher("aaaaab");
boolean b = m.matches();

在仅使用一次正则表达式时,可以方便地通过此类定义 matches 方法。此方法编译表达式并在单个调用中将输入序列与其匹配。
语句boolean b = Pattern.matches("a*b", "aaaaab");
等效于上面的三个语句,尽管对于重复的匹配而言它效率不高,因为它不允许重用已编译的模式。

compile()

public static Pattern compile(String regex)
将给定的正则表达式编译到模式中。
参数:
regex - 要编译的表达式
抛出:
PatternSyntaxException - 如果表达式的语法无效

matcher()

public Matcher matcher(CharSequence input)
创建匹配给定输入与此模式的匹配器。
参数:
input - 要匹配的字符序列
返回:
此模式的新匹配器

matches()

static boolean matches(String regex, CharSequence input)
编译给定正则表达式并尝试将给定输入与其匹配。
例如:boolean b = Pattern.matches(“a*b”, “aaaaab”);
调用此便捷方法的形式
Pattern.matches(regex, input);
与表达式
Pattern.compile(regex).matcher(input).matches()
的行为完全相同。
如果要多次使用一种模式,编译一次后重用此模式比每次都调用此方法效率更高。
参数:
regex - 要编译的表达式
input - 要匹配的字符序列
抛出:
PatternSyntaxException - 如果表达式的语法无效


Matcher

java.util.regex.Matcher

public final class Matcher
extends Object
implements MatchResult

matches()

public boolean matches()
尝试将整个区域与模式匹配。
如果匹配成功,则可以通过 start、end 和 group 方法获取更多信息。
返回: 当且仅当整个区域序列匹配此匹配器的模式时才返回 true。

find()

public boolean find()
尝试查找与该模式匹配的输入序列的下一个子序列。
此方法从匹配器区域的开头开始,如果该方法的前一次调用成功了并且从那时开始匹配器没有被重置,则从以前匹配操作没有匹配的第一个字符开始。
如果匹配成功,则可以通过 start、end 和 group 方法获取更多信息。
返回: 当且仅当输入序列的子序列匹配此匹配器的模式时才返回 true。

lookingAt()

public boolean lookingAt()
尝试将从区域开头开始的输入序列与该模式匹配。
与 matches 方法类似,此方法始终从区域的开头开始;与之不同的是,它不需要匹配整个区域。
如果匹配成功,则可以通过 start、end 和 group 方法获取更多信息。
返回:当且仅当输入序列的前缀匹配此匹配器的模式时才返回 true。

matches()/find()/lookingAt()的区别

通过调用 Patternmatcher() 方法从模式创建匹配器。创建匹配器后,可以使用它执行三种不同的匹配操作:
matches() 方法尝试将整个输入序列与该模式匹配。
lookingAt() 尝试将输入序列从头开始与该模式匹配。
find() 方法扫描输入序列以查找与该模式匹配的下一个子序列。
每个方法都返回一个表示成功或失败的布尔值。通过查询匹配器的状态可以获取关于成功匹配的更多信息。

matches() 对整个字符串进行匹配,只有整个字符串都匹配了才返回true
lookingAt() 从输入的头开始找,只有字符串的前缀满足模式才返回true
find() 方法在部分匹配时和完全匹配时返回true,匹配不上返回false;

matches() 是整个匹配,只有整个字符序列完全匹配成功,才返回True,否则返回False。但如果前部分匹配成功,将移动下次匹配的位置。
lookingAt() 是部分匹配,总是从第一个字符进行匹配,匹配成功了不再继续匹配,匹配失败了,也不继续匹配。
find() 是部分匹配,从当前位置开始匹配,找到一个匹配的子串,将移动下次匹配的位置。

Mathcher 的 find() 和 lookingAt()() 方法执行成功之后,会影响后续的find的执行,因为下一次find会从上次匹配成功的位置开始继续查找,如果不想这样可以使用 reset()() 方法复原匹配器的状态

reset()

public Matcher reset()
重置匹配器。
重置匹配器将放弃其所有显式状态信息并将其添加位置设置为零。匹配器的区域被设置为默认区域,默认区域就是其整个字符序列。此匹配器的区域边界的定位和透明度都不受影响。
返回: 匹配器。

groupCount()

public int groupCount()
返回此匹配器模式中的捕获组数。
根据惯例,零组表示整个模式。它不包括在此计数中。
任何小于等于此方法返回值的非负整数保证是此匹配器的有效组索引。
指定者:接口 MatchResult 中的 groupCount
返回: 此匹配器模式中的捕获组数。


正则表达式构造

字符类

[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]

预定义字符类(元字符)

注意元字符在正则表达式中的写法,不能直接用元字符来编写我们的正则程序
.匹配所有单个字符,除了换行符(Linux 中换行是 \n,Windows 中换行是 \r\n

元字符 在正则表达式中的写法 意义
. . 任何字符(与行结束符可能匹配也可能不匹配)
\d \\d 0-9之间的任意一个数字,等价于[0-9]
\D \\D 非数字,等价于[^0-9]
\s \\s 空白字符,等价于[ \t\n\x0B\f\r]
\S \\S 非空白字符,等价于[^\s]
\w \\w 单词字符,等价于[a-zA-Z_0-9]
\W \\W 非单词字符,等价于[^\w]
\p{Lower} \\p[Lower] 小写字母[a~z]
\p{Upper} \\p{Upper} 大写字母[A~Z]
\p{ASCII} \\p{ACSII} ASCII字符
\p{Alpha} \\p{Alpha} 字母
\p{digit} \\p{digit} 数字字符[0~9]
\p{Alnum} \\p{Alnum} 字母或数字
\p{Punct} \\p{Punct} 标点符号
\p{graph} \\p{graph} 可视字符
\p{Print} \\p{Print} 可打印字符
\p{Blank} \\p{Blank} 空格或制表符
\p{Cntrl} \\p{Cntrl} 控制字符

边界匹配器

^ 行的开头
$ 行的结尾
\b 单词边界
\B 非单词边界
\A 输入的开头
\G 上一个匹配的结尾
\Z 输入的结尾,仅用于最后的结束符(如果有的话)
\z 输入的结尾

贪婪模式量词(Greedy quantifiers)/最大匹配

贪婪模式和非贪婪模式指的是在正则匹配过程中的行为,在贪婪模式下,匹配最长的匹配值。非贪婪模式下,匹配最短的匹配值。
Java 正则表达式默认用的是greedy贪婪匹配模式。
匹配过程:
先看看整个字符串是否存在匹配,如果未发现匹配,则去掉字符串中的最后一个字符,再次尝试匹配,如果还是未发现匹配再去掉最后一个字符,循环往复直到发现一个匹配或者字符串不剩任何字符串。

X? X,一次或一次也没有, 是 {0,1} 的简写
X* X,零次或多次, 是 {0,} 的简写, .* 表示匹配任何字符串
X+ X,一次或多次, 是 {1,} 的简写
X{n} X,恰好 n 次
X{n,} X,至少 n 次
X{n,m} X,至少 n 次,但是不超过 m 次

惰性模式量词(Reluctant quantifiers)/最小匹配

Reluctant quantifiers, 称为 非贪婪模式,或勉强模式,或惰性模式,或最小匹配
如果 ? 是限定符 *+?{} 后面的第一个字符,那么表示非贪婪模式(尽可能少的匹配字符),而不是默认的贪婪模式
匹配过程:
先看看字符串的第一个字母是否存在匹配,如果未发现匹配,则读入下一个字符,再次尝试匹配,如果还是未发现匹配则再读取下一个字符,循环往复直到发现一个匹配或者整个字符串都检查过也没有发现匹配。

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

占有模式量词(Possessive quantifiers)/完全匹配

只尝试匹配整个字符串。如果整个字符串不匹配,则不做进一步。
意思就是只做贪婪匹配的第一步。
如果 + 是限定符 *+?{} 后面的第一个字符,那么表示完全匹配。
X?+ X,一次或一次也没有
X*+ X,零次或多次
X++ X,一次或多次
X{n}+ X,恰好 n 次
X{n,}+ X,至少 n 次
X{n,m}+ X,至少 n 次,但是不超过 m 次

贪婪量词 惰性量词 支配量词 描述
* *? *+ 可以不出现,也可以出现任意次
? ?? ?+ 可以出现0次或1次
+ +? ++ 至少出现1次或以上
{n} {n}? {n}+ 有且只能出现n次
{n,m} {n,m}? {n,m}+ 至少出现n次,至多出现m次
{n,} {n,}? {n,}+ 至少出现n次或以上

Java 正则表达式——贪婪匹配、惰性匹配、支配匹配
https://blog.csdn.net/chy555chy/article/details/53368506

Java 正则表达式 量词 — 三种匹配模式【贪婪型、勉强型、占有型】
https://www.cnblogs.com/lavenderzh/p/5379406.html

Logical运算符

XY X 后跟 Y
X|Y X 或 Y
(X) X,作为捕获组

捕获组和反向引用

捕获组就是匹配到的内容,按照()子表达式划分成若干组。
小括号 () 可以达到对正则表达式进行分组的效果,称为捕获组。

捕获组可以通过从左到右计算其开括号来编号。编号规则是左括号(从左到右出现的顺序,从1开始编号,例如,在表达式 ((A)(B(C))) 中,存在四个这样的组:
0 ((A)(B(C)))
1 ((A)(B(C)))
2 (A)
3 (B(C))
4 (C)

0组始终代表整个表达式

Java 正则表达式详解
https://segmentfault.com/a/1190000009162306


Redundant Character Escape … in RegExp

方括号中的很多转移符都是没必要的,如果有多余的转移符,IDE会提示 “Redundant Character Escape … in RegExp”

例如 [.][\\.] 是完全相同的:

Pattern pattern = Pattern.compile("[\\.]");
System.out.println(pattern.matcher("").find());
System.out.println(pattern.matcher(".").find());
System.out.println(pattern.matcher("a").find());

结果为 false true false

pattern = Pattern.compile("[.]");
System.out.println(pattern.matcher("").find());
System.out.println(pattern.matcher(".").find());
System.out.println(pattern.matcher("a").find());

结果为 false true false
但如果在方括号之外,想要匹配 . 的话,就需要转义符 \\. 了,否则 点 . 会匹配所有字符

Redundant Character Escape of .(dot) in java regex
https://stackoverflow.com/questions/49084230/redundant-character-escape-of-dot-in-java-regex


Java正则表达式应用举例

正则表达式用于String.split()分隔字符串

用空格来分隔单词时,可能单词间有多个空格,直接使用正则表达式 \\s++ 匹配一个或多个空格即可。

@Test
public void testSplit() {
    String input = "hello   world, i am  Java.";
    String[] words = input.split("\\s+");
    System.out.print(String.join(" ", words));
}

结果

hello world, i am Java.

java正则表达式匹配手机号

匹配 86-11位手机号

package com.masikkk.common;
import java.util.regex.Pattern;
public class test {
    public static void main(String[] args){
        String mobileRegExp = "^[0-9]{1,4}-[0-9]{11}$";
        Pattern p = Pattern.compile(mobileRegExp);
        System.out.println(p.matcher("68-13610101010").matches());
    }
}

Java 正则表达式
http://www.runoob.com/java/java-regular-expressions.html

java正则表达式匹配邮箱地址

public static boolean isEmail(String string) {
        if (string == null)
            return false;
        String regEx1 = "^([a-z0-9A-Z]+[-|\\.]?)+[a-z0-9A-Z]@([a-z0-9A-Z]+(-[a-z0-9A-Z]+)?\\.)+[a-zA-Z]{2,}$";
        Pattern p;
        Matcher m;
        p = Pattern.compile(regEx1);
        m = p.matcher(string);
        if (m.matches())
            return true;
        else
            return false;
    }

java判断邮箱是否合法
https://blog.csdn.net/u012934325/article/details/73558084
Java邮箱正则表达式
http://stevenjohn.iteye.com/blog/1058739

子串匹配并指定格式捕获数据

public static void main(String[] args) {
    Pattern p = Pattern.compile("(\\d+,)(\\d+)");
    String s = "123,456-34,345-55678";
    Matcher m = p.matcher(s);
    while (m.find()) {
        System.out.println("捕获个数:groupCount()=" + m.groupCount());
        System.out.println("m.group():" + m.group()); //打印所有
        System.out.println("m.group(1):" + m.group(1)); //打印第一组
        System.out.println("m.group(2):" + m.group(2)); //打印第二组
        System.out.println();
    }
}

每次while循环匹配逗号分隔的纯数字子串:
第一轮while循环 find() 匹配 “123,456”, 第二轮while循环 find() 匹配 “34,345”, 剩下的”-55678”无法和模式匹配
每次while循环中输出捕获组的捕获情况:
group(0)与group()等价,表示整个匹配的子串。
group(1)等价于第一个括号内的表达式返回的字符串,以此类推。
上述程序的执行结果如下:

捕获个数:groupCount()=2
m.group():123,456
m.group(1):123,
m.group(2):456

捕获个数:groupCount()=2
m.group():34,345
m.group(1):34,
m.group(2):345

子串匹配并指定格式捕获数据

过滤一个有规律性的字符串,得到想要的结果,如下面的字符串,最终想得到结果:25分 43分 100分

public static void main(String[] args) {
    String filetext = "张小名=25分|李小花=43分|王力=100分|";
    Pattern p = Pattern.compile("\\=(.*?)\\|");//正则表达式,取=和|之间的字符串,不包括=和|
    Matcher m = p.matcher(filetext);
    System.out.println("捕获组个数:" + m.groupCount());
    while(m.find()) {
        System.out.println(m.group(1));
    }
}

每个while循环输匹配竖线|分隔的一部分子串,循环内通过group输出捕获的编号为1的组。
结果:

捕获组个数:1
25分
43分
100分

提取两个分隔符之间的数据

比如要提取”[“与”]”之间的字符串

public static void main(String[] args) {
    String str = "([长度] + [高度]) * [倍数] - [减号] / [除号] > [大于号] < [小于号] == [等号] ";
    String regx = "\\[(.*?)]";
    Pattern pattern = Pattern.compile(regx);
    Matcher matcher = pattern.matcher(str);
    while(matcher.find()) {
        System.out.println(matcher.group(1));
    }
}

结果为:
长度
高度
倍数
减号
除号
大于号
小于号
等号

判断字符串中是否包含中文字符

Java判断一个字符串是否有中文一般情况是利用Unicode编码(CJK统一汉字的编码区间:0x4e00–0x9fbb)的正则来做判断,但是其实这个区间来判断中文不是非常精确,因为有些中文的标点符号比如:,。等等是不能识别的。

public static boolean isContainChinese(String str) {
    Pattern p = Pattern.compile("[\u4e00-\u9fa5]");
    Matcher m = p.matcher(str);
    if (m.find()) {
        return true;
    }
    return false;
}

Java 完美判断中文字符
http://www.micmiu.com/lang/java/java-check-chinese/


拆分斜杠分隔的中英文

员工的title是由斜线分隔的中英文
规则:
1、如果既有中文又有英文,则肯定英文在前,中文在后
2、可能只有中文,也可能只有英文
3、中文或英文中还可能有斜线,且不止一个
4、中文或英文中还可能有的字符包括: 空白、中英文逗号、数字、下划线、&

处理过程解释:
一、正则 ([\\w\\s&,,/]+)/([\\u4e00-\\u9fa5\\w\\s&,,/]+)
1、有两个捕获组(两个括号),中间用斜线分隔,分别捕获斜线前的英文部分和斜线后的中文部分
2、每个捕获组内是至少一次的贪婪量词+,表示中括号内的字符至少得出现一次,不能为空
3、中括号内是中英文部分可出现的字符或预定义字符类
二、title是固定的最多一次的斜线分割的中英文组合,所以捕获组只需捕获一次,不需要循环出现,所以不用 while(m.find())

package com.masikkk.test;

import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.assertj.core.util.Lists;
import org.junit.Test;

public class TitleSplitTest {
    @Test
    public void testSplitTitle() {
        Pattern pattern = Pattern.compile("([\\w\\s&,,/]+)/([\\u4e00-\\u9fa5\\w\\s&,,/]+)");
        String s1 = "Senior Designer, UI/UX Design & Manager / 高级设计师,UI/UX设计与管理";
        String s2 = "Designer, UI/UX Design / 设计师,UI/UX 设计";
        String s3 = "Assistant Manager, Swapping/Charging  Quality Team / 助理经理,充换电质量团队";
        String s33 = "Purchasing Assistant Manager, Body & Exterior / 采购助理经理,车身外饰 /";
        String s34 = "Engineer, Robot/Simulation / 工程师, 机器人/仿真";
        String s35 = "Engineer, Product Quality Engineering, INT/EXT / 工程师,产品质量工程";
        String s4 = "only english title";
        String s5 = "只有中文title";
        String s6 = "中文title带着斜杠/";
        String s7 = "english/中文 yingwen/中中";

        List<String> titles = Lists.newArrayList(s1, s2, s3, s33, s34, s35, s4, s5, s6, s7);
        for (String title : titles) {
            System.out.println("title   : " + title);
            String enTitle = "";
            String cnTitle = "";
            Matcher m = pattern.matcher(title);
            if (m.find()) {
                System.out.println("captured: " + m.group());
                enTitle = m.group(1).trim();
                cnTitle = m.group(2).trim();
            } else {
                Matcher m2 = Pattern.compile("[\\u4e00-\\u9fa5]").matcher(title);
                if (m2.find()) {
                    cnTitle = title;
                } else {
                    enTitle = title;
                }
            }
            System.out.println("en_title: " + enTitle);
            System.out.println("cn_title: " + cnTitle);
            System.out.println();
        }
    }
}

结果:

title   : Senior Designer, UI/UX Design & Manager / 高级设计师,UI/UX设计与管理
captured: Senior Designer, UI/UX Design & Manager / 高级设计师,UI/UX设计与管理
en_title: Senior Designer, UI/UX Design & Manager
cn_title: 高级设计师,UI/UX设计与管理

title   : Designer, UI/UX Design / 设计师,UI/UX 设计
captured: Designer, UI/UX Design / 设计师,UI/UX 设计
en_title: Designer, UI/UX Design
cn_title: 设计师,UI/UX 设计

title   : Assistant Manager, Swapping/Charging  Quality Team / 助理经理,充换电质量团队
captured: Assistant Manager, Swapping/Charging  Quality Team / 助理经理,充换电质量团队
en_title: Assistant Manager, Swapping/Charging  Quality Team
cn_title: 助理经理,充换电质量团队

title   : Purchasing Assistant Manager, Body & Exterior / 采购助理经理,车身外饰 /
captured: Purchasing Assistant Manager, Body & Exterior / 采购助理经理,车身外饰 /
en_title: Purchasing Assistant Manager, Body & Exterior
cn_title: 采购助理经理,车身外饰 /

title   : Engineer, Robot/Simulation / 工程师, 机器人/仿真
captured: Engineer, Robot/Simulation / 工程师, 机器人/仿真
en_title: Engineer, Robot/Simulation
cn_title: 工程师, 机器人/仿真

title   : Engineer, Product Quality Engineering, INT/EXT / 工程师,产品质量工程
captured: Engineer, Product Quality Engineering, INT/EXT / 工程师,产品质量工程
en_title: Engineer, Product Quality Engineering, INT/EXT
cn_title: 工程师,产品质量工程

title   : only english title
en_title: only english title
cn_title:

title   : 只有中文title
en_title:
cn_title: 只有中文title

title   : 中文title带着斜杠/
en_title:
cn_title: 中文title带着斜杠/

title   : english/中文 yingwen/中中
captured: english/中文 yingwen/中中
en_title: english
cn_title: 中文 yingwen/中中

Java正则表达式解决字符串转整型atoi

不推荐这种解法,很慢,比直接从前往后扫描处理慢一个数量级。
时间复杂度也不好分析,但作为复习Java正则表达式,还是可以写一下的,当练手了。

public int myAtoi2(String str) {
    // ( *) 匹配0个或多个空格,[+-]? 匹配0个或1个符号位, \d+ 匹配1个或多个数字, .* 匹配剩余后缀字符
    Pattern pattern = Pattern.compile("( *)([+-]?\\d+).*");
    Matcher matcher = pattern.matcher(str);
    // 先用 matches() 对整个串进行完全匹配
    if (!matcher.matches()) {
        return 0;
    }
    // 重置匹配器后,使用 find() 进行部分匹配,其中的第2个捕获组就是合法整数对应的字符串
    matcher.reset();
    if (matcher.find()) {
        String validIntStr = matcher.group(2);
        try {
            return Integer.parseInt(validIntStr);
        } catch (NumberFormatException e) {
            return validIntStr.startsWith("-") ? Integer.MIN_VALUE : Integer.MAX_VALUE;
        }
    }
    return 0;
}

上一篇 Java-集合框架基础

下一篇 Spring-概述

阅读
评论
5,927
阅读预计24分钟
创建日期 2015-07-22
修改日期 2020-06-21
类别

页面信息

location:
protocol:
host:
hostname:
origin:
pathname:
href:
document:
referrer:
navigator:
platform:
userAgent:

评论