java正则表达式中[&&]用法
Posted
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了java正则表达式中[&&]用法相关的知识，希望对你有一定的参考价值。
1.[^456]是表示出了4/5/6意外的任何字符吗？
2.[a-o&&[def]:是代表字母d或e或f吗？不是类似ad吧，只返回一个字符是吧
3.[a-d&&[^bc]:代表b或c吗？
×××××××××××××××××××××××××××××××××××××××××××××
我给你贴出来
×××××××××××××××××××××××××××××××××××××××××××××
public final class Patternextends Objectimplements 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");等效于上面的三个语句，尽管对于重复的匹配而言它效率不高，因为它不允许重用已编译的模式。
此类的实例是不可变的，可供多个并发线程安全使用。Matcher 类的实例用于此目的则不安全。
正则表达式的构造摘要
构造 匹配
字符
x 字符 x
\\ 反斜线字符
\0n 带有八进制值 0 的字符 n (0 <= n <= 7)
\0nn 带有八进制值 0 的字符 nn (0 <= n <= 7)
\0mnn 带有八进制值 0 的字符 mnn（0 <= m <= 3、0 <= n <= 7）
\xhh 带有十六进制值 0x 的字符 hh
\uhhhh 带有十六进制值 0x 的字符 hhhh
\t 制表符 ('\u0009')
\n 新行（换行）符 ('\u000A')
\r 回车符 ('\u000D')
\f 换页符 ('\u000C')
\a 报警 (bell) 符 ('\u0007')
\e 转义符 ('\u001B')
\cx 对应于 x 的控制符
字符类
[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]（减去）
预定义字符类
. 任何字符（与行结束符可能匹配也可能不匹配）
\d 数字：[0-9]
\D 非数字： [^0-9]
\s 空白字符：[ \t\n\x0B\f\r]
\S 非空白字符：[^\s]
\w 单词字符：[a-zA-Z_0-9]
\W 非单词字符：[^\w]
POSIX 字符类（仅 US-ASCII）
\pLower 小写字母字符：[a-z]
\pUpper 大写字母字符：[A-Z]
\pASCII 所有 ASCII：[\x00-\x7F]
\pAlpha 字母字符：[\pLower\pUpper]
\pDigit 十进制数字：[0-9]
\pAlnum 字母数字字符：[\pAlpha\pDigit]
\pPunct 标点符号：!"#$%&'()*+,-./:;?@[\]^_`|~
\pGraph 可见字符：[\pAlnum\pPunct]
\pPrint 可打印字符：[\pGraph\x20]
\pBlank 空格或制表符：[ \t]
\pCntrl 控制字符：[\x00-\x1F\x7F]
\pXDigit 十六进制数字：[0-9a-fA-F]
\pSpace 空白字符：[ \t\n\x0B\f\r]
java.lang.Character 类（简单的 java 字符类型）
\pjavaLowerCase 等效于 java.lang.Character.isLowerCase()
\pjavaUpperCase 等效于 java.lang.Character.isUpperCase()
\pjavaWhitespace 等效于 java.lang.Character.isWhitespace()
\pjavaMirrored 等效于 java.lang.Character.isMirrored()
Unicode 块和类别的类
\pInGreek Greek 块（简单块）中的字符
\pLu 大写字母（简单类别）
\pSc 货币符号
\PInGreek 所有字符，Greek 块中的除外（否定）
[\pL&&[^\pLu]] 所有字母，大写字母除外（减去）
边界匹配器
^ 行的开头
$ 行的结尾
\b 单词边界
\B 非单词边界
\A 输入的开头
\G 上一个匹配的结尾
\Z 输入的结尾，仅用于最后的结束符（如果有的话）
\z 输入的结尾
Greedy 数量词
X? X，一次或一次也没有
X* X，零次或多次
X+ X，一次或多次
Xn X，恰好 n 次
Xn, X，至少 n 次
Xn,m X，至少 n 次，但是不超过 m 次
Reluctant 数量词
X?? X，一次或一次也没有
X*? X，零次或多次
X+? X，一次或多次
Xn? X，恰好 n 次
Xn,? X，至少 n 次
Xn,m? X，至少 n 次，但是不超过 m 次
Possessive 数量词
X?+ X，一次或一次也没有
X*+ X，零次或多次
X++ X，一次或多次
Xn+ X，恰好 n 次
Xn,+ X，至少 n 次
Xn,m+ X，至少 n 次，但是不超过 m 次
Logical 运算符
XY X 后跟 Y
X|Y X 或 Y
(X) X，作为捕获组
Back 引用
\n 任何匹配的 nth 捕获组
引用
\ Nothing，但是引用以下字符
\Q Nothing，但是引用所有字符，直到 \E
\E Nothing，但是结束从 \Q 开始的引用
特殊构造（非捕获）
(?:X) X，作为非捕获组
(?idmsux-idmsux) Nothing，但是将匹配标志由 on 转为 off
(?idmsux-idmsux:X) X，作为带有给定标志 on - off 的非捕获组
(?=X) X，通过零宽度的正 lookahead
(?!X) X，通过零宽度的负 lookahead
(?<=X) X，通过零宽度的正 lookbehind
(?<!X) X，通过零宽度的负 lookbehind
(?>X) X，作为独立的非捕获组
--------------------------------------------------------------------------------
反斜线、转义和引用
反斜线字符 ('\') 用于引用转义构造，如上表所定义的，同时还用于引用其他将被解释为非转义构造的字符。因此，表达式 \\ 与单个反斜线匹配，而 \ 与左括号匹配。
在不表示转义构造的任何字母字符前使用反斜线都是错误的；它们是为将来扩展正则表达式语言保留的。可以在非字母字符前使用反斜线，不管该字符是否非转义构造的一部分。
根据 Java Language Specification 的要求，Java 源代码的字符串中的反斜线被解释为 Unicode 转义或其他字符转义。因此必须在字符串字面值中使用两个反斜线，表示正则表达式受到保护，不被 Java 字节码编译器解释。例如，当解释为正则表达式时，字符串字面值 "\b" 与单个退格字符匹配，而 "\\b" 与单词边界匹配。字符串字面值 "\(hello\)" 是非法的，将导致编译时错误；要与字符串 (hello) 匹配，必须使用字符串字面值 "\\(hello\\)"。
字符类
字符类可以出现在其他字符类中，并且可以包含并集运算符（隐式）和交集运算符 (&&)。并集运算符表示至少包含其某个操作数类中所有字符的类。交集运算符表示包含同时位于其两个操作数类中所有字符的类。
字符类运算符的优先级如下所示，按从最高到最低的顺序排列：
1 字面值转义 \x
2 分组 [...]
3 范围 a-z
4 并集 [a-e][i-u]
5 交集 [a-z&&[aeiou]]
注意，元字符的不同集合实际上位于字符类的内部，而非字符类的外部。例如，正则表达式 . 在字符类内部就失去了其特殊意义，而表达式 - 变成了形成元字符的范围。
行结束符
行结束符 是一个或两个字符的序列，标记输入字符序列的行结尾。以下代码被识别为行结束符：
新行（换行）符 ('\n')、
后面紧跟新行符的回车符 ("\r\n")、
单独的回车符 ('\r')、
下一行字符 ('\u0085')、
行分隔符 ('\u2028') 或
段落分隔符 ('\u2029)。
如果激活 UNIX_LINES 模式，则新行符是惟一识别的行结束符。
如果未指定 DOTALL 标志，则正则表达式 . 可以与任何字符（行结束符除外）匹配。
默认情况下，正则表达式 ^ 和 $ 忽略行结束符，仅分别与整个输入序列的开头和结尾匹配。如果激活 MULTILINE 模式，则 ^ 在输入的开头和行结束符之后（输入的结尾）才发生匹配。处于 MULTILINE 模式中时，$ 仅在行结束符之前或输入序列的结尾处匹配。
组和捕获
捕获组可以通过从左到右计算其开括号来编号。例如，在表达式 ((A)(B(C))) 中，存在四个这样的组：
1 ((A)(B(C)))
2 \A
3 (B(C))
4 (C)
组零始终代表整个表达式。
之所以这样命名捕获组是因为在匹配中，保存了与这些组匹配的输入序列的每个子序列。捕获的子序列稍后可以通过 Back 引用在表达式中使用，也可以在匹配操作完成后从匹配器检索。
与组关联的捕获输入始终是与组最近匹配的子序列。如果由于量化的缘故再次计算了组，则在第二次计算失败时将保留其以前捕获的值（如果有的话）例如，将字符串 "aba" 与表达式 (a(b)?)+ 相匹配，会将第二组设置为 "b"。在每个匹配的开头，所有捕获的输入都会被丢弃。
以 (?) 开头的组是纯的非捕获 组，它不捕获文本，也不针对组合计进行计数。 参考技术A ^ 取反，&& 逻辑与 （并且）
[^456] 匹配一个 非4非5非6的任意字符，可以匹配：a、x、1、8、好、中……
[a-o&&[def]] 等价于[def]，可以匹配：d、e、f
[a-d&&[^bc]] 等价于 [ad]，可以匹配：a、d
以上都是匹配的单个字符，使用*、+、等可以匹配连续的多个字符本回答被提问者和网友采纳
Java 正则简单用法
正则表达式是一种可以用于模式匹配和替换的规范，一个正则表达式就是由普通的字符（例如字符a到z）以及特殊字符（元字符）组成的文字模式，它 用以描述在查找文字主体时待匹配的一个或多个字符串。正则表达式作为一个模板，将某个字符模式与所搜索的字符串进行匹配。
众所周知，在程序开发中，难免会遇到需要匹配、查找、替换、判断字符串的情况发生，而这些情况有时又比较复杂，如果用纯编码方式解决，往往会浪费程序员的时间及精力。因此，学习及使用正则表达式，便成了解决这一矛盾的主要手段。
下面是正则表达式的解释：
- // 反斜杠
- /t 间隔 (‘/u0009‘)
- /n 换行 (‘/u000A‘)
- /r 回车 (‘/u000D‘)
- /d 数字 等价于[0-9]
- /D 非数字 等价于[^0-9]
- /s 空白符号 [/t/n/x0B/f/r]
- /S 非空白符号 [^/t/n/x0B/f/r]
- /w 单独字符 [a-zA-Z_0-9]
- /W 非单独字符 [^a-zA-Z_0-9]
- /f 换页符
- /e Escape
- /b 一个单词的边界
- /B 一个非单词的边界
- /G 前一个匹配的结束
- ^为限制开头
- ^java 条件限制为以Java为开头字符
- $为限制结尾
- java$ 条件限制为以java为结尾字符
- . 条件限制除/n以外任意一个单独字符
- java.. 条件限制为java后除换行外任意两个字符
- 加入特定限制条件「[]」
- [a-z] 条件限制在小写a to z范围中一个字符
- [A-Z] 条件限制在大写A to Z范围中一个字符
- [a-zA-Z] 条件限制在小写a to z或大写A to Z范围中一个字符
- [0-9] 条件限制在小写0 to 9范围中一个字符
- [0-9a-z] 条件限制在小写0 to 9或a to z范围中一个字符
- [0-9[a-z]] 条件限制在小写0 to 9或a to z范围中一个字符(交集)
- []中加入^后加再次限制条件「[^]」
- [^a-z] 条件限制在非小写a to z范围中一个字符
- [^A-Z] 条件限制在非大写A to Z范围中一个字符
- [^a-zA-Z] 条件限制在非小写a to z或大写A to Z范围中一个字符
- [^0-9] 条件限制在非小写0 to 9范围中一个字符
- [^0-9a-z] 条件限制在非小写0 to 9或a to z范围中一个字符
- [^0-9[a-z]] 条件限制在非小写0 to 9或a to z范围中一个字符(交集)
下面几个简单的Java正则用例：
1 public class RegexTest { 2 public static void main(String[] args) { 3 String a = "aaaaa"; 4 String b = "11111"; 5 String c = "abc123"; 6 if (a.matches("\\\\D+")) { 7 System.out.println("This is first true"); 8 } 9 if (a.matches("[a-z]+")) { 10 System.out.println("This is second true"); 11 } 12 if (a.matches("[A-Z]+")) { 13 System.out.println("This is third true"); 14 } 15 if (b.matches("\\\\d+")) { 16 System.out.println("This is fourth true"); 17 } 18 if (b.matches("[0-9]+")) { 19 System.out.println("This is fifth true"); 20 } 21 if (c.matches("[a-zA-Z0-9]+")) { 22 System.out.println("This is sixth true"); 23 } 24 if (c.matches("\\\\D+\\\\d+")) { 25 System.out.println("This is seventh true"); 26 } 27 } 28 }
Pattern.compile函数，可以加入控制正则表达式的匹配行为的参数：
Pattern Pattern.compile(String regex, int flag)
flag的取值范围如下：
Pattern.CANON_EQ 当且仅当两个字符的"正规分解(canonical decomposition)"都完全相同的情况下，才认定匹配。比如用了这个标志之后，表达式"a/u030A"会匹配"?"。默认情况下，不考虑"规 范相等性(canonical equivalence)"。
Pattern.CASE_INSENSITIVE(?i) 默认情况下，大小写不明感的匹配只适用于US-ASCII字符集。这个标志能让表达式忽略大小写进行匹配。要想对Unicode字符进行大小不明感的匹 配，只要将UNICODE_CASE与这个标志合起来就行了。
Pattern.COMMENTS(?x) 在这种模式下，匹配时会忽略(正则表达式里的)空格字符(译者注：不是指表达式里的"//s"，而是指表达式里的空格，tab，回车之类)。注释从#开始，一直到这行结束。可以通过嵌入式的标志来启用Unix行模式。
Pattern.DOTALL(?s) 在这种模式下，表达式‘.‘可以匹配任意字符，包括表示一行的结束符。默认情况下，表达式‘.‘不匹配行的结束符。
Pattern.MULTILINE
(?m) 在这种模式下，‘^‘和‘$‘分别匹配一行的开始和结束。此外，‘^‘仍然匹配字符串的开始，‘$‘也匹配字符串的结束。默认情况下，这两个表达式仅仅匹配字符串的开始和结束。
Pattern.UNICODE_CASE
(?u) 在这个模式下，如果你还启用了CASE_INSENSITIVE标志，那么它会对Unicode字符进行大小写不明感的匹配。默认情况下，大小写不敏感的匹配只适用于US-ASCII字符集。
Pattern.UNIX_LINES(?d) 在这个模式下，只有‘/n‘才被认作一行的中止，并且与‘.‘，‘^‘，以及‘$‘进行匹配。
1 import java.io.File; 2 import java.io.FileFilter; 3 import java.io.PrintStream; 4 import java.util.ArrayList; 5 import java.util.Iterator; 6 import java.util.regex.Matcher; 7 import java.util.regex.Pattern; 8 9 public class FilesAnalyze { 10 //用于缓存文件列表 11 @SuppressWarnings("rawtypes") 12 private ArrayList files = new ArrayList(); 13 //用于承载文件路径 14 private String _path; 15 //用于承载未合并的正则公式 16 private String _regexp; 17 class MyFileFilter implements FileFilter { 18 /** 19 * 匹配文件名称 20 */ 21 public boolean accept(File file) { 22 try { 23 Pattern pattern = Pattern.compile(_regexp); 24 Matcher match = pattern.matcher(file.getName()); 25 return match.matches(); 26 } catch (Exception e) { 27 return true; 28 } 29 } 30 } 31 /** 32 * 解析输入流 33 * @param inputs 34 */ 35 FilesAnalyze(String path,String regexp){ 36 getFileName(path,regexp); 37 } 38 /** 39 * 分析文件名并加入files 40 * @param input 41 */ 42 @SuppressWarnings("unchecked") 43 private void getFileName(String path,String regexp) { 44 //目录 45 _path=path; 46 _regexp=regexp; 47 File directory = new File(_path); 48 File[] filesFile = directory.listFiles(new MyFileFilter()); 49 if (filesFile == null) return; 50 for (int j = 0; j < filesFile.length; j++) { 51 files.add(filesFile[j]); 52 } 53 return; 54 } 55 /** 56 * 显示输出信息 57 * @param out 58 */ 59 @SuppressWarnings("rawtypes") 60 public void print (PrintStream out) { 61 Iterator elements = files.iterator(); 62 while (elements.hasNext()) { 63 File file=(File) elements.next(); 64 out.println(file.getPath()); 65 } 66 } 67 public static void output(String path,String regexp) { 68 FilesAnalyze fileGroup1 = new FilesAnalyze(path,regexp); 69 fileGroup1.print(System.out); 70 } 71 public static void main (String[] args) { 72 output("D://","[A-z|.]*"); 73 } 74 }
http://www.cnblogs.com/shuqi/p/4427693.html这个博主的常用正则表达式比较全，可以深入学习下
以上是关于java正则表达式中[&&]用法的主要内容，如果未能解决你的问题，请参考以下文章