别有一番风味的正则表达式

最新推荐文章于 2024-08-18 21:29:33 发布
最新推荐文章于 2024-08-18 21:29:33 发布
阅读量135 收藏
点赞数
文章标签： java python 数据库
原文链接：https://my.oschina.net/wangmengjun/blog/780908
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

写一个用于判断给定字符串是否只包含数字或者字母的正则表达式。

针对这样需要，我们可以采用类似于如下的方式实现。

    public boolean isAlphaNumeric(String value) {
        if(StringUtils.isEmpty(value)){
            return false;
        }
        return value.matches("^[a-zA-Z0-9]*$");
    }

在java.util.regex.Pattern类中，其实除了字符类或者预定义字符类，如：

Character classes
[abc]	a, b, or c (simple class)
[^abc]	Any character except a, b, or c (negation)
[a-zA-Z]	a through z or A through Z, inclusive (range)
[a-d[m-p]]	a through d, or m through p: [a-dm-p] (union)
[a-z&&[def]]	d, e, or f (intersection)
[a-z&&[^bc]]	a through z, except for b and c: [ad-z] (subtraction)
[a-z&&[^m-p]]	a through z, and not m through p: [a-lq-z](subtraction)
 

Predefined character classes
.	Any character (may or may not match line terminators)
\d	A digit: [0-9]
\D	A non-digit: [^0-9]
\s	A whitespace character: [ \t\n\x0B\f\r]
\S	A non-whitespace character: [^\s]
\w	A word character: [a-zA-Z_0-9]
\W	A non-word character: [^\w]

参考https://docs.oracle.com/javase/7/docs/api/java/util/regex/Pattern.html

之外，还支持Unicode 字符属性别名 , POSIX 正则表达式字符类以及java字符类型等。让我们一起来看一下相关的源代码和API的说明，然后尝试一下能写出什么不一样的正则表达式出来。走起~~~

Unicode字符属性别名

