java 正则表达式 65个字母内只包含数字，空格，+号 三种的该如何写呢

问题描述：

java 正则表达式 65个字母内只包含数字，空格，+号 三种的该如何写呢

网友观点：

{String x = \\\"18749237 +322+2\\\";
String regex = \\\"[+ \\d]{0,65}\\\";
Boolean result = x.matches(regex);
if(result){
System.out.println(\\\"符合规则\\\");
}else {
System.out.println(\\\"不符合规则\\\");
}
}

正则表达式，“65个字母内只包含数字，空格，+号 三种”匹配串：[\\d+ ]{65}

上面代码片段，，亲测可行，，有问题还可以追问

[\\d \\+]+
String patternStr = \\\"[\\d \\+]+\\\"; //java中反斜杠要转义
//测试字符串
String str = \\\"7 8+4 +\\\";
Matcher meq = Pattern.compile(patternStr).matcher(str);
if(meq.matches()){
System.out.println(\\\"~~~完全匹配~~\\\");
}

^[\\d\\n+]{65}$

^[\\d\\n+]{65}$

Java正则表达式详解

小编提示：此篇文章阅读时间为15分钟左右，可先收藏后阅读。

前言

正则表达式是用来处理字符串的一把利器，它是一个专门匹配n个字符串的字符串模板，本质是查找和替换。许多语言，包括Perl、PHP、Python、JavaScript和JScript，都支持用正则表达式处理文本，一些文本编辑器用正则表达式实现高级“搜索-替换”功能。那么Java又怎样呢？在Java中存在一个用正则表达式所订制的模式来对字符串进行匹配工作的类库包它就是java.util.regex。而在该包中包含是Pattern、Matcher这两个工具类，其中Pattern：编译好的带匹配的模板(如：Pattern.compile("[a-z]{2}");/ / 取2个小写字母)；Matcher：匹配目标字符串后产生的结果(如：pattern.matcher("目标字符串");)。

一、Pattern和Matcher

Pattern类用于创建一个正则表达式（匹配模式）,它的构造方法是私有的,不可以直接创建,但可以通过Pattern.complie(String regex)简单工厂方法创建一个正则表达式.Java代码示例:

Pattern p=Pattern.compile("\\\\w+");

p.pattern();//返回 \\w+

pattern() 返回正则表达式的字符串形式,其实就是返回Pattern.complile(String regex)的regex参数

1.Pattern.split(CharSequence input)

Pattern有一个split(CharSequence
input)方法,用于分隔字符串,并返回一个String[],其中String.split(String regex)就是通过Pattern.split(CharSequence input)来实现的.

Java代码示例:

Pattern p=Pattern.compile("\\\\d+");

String[]
str=p.split("AAA456456VVV0532214DDD");

// 结果:str[0]="
AAA " str[1]=" VVV " str[2]=" DDD

2. Pattern.matcher(String regex,CharSequence
input)

该方法是一个静态方法,用于快速匹配字符串,该方法适合用于只匹配一次,且匹配全部字符串. Java代码示例:

Pattern.matches("[a-z]{2}+","AA");//返回true

Pattern.matches("[a-z]{2}","A2");//返回false,需要匹配到所有字符串才能返回true

3.Pattern.matcher(CharSequence input)

Pattern.matcher(CharSequence input)返回一个Matcher对象. Matcher类的构造方法也是私有的,不能随意创建,只能通过Pattern.matcher(CharSequence input)方法得到该类的实例. Pattern类只能做一些简单的匹配操作,要想得到更强更便捷的正则匹配操作,那就需要将Pattern与Matcher一起合作.Matcher类提供了对正则表达式的分组支持,以及对正则表达式的多次匹配支持. Java代码示例:

Pattern p=Pattern.compile("\\\\d+");

Matcher
m=p.matcher("22bb23");

m.pattern();//返回p 也就是返回该Matcher对象是由哪个Pattern对象的创建的

4.Matcher类介绍

Matcher类提供三个匹配操作方法它们分别是Matcher.matches()/
Matcher.lookingAt()/ Matcher.find(),三个方法均返回boolean类型,当匹配到时返回true,没匹配到则返回false。matches()对整个字符串进行匹配,只有整个字符串都匹配了才返回true Java代码示例:

Pattern p=Pattern.compile("\\\\d+");

Matcher m=p.matcher("22bb23");

m.matches();//返回false,因为bb不能被\\d+匹配,导致整个字符串匹配未成功.

Matcher m2=p.matcher("2223");

m2.matches();//返回true,因为\\d+匹配到了整个字符串

我们现在回头看一下Pattern.matcher(String
regex,CharSequence input),它与下面这段代码等价

Pattern.compile(regex).matcher(input).matches() ;

lookingAt()对前面的字符串进行匹配,只有匹配到的字符串在最前面才返回true,Java代码示例:

Pattern p=Pattern.compile("\\\\d+");

Matcher m=p.matcher("22bb23");

m.lookingAt();//返回true,因为\\d+匹配到了前面的22

Matcher m2=p.matcher("aa2223");

m2.lookingAt();//返回false,因为\\d+不能匹配前面的aa

find()对字符串进行匹配,匹配到的字符串可以在任何位置. Java代码示例:

Pattern p=Pattern.compile("\\\\d+");

Matcher m=p.matcher("22bb23");

m.find();//返回true

Matcher m4=p.matcher("aabb");

m4.find();//返回false

5.Mathcer类拓展

当使用matches(),lookingAt(),find()执行匹配操作后,就可以利用以上三个方法得到更详细的信息.

start()返回匹配到的子字符串在字符串中的索引位置.

end()返回匹配到的子字符串的最后一个字符在字符串中的索引位置.

group()返回匹配到的子字符串

Matcher类同时提供了四个将匹配子串替换成指定字符串的方法：

replaceAll() ;replaceFirst() ;appendReplacement()
;appendTail()

replaceAll()与replaceFirst()的用法都比较简单,我们主要重点了解一下appendReplacement()和appendTail()方法。

appendReplacement(StringBuffer sb, String replacement) 将当前匹配子串替换为指定字符串，并且将替换后的子串以及其之前到上次匹配子串之后的字符串段添加到一个StringBuffer对象里，而appendTail(StringBuffer sb) 方法则将最后一次匹配工作后剩余的字符串添加到一个StringBuffer对象里。例如，有字符串fatcatfatcatfat,假设既有正则表达式模式为"cat"，第一次匹配后调用appendReplacement(sb,"dog"),那么这时StringBuffer sb的内容为fatdog，也就是fatcat中的cat被替换为dog并且与匹配子串前的内容加到sb里，而第二次匹配后调用appendReplacement(sb,"dog")，那么sb的内容就变为fatdogfatdog，如果最后再调用一次appendTail（sb）,那么sb最终的内容将是fatdogfatdogfat。

二、正则表达式规则

a.字符类
[abc] a, b, or c (简单类)
[^abc] 除了a、b或c之外的任意 字符（求反）
[a-zA-Z] a到z或A到Z ，包含（范围)
[a-z-[bc]] a到z，除了b和c ： [ad-z]（减去）
[a-z-[m-p]] a到z，除了m到 p：
[a-lq-z]
[a-z-[^def]] d, e, 或
f
备注：
方括号的正则表达式“t[aeio]n”只匹配“tan”、“Ten”、“tin”和“ton”，只能匹配单个字符。
圆括号，因为方括号只允许匹配单个字符；故匹配多个字符时使用圆括号“()”。比如使用“t(a|e|i|o|oo)n”正则表达式，就必须用圆括号。

b.预定义的字符类
. 任意字符（也许能与行终止符匹配，也许不能） 备注：句点符号代表任意一个字符。比如：表达式就是“t.n”，它匹配“tan”、“ten”、“tin”和“ton”，还匹配“t#n”、“tpn”甚至“t n”。
\\d 数字:
[0-9]
\\D 非数字:
[^0-9]
\\s 空格符: [
\\t\\n\\x0B\\f\\r]
\\S 非空格符: [^\\s]
\\w 单词字符:
[a-zA-Z_0-9]
\\W 非单词字符: [^\\w]

c.表达次数的符号
符号 次数
* 0次或者多次
+ 1次或者多次
? 0次或者1次
{n} 恰好n次
{n,m} 从n次到m次

三、实例演示

a.字符串操作

/*

* 获取

*

*/

public static void functionDemo_4() {

String str
= "da jia hao,ming tian bu fang jia!";

String
regex = "\\\\b[a-z]{3}\\\\b";

//1,将正则封装成对象。

Pattern p =
Pattern.compile(regex);

//2, 通过正则对象获取匹配器对象。

Matcher m =
p.matcher(str);

//使用Matcher对象的方法对字符串进行操作。

//既然要获取三个字母组成的单词

//查找。 find();

System.out.println(str);

while(m.find()){

System.out.println(m.group());//获取匹配的子序列

System.out.println(m.start()+":"+m.end());

}

}

/*

* 替换

*/

public static
void functionDemo_3() {

String str
= "zhangsanttttxiaoqiangmmmmmmzhaoliu";

str =
str.replaceAll("(.)\\\\1+", "$1");

System.out.println(str);

String tel
= "15800001111";//158****1111;

tel =
tel.replaceAll("(\\\\d{3})\\\\d{4}(\\\\d{4})", "$1****$2");

System.out.println(tel);

}

/*

* 切割。

* 组：((A)(B(C)))

*/

public static
void functionDemo_2(){

String str
= "zhangsanttttxiaoqiangmmmmmmzhaoliu";

String[]
names = str.split("(.)\\\\1+");//str.split("\\\\.");

for(String
name : names){

System.out.println(name);

}

}

/*

* 演示匹配。

*/

public static
void functionDemo_1(){

//匹配手机号码是否正确。

String tel
= "15800001111";

String
regex = "1[358]\\\\d{9}";

boolean b =
tel.matches(regex);

System.out.println(tel+":"+b);

}

b．实例操作

//对邮件地址校验。

public
static void test_3() {

String
mail = "abc1@sina.com.cn";

String
regex = "[a-zA-Z0-9_]+@[a-zA-Z0-9]+(\\\\.[a-zA-Z]{1,3})+";

regex
= "\\\\w+@\\\\w+(\\\\.\\\\w+)+";//1@1.1

boolean
b = mail.matches(regex);

System.out.println(mail+":"+b);

}

public
static void test_1(){

String
str = "我我...我我...我我我要...要要要要...要要要要..学学学学学...学学编编...编编编编..编..程程...程程...程程程";

//1，将字符串中.去掉。 用替换。

str
= str.replaceAll("\\\\.+", "");

System.out.println(str);

//2,替换叠词。

str
= str.replaceAll("(.)\\\\1+", "$1");

System.out.println(str);

}

/*

* ip地址排序。

* 192.168.10.34 127.0.0.1 3.3.3.3 105.70.11.55

*/

public
static void test_2(){

String
ip_str = "192.168.10.34 127.0.0.1 3.3.3.3
105.70.11.55";

//1,为了让ip可以按照字符串顺序比较，只要让ip的每一段的位数相同。所以，补零，按照每一位所需做多0进行补充。每一段都加两个0.

ip_str
= ip_str.replaceAll("(\\\\d+)", "00$1");

System.out.println(ip_str);

//然后每一段保留数字3位。

ip_str
= ip_str.replaceAll("0*(\\\\d{3})", "$1");

System.out.println(ip_str);

//1，将ip地址切出。

String[]
ips = ip_str.split(" +");

TreeSet<String>
ts = new TreeSet<String>();

for(String ip : ips){

ts.add(ip);

}

for(String
ip : ts){

System.out.println(ip.replaceAll("0*(\\\\d+)",
"$1"));

}

}

四、总结

正则表达式是操作字符串的有效手段，但是在方便我们开发的同时，我们必须意识到正则表达式存在一定的缺陷那就是如果在程序中过多使用正则表达式会造成程序的阅读性急速下降。