// Unicode character property aliases, defined in
            // http://www.unicode.org/Public/UNIDATA/PropertyValueAliases.txt
            defCategory("Cn", 1<<Character.UNASSIGNED);
            defCategory("Lu", 1<<Character.UPPERCASE_LETTER);
            defCategory("Ll", 1<<Character.LOWERCASE_LETTER);
            defCategory("Lt", 1<<Character.TITLECASE_LETTER);
            defCategory("Lm", 1<<Character.MODIFIER_LETTER);
            defCategory("Lo", 1<<Character.OTHER_LETTER);
            defCategory("Mn", 1<<Character.NON_SPACING_MARK);
            defCategory("Me", 1<<Character.ENCLOSING_MARK);
            defCategory("Mc", 1<<Character.COMBINING_SPACING_MARK);
            defCategory("Nd", 1<<Character.DECIMAL_DIGIT_NUMBER);
            defCategory("Nl", 1<<Character.LETTER_NUMBER);
            defCategory("No", 1<<Character.OTHER_NUMBER);
            defCategory("Zs", 1<<Character.SPACE_SEPARATOR);
            defCategory("Zl", 1<<Character.LINE_SEPARATOR);
            defCategory("Zp", 1<<Character.PARAGRAPH_SEPARATOR);
            defCategory("Cc", 1<<Character.CONTROL);
            defCategory("Cf", 1<<Character.FORMAT);
            defCategory("Co", 1<<Character.PRIVATE_USE);
            defCategory("Cs", 1<<Character.SURROGATE);
            defCategory("Pd", 1<<Character.DASH_PUNCTUATION);
            defCategory("Ps", 1<<Character.START_PUNCTUATION);
            defCategory("Pe", 1<<Character.END_PUNCTUATION);
            defCategory("Pc", 1<<Character.CONNECTOR_PUNCTUATION);
            defCategory("Po", 1<<Character.OTHER_PUNCTUATION);
            defCategory("Sm", 1<<Character.MATH_SYMBOL);
            defCategory("Sc", 1<<Character.CURRENCY_SYMBOL);
            defCategory("Sk", 1<<Character.MODIFIER_SYMBOL);
            defCategory("So", 1<<Character.OTHER_SYMBOL);
            defCategory("Pi", 1<<Character.INITIAL_QUOTE_PUNCTUATION);
            defCategory("Pf", 1<<Character.FINAL_QUOTE_PUNCTUATION);
            defCategory("L", ((1<<Character.UPPERCASE_LETTER) |
                              (1<<Character.LOWERCASE_LETTER) |
                              (1<<Character.TITLECASE_LETTER) |
                              (1<<Character.MODIFIER_LETTER)  |
                              (1<<Character.OTHER_LETTER)));
            defCategory("M", ((1<<Character.NON_SPACING_MARK) |
                              (1<<Character.ENCLOSING_MARK)   |
                              (1<<Character.COMBINING_SPACING_MARK)));
            defCategory("N", ((1<<Character.DECIMAL_DIGIT_NUMBER) |
                              (1<<Character.LETTER_NUMBER)        |
                              (1<<Character.OTHER_NUMBER)));
            defCategory("Z", ((1<<Character.SPACE_SEPARATOR) |
                              (1<<Character.LINE_SEPARATOR)  |
                              (1<<Character.PARAGRAPH_SEPARATOR)));
            defCategory("C", ((1<<Character.CONTROL)     |
                              (1<<Character.FORMAT)      |
                              (1<<Character.PRIVATE_USE) |
                              (1<<Character.SURROGATE))); // Other
            defCategory("P", ((1<<Character.DASH_PUNCTUATION)      |
                              (1<<Character.START_PUNCTUATION)     |
                              (1<<Character.END_PUNCTUATION)       |
                              (1<<Character.CONNECTOR_PUNCTUATION) |
                              (1<<Character.OTHER_PUNCTUATION)     |
                              (1<<Character.INITIAL_QUOTE_PUNCTUATION) |
                              (1<<Character.FINAL_QUOTE_PUNCTUATION)));
            defCategory("S", ((1<<Character.MATH_SYMBOL)     |
                              (1<<Character.CURRENCY_SYMBOL) |
                              (1<<Character.MODIFIER_SYMBOL) |
                              (1<<Character.OTHER_SYMBOL)));
            defCategory("LC", ((1<<Character.UPPERCASE_LETTER) |
                               (1<<Character.LOWERCASE_LETTER) |
                               (1<<Character.TITLECASE_LETTER)));
            defCategory("LD", ((1<<Character.UPPERCASE_LETTER) |
                               (1<<Character.LOWERCASE_LETTER) |
                               (1<<Character.TITLECASE_LETTER) |
                               (1<<Character.MODIFIER_LETTER)  |
                               (1<<Character.OTHER_LETTER)     |
                               (1<<Character.DECIMAL_DIGIT_NUMBER)));
            defRange("L1", 0x00, 0xFF); // Latin-1
            map.put("all", new CharPropertyFactory() {
                    CharProperty make() { return new All(); }});

 

\p{Lu}	            An uppercase letter (category)
[\p{L}&&[^\p{Lu}]] 	Any letter except an uppercase letter (subtraction)

示例

判断是否由大写字母组成
        /**
		 * 判断是否都是由大写字母组成
		 */
		String regexExp = "^[\\p{Lu}]*$";
		System.out.println("a".matches(regexExp));// false
		System.out.println("B".matches(regexExp));// true
		System.out.println("aB".matches(regexExp));// false
		System.out.println("@".matches(regexExp));// false

POSIX 字符类（仅 US-ASCII） 

  // Posix regular expression character classes, defined in
            // http://www.unix.org/onlinepubs/009695399/basedefs/xbd_chap09.html
            defRange("ASCII", 0x00, 0x7F);   // ASCII
            defCtype("Alnum", ASCII.ALNUM);  // Alphanumeric characters
            defCtype("Alpha", ASCII.ALPHA);  // Alphabetic characters
            defCtype("Blank", ASCII.BLANK);  // Space and tab characters
            defCtype("Cntrl", ASCII.CNTRL);  // Control characters
            defRange("Digit", '0', '9');     // Numeric characters
            defCtype("Graph", ASCII.GRAPH);  // printable and visible
            defRange("Lower", 'a', 'z');     // Lower-case alphabetic
            defRange("Print", 0x20, 0x7E);   // Printable characters
            defCtype("Punct", ASCII.PUNCT);  // Punctuation characters
            defCtype("Space", ASCII.SPACE);  // Space characters
            defRange("Upper", 'A', 'Z');     // Upper-case alphabetic
            defCtype("XDigit",ASCII.XDIGIT); // hexadecimal digits

 

POSIX character classes (US-ASCII only)

\p{Lower}	A lower-case alphabetic character: [a-z]
\p{Upper}	An upper-case alphabetic character:[A-Z]
\p{ASCII}	All ASCII:[\x00-\x7F]
\p{Alpha}	An alphabetic character:[\p{Lower}\p{Upper}]
\p{Digit}	A decimal digit: [0-9]
\p{Alnum}	An alphanumeric character:[\p{Alpha}\p{Digit}]
\p{Punct}	Punctuation: One of !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
\p{Graph}	A visible character: [\p{Alnum}\p{Punct}]
\p{Print}	A printable character: [\p{Graph}\x20]
\p{Blank}	A space or a tab: [ \t]
\p{Cntrl}	A control character: [\x00-\x1F\x7F]
\p{XDigit}	A hexadecimal digit: [0-9a-fA-F]

示例

判断是否由ASCII值组成
        /**
		 * 判断是否由ASCII码组成
		 */
		String regexExp = "^[\\p{ASCII}]*$";
		System.out.println("a".matches(regexExp));// true
		System.out.println("1".matches(regexExp));// true
		System.out.println("-".matches(regexExp));// true
		System.out.println("@".matches(regexExp));// true
		System.out.println("我".matches(regexExp));// false
判断是否由小写字母组成
		/**
		 * 判断是否由小写字母组成
		 */
		String regexExp = "^[\\p{Lower}]*$";
		System.out.println("a".matches(regexExp));// true
		System.out.println("1".matches(regexExp));// false
		System.out.println("-".matches(regexExp));// false
		System.out.println("@".matches(regexExp));// false
		System.out.println("B".matches(regexExp));// false
判断是是否是有数字组成
		/**
		 * 判断是否由数字组成
		 */
		String regexExp = "^[\\p{Digit}]*$";
		System.out.println("a".matches(regexExp));// false
		System.out.println("1".matches(regexExp));// true
		System.out.println("-".matches(regexExp));// false
		System.out.println("@".matches(regexExp));// false
		System.out.println("B".matches(regexExp));// false

剩余的，如Upper用于判断是否由大写字母组成等，有兴趣的读者可以自己写一下。

java.lang.Character 类（简单的 java 字符类型） 

 // Java character properties, defined by methods in Character.java
            defClone("javaLowerCase", new CloneableProperty() {
                boolean isSatisfiedBy(int ch) {
                    return Character.isLowerCase(ch);}});
            defClone("javaUpperCase", new CloneableProperty() {
                boolean isSatisfiedBy(int ch) {
                    return Character.isUpperCase(ch);}});
            defClone("javaAlphabetic", new CloneableProperty() {
                boolean isSatisfiedBy(int ch) {
                    return Character.isAlphabetic(ch);}});
            defClone("javaIdeographic", new CloneableProperty() {
                boolean isSatisfiedBy(int ch) {
                    return Character.isIdeographic(ch);}});
            defClone("javaTitleCase", new CloneableProperty() {
                boolean isSatisfiedBy(int ch) {
                    return Character.isTitleCase(ch);}});
            defClone("javaDigit", new CloneableProperty() {
                boolean isSatisfiedBy(int ch) {
                    return Character.isDigit(ch);}});
            defClone("javaDefined", new CloneableProperty() {
                boolean isSatisfiedBy(int ch) {
                    return Character.isDefined(ch);}});
            defClone("javaLetter", new CloneableProperty() {
                boolean isSatisfiedBy(int ch) {
                    return Character.isLetter(ch);}});
            defClone("javaLetterOrDigit", new CloneableProperty() {
                boolean isSatisfiedBy(int ch) {
                    return Character.isLetterOrDigit(ch);}});
            defClone("javaJavaIdentifierStart", new CloneableProperty() {
                boolean isSatisfiedBy(int ch) {
                    return Character.isJavaIdentifierStart(ch);}});
            defClone("javaJavaIdentifierPart", new CloneableProperty() {
                boolean isSatisfiedBy(int ch) {
                    return Character.isJavaIdentifierPart(ch);}});
            defClone("javaUnicodeIdentifierStart", new CloneableProperty() {
                boolean isSatisfiedBy(int ch) {
                    return Character.isUnicodeIdentifierStart(ch);}});
            defClone("javaUnicodeIdentifierPart", new CloneableProperty() {
                boolean isSatisfiedBy(int ch) {
                    return Character.isUnicodeIdentifierPart(ch);}});
            defClone("javaIdentifierIgnorable", new CloneableProperty() {
                boolean isSatisfiedBy(int ch) {
                    return Character.isIdentifierIgnorable(ch);}});
            defClone("javaSpaceChar", new CloneableProperty() {
                boolean isSatisfiedBy(int ch) {
                    return Character.isSpaceChar(ch);}});
            defClone("javaWhitespace", new CloneableProperty() {
                boolean isSatisfiedBy(int ch) {
                    return Character.isWhitespace(ch);}});
            defClone("javaISOControl", new CloneableProperty() {
                boolean isSatisfiedBy(int ch) {
                    return Character.isISOControl(ch);}});
            defClone("javaMirrored", new CloneableProperty() {
                boolean isSatisfiedBy(int ch) {
                    return Character.isMirrored(ch);}});

参考 https://docs.oracle.com/javase/7/docs/api/java/util/regex/Pattern.html

java.lang.Character classes (simple java character type)

\p{javaLowerCase}	Equivalent to java.lang.Character.isLowerCase()
\p{javaUpperCase}	Equivalent to java.lang.Character.isUpperCase()
\p{javaWhitespace}	Equivalent to java.lang.Character.isWhitespace()
\p{javaMirrored}	Equivalent to java.lang.Character.isMirrored()

示例

判断是否由小写字母组成
		/**
		 * 判断是否由小写字母组成
		 */
		String regexExp = "^[\\p{javaLowerCase}]*$";
		System.out.println("a".matches(regexExp));// true
		System.out.println("1".matches(regexExp));// false
		System.out.println("-".matches(regexExp));// false
		System.out.println("@".matches(regexExp));// false
		System.out.println("B".matches(regexExp));// false
判断是否由数字或者字母组成
		/**
		 * 判断是否由数字或者字母组成
		 */
		String regexExp = "^[\\p{javaLetterOrDigit}]*$";
		System.out.println("a".matches(regexExp));// true
		System.out.println("1".matches(regexExp));// true
		System.out.println("-".matches(regexExp));// false
		System.out.println("@".matches(regexExp));// false
		System.out.println("B1".matches(regexExp));// true

小结

通过上述示例的编写，想必大家对判断数字、字母、ASCII码等正则表达式的编写，又多了几种写法了。

转载于:https://my.oschina.net/wangmengjun/blog/780908

weixin_34247032
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JDK源码阅读之Character
带翅膀的猫的博客
09-19 3929
Character       Character类是基本数据类型char的包装类，该类提供了几种方法，以确定字符的类别（小写字母，数字，等等），并将字符从大写转换成小写，反之亦然。Jdk1.8中字符信息基于 Unicode 标准，版本 6.2.0。 类图 public final class Character implements ...
[十一]基础数据类型之Character
noteless的博客
10-17 3602
Character与Unicode Character 基本数据类型char 的包装类 Character 类型的对象包含一个 char 类型的字段 该类提供了几种方法来确定字符的类别（小写字母、数字等），并将字符从大写转换为小写，反之亦然 Character在 jdk8中, 基于版本Unicode6.0.2 标准 Character 类的方法和数据是通过 UnicodeD...
Python 字符编码判断
weixin_34128839的博客
03-02 537
法一：isinstance(s, str) 用来判断是否为一般字符串isinstance(s, unicode) 用来判断是否为unicode或if type(str).__name__!="unicode":str=unicode(str,"utf-8")else:pass法二：Python chardet 字符编码判断使用 chardet 可以很方便的实现字符串/文件的编码检测。尤其是中文网页...
JDK源码解析(4)——Byte、Character
Leeand的博客
04-26 296
一、Byte Byte与Integer基本大同小异，也会在加载时生成-128到127的初始值，所以不多赘述。 二、Character Character会在加载时生成127+1的初始值，所以不多赘述。 isValidCodePoint // 判断指定的代码点是否为从 0x0000 到 0x10FFFF 范围之内的有效 Unicode 代码点值。 public static boolean isValidCodePoint(int codePoint) { // Optimized for.
Java学习笔记#08 Java标识符
嘻嘻呵呵的博客
08-13 741
提到Java标识符的规则，很多博客都会告诉你标识符只能由字母、数组、美元符号（$）、下划线（_）开头，且不能以数字开头。 网上广为流传的叙述似乎来自SCJP（Sun Certified Programmer for Java，SUN认证Java程序员）教程[1]： 标识符必须以字母、货币符号（$）或连接符（connecting character，如下划线_）开头。 标识符不能以数字开头。 在第一个字符之后，标识符可以包含字母、各种货币符号、连接符或数字的任意组合。 对于一个标识符可以包含多少字符没有限制。
JavaScript正则表达式
01-08
1、正则表达式是描述字符模式的对象，正则表达式用于对字符串模式匹配及检索替换，是对字符串执行模式匹配的强大工具。 2、String和RegExp都定义了使用正则表达式进行强大的模式匹配和文本检索与替换的函数。 3、...
SQL 正则表达式及mybatis中使用正则表达式
12-13
mysql 提供的模式匹配的其他类型是使用扩展正则表达式。 当你对这类模式进行匹配测试时，使用REGEXP和NOT REGEXP操作符(或RLIKE和NOT RLIKE，它们是同义词)。 扩展正则表达式的一些字符是： “.”匹配任何单个的...
正则表达式汇总-Labview
03-25
正则表达式汇总
匹配中文汉字的正则表达式介绍
12-13
匹配中文字符的正则表达式： [\u4e00-\u9fa5] 或许你也需要匹配双字节字符，中文也是双字节的字符 代码如下: 匹配双字节字符(包括汉字在内)：[^\x00-\xff] 注：可以用来计算字符串的长度（一个双字节字符长度计2，...
PostgreSQL 正则表达式 常用函数的总结
10-19
4. 正则表达式编译与释放：虽然PostgreSQL在后台进行正则表达式的编译和优化，但在某些情况下，了解如何编译和释放正则表达式对于性能优化是有帮助的。 - `regcomp` 和 `regerror` 等函数用于编译和获取正则表达式...
Java正则表达式进阶教程之构造方法
荷意
01-28 305
原文发于http://blog.thihy.info/post/119，转载请注明出处。 本文是在学习正则表达式过程中整理的，虽然冠以“教程”，但实际上应该算是学习笔记。整篇文章需要对正则有一定的理解。。如果有啥写得不对的，或者写得不够清楚的，欢迎大家留言讨论。 概述 正则表达式(Regular Expression)是高效的、便捷的文本处理工具，能够快速查询符合某种规范的文本。 例如...
判断字符串是否由数字和字母构成
qq_43590728的博客
12-10 2631
一：JAVA判断字符串是否由数字和字母构成 第一种方法：可以采用Character里面的一个方法.isLetterOrDigit() public static boolean normalstr(String s){ int len = s.length(); for(int i=0;i<len;i++) { char ch = s.charAt(i); if(!Character.isLetterOrDigit(ch)) { return false
mmseg4j支持单个字母、数字及组合搜索
mlc0202的专栏
05-27 1128
solr中mmseg4j支持单个字母、数字及组合搜索 分类： solr/lucene学习总结2013-01-17 17:29 1546人阅读 评论(0) 收藏 举报 solr mmseg4j 原文地址:http://blog.csdn.net/july_2/article/details/24481935          如题，看到这个题目也许觉得功能有些多余
java character 数字_Java学习——Number类、Character类
weixin_39811101的博客
02-17 205
Number类在使用数字时，我们通常会使用内置数据类型，如int a = 9;float b = 3.14然而在实际开发中，我们经常遇到需要使用对象而不是使用内置数据类型的对象。为了解决这一问题，Java为每一个内置数据类型提供了对应的包装类(比如使用该类型所拥有的函数)，如下图：这种由编译器特别支持的包成为装箱，例子public classForTest {public static voidm...
MMSeg4J改造，使之支持中英文数字连词
Yoara的备忘录
11-20 2977
package com.qfang.util; import java.io.BufferedReader; import java.io.IOException; import java.io.PushbackReader; import java.io.Reader; import java.util.LinkedList; import java.util.Queue; import c
java 字符组合,检测Java中的任何组合字符
weixin_32824725的博客
02-16 109
I am looking for a way to detect if a character in a java string "is a combining character" or not. For instance,String khmerCombiningVowel =new String(new byte[]{(byte) 0xe1,(byte) 0x9f,(byte) 0x80}...
Character包装类的源码解析
一无是处的博客
01-13 270
Character源码解析
Linux配置Maven环境
最新发布
Java全栈开发者
08-18 372
官网地址：https://maven.apache.org/download.cgi。获取其对应的下载链接（也可以使用下载到本地后，手动上传到服务器的方式）切到自己想要存放的路径后，使用wget下载。使用pwd查看文件路径，ll查看文件名称。这里以当前最新版本3.9.8为例。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值