2010年7月 总版技术专家分月排行榜第二2010年6月 总版技术专家分月排行榜第二
2010年5月 总版技术专家分月排行榜第三
2010年7月 总版技术专家分月排行榜第二2010年6月 总版技术专家分月排行榜第二
2010年5月 总版技术专家分月排行榜第三
本帖子已过去太久远了，不再提供回复功能。关于字符串的专题-阿里云资讯网
字符串或串(String)是由数字、字母、下划线组成的一串字符。一般记为 s=“a1a2&&&an”(n&=0)。它是编程语言中表示文本的数据类型。字符串主要用于编程，概念说明、函数解释、用法详述见正文，这里补充两点：1.FreePascal中的Ansistring只能看成整体，很多函数无法使用，就算是提取单个元素也很麻烦，所以除非万不得已就不要用；2.字符串在存储上类似字符数组，所以它每一位的单个元素都是可以提取的，如s=“aaaaabbbbb”，则s【1】=“a”，s【10】=&b&，而字符串的零位正是它的长度，如s【0】=10（上述功能Ansistring没有。），还可以提供很多方便，如高精度运算时每一位都可以转化为数字存入数组。
　 中介交易 /zixun/aggregation/6858.html&&SEO诊断 淘宝客 云主机 技术大厅 　 　　盗号木马相信大家都不陌生。随着网络越来越普及，网上的账号密码越来越重要，盗号木马的生命力也就越发的顽强了。 　　随着与杀毒软件的对抗，盗号木马也在不断的更新换代。QQ粘虫就是一个很典型的例子，这类木马的特点可以参考我...
　　中文分词又叫中文切词，中文划词等，是seo必须掌握的一个/zixun/aggregation/22929.html&&基础知识。现有的中文分词算法可分为三大类：基于字符串匹配的分词方法、基于理解的分词方法和基于统计的分词方法。 　　1、基于字符串匹配的分词方法 　　这种方法又叫做机械分词方法，它是按照一定的策略将待分析的汉字串与一...
中文分词技术属于自然语言/zixun/aggregation/20795.html&&处理技术范畴，对于一句话，人可以通过自己的知识来明白哪些是词，哪些不是词，但如何让计算机也能理解？其处理过程就是分词算法。 　　现有的分词算法可分为三大类：基于字符串匹配的分词方法、基于理解的分词方法和基于统计的分词方法。　　1、基于字符串匹配的分词...
　&/zixun/aggregation/37954.html&& 如何快速的进入Windows 2003操作系统呢？在本文中我们将介绍两种快速登陆Windows 2003操作系统的方法： 　　一种方法比较简单，您只需单击“开始|运行”，并在输入框中键入“control userpasswords2”，这样就可以在“...
很多情况下，我们需要脱除一个字符串中可能会存在的引号，然后在加上自己的引号使其中的特殊字符（命令连接符& 、| 、&&、||，命令行参数界定符Space 、tab 、; 、= ，字符化转义符^ 、& ，变量化转义符% 等）字符化，失去特定的作用，而作为普通的字符成为字符串的一个组成部分。　　一、将字符串中的引号脱去的简单办法有三种，它们的功能相近，只是各自的...
&/zixun/aggregation/37954.html&& & 本节介绍使用HDFS 的API 编程的简单示例。 & & 下面的程序可以实现如下功能：在输入文件目录下的所有文件中，检索某一特定字符串所出现的行，将这些行的内容输出到本地文件系统的输出文件夹中。这一功能在分析MapRe...
作为一个概念而言，正则表达式对于Python来说并不是独有的。但是，Python中的正则表达式在实际使用过程中还是有一些细小的差别。 本文是一系列关于Python正则表达式文章的其中一部分。在这个系列的第一篇文章中，我们将重点讨论如何使用Python中的正则表达式并突出Python中一些独有的特性。 我们将介绍Python中对字符串进行搜索和查找的一些方法。然后我们讲讨论如何使用分组来处理我...
似乎Google现在已经成了万能的代名词，google大学，利用google搜索恶意软件，google盲人搜索等等，Google的功能我们数也数不清。如今，国外的一个站点Bugle利用Google来代替编译器，利用google，用户可以查找代码中一些常见的错误，例如：缓冲区溢出、格式化字符串等等。用法如下例所示： 　　简单的字符串拷贝：strcpy(buf,str) 　　这是一个简单的C格式...
一.数据控制语句 (DML) 部分 1.INSERT&/zixun/aggregation/37954.html&& (往6184.html&&数据表里插入记录的语句) INSERT INTO 表名(字段名1, 字段名2, ……) VALUES ( 值1, 值2, ……);& INSER...
随着 web 发展，前端应用变得越来越复杂，基于后端的 javascript(Node.js) 也开始崭露头角，此时 javascript 被寄予了更大的期望，与此同时 javascript MVC 思想也开始流行起来。javascript 模板引擎作为数据与界面分离工作中最重要一环，越来越受开发者关注，近一年来在开源社区中更是百花齐放，在 Twitter、淘宝网、新浪微博、腾讯QQ空间、腾...
如今的流氓网站越来越流氓了，今天到绿盟软件下载软件，结果一不小心就被误导，随后中招。中的是一个叫做“ pp2345网址导航 ”的流氓网站，只要用户误下载了一个EXE可执行程序，点击之后程序随即消失，从此以后再打开IE、Opera、遨游、火狐等N多浏览器，都会被指向&&这个流氓网站。 后来我发现，这个流氓软件的作者还非常聪明，他先将用户桌面和开始菜单中...
本文主要是精灵复习php正则表达式记录下的学习笔记，正则表达式一直都是程序学习的难点，在seo中，也有很多地方用到，如301转向规则，rewrite规则，都是基于正则表达式的，含有一些cms的模板自变量修改替换，如dedecms，也可以使用正则表达式，若是将其融汇贯通，对seo还是有一定帮助的。 下面是复习笔记： 正则表达式简介及正则表达式在PHP中的作用正则表达式是一种表示规则的途经，在 ...
　　当人们通过搜索引擎进入你的网站时，搜索引擎会告诉你人们通过什么样的引用字符串。你的/zixun/aggregation/13143.html&&网络分析工作使用的引用字符串决定了用户是如何发现你的网站的。这有助于你理解什么人在进行搜索，他们最终是如何发现你的，等等。当你使用付费搜索时有许多灵活性，你在网络分析工具中输入了什么样的词...
由于 GNU 的 /zixun/aggregation/29818.html&&Fortran 和 C 语言二者的函数彼此可以直接相互调用，所以混合编程可以非常容易地实现。只要你足够仔细，确保函数调用时传递的参数类型正确，函数就可以在两种语言间来回调用，就像它们是同一种语言一样。 下表中列出了 Fortran 的数据类型和它们在 C...
本书所有章节里，你都无法避开接口这一概念，不论以何种形式。因此，对读者而言，理解接口的意义相当重要。在大型软件项目中，特别是那些预期或需要与大量其它软件互动的项目中，开发精确良好的应用开发接口（APIs）是非常有必要的。我们可以把API看作整个框架的标准，就像RFC或POSIX标准那样。一旦定义并发布了一个接口，它就不应随意改变。此外，API在单体软件里也很有用，它被看作内部API。 接口（...
符号计算语言
Treep是一个用于符号计算的简单语言。它可以用于更复杂对象中的数字和字符串进行组织，这些对象是存储在AVL树内存的值对列表。它大约有六十个内置函数来操作这些数据和用新的方法来定义新的功能，Treep语法非常类似于Lisp。 Treep 该版本进行了速度的优化，比以前更快。在源代码中，“转到”是用来跳过不必要的检查。 软件信息：http://www.dubiel.pl/...
Sally 0.6.3是一组字符串映射到一组向量的工具。这个映射被称为嵌入，并让机器学习和数据挖掘技术应用于字符串数据的分析。它可用于数据，如文本文件，DNA序列，或日志文件。被用作向量空间模型或bag-of-words模型。字符串是通过一组特性，每个特性与向量空间的一个方面是相关联的。另外，二进制或TF-IDF值是可以计算出来的。向量可以输出纯文本，LIBSVM，或Matlab格式。 S...
Strings edit 是一个提供了I/O设备的库，用于整数、浮点数，罗马数字和字符串。配备的输入和输出子程序支持流处理的字符串指针，输出可以对齐一个固定大小的字段填充，数字输入可以检测预期值的范围是饱和或异常，浮点数输出可以指定相对或绝对的输出精度。支持UTF-8编码的字符串，包括通配符模式匹配、集和代码点maps，大/小写和其他Unicode的分类。 Strings edit支持的I/...
到目前为止，我们简单地搜索了一个静态字符串。正则表达式通常也用不同的方式，通过下面的 `RegexObject` 方法，来修改字符串。 方法/属性作用 split()将字符串在 RE 匹配的地方分片并生成一个列表， sub()找到 RE 匹配的所有子串，并将其用一个不同的字符串替换 subn()与 sub() 相同，但返回新的字符串和替换次数 将字符串分片 `RegexObject` 的...
到目前为止，我们只展示了正则表达式的一部分功能。在本节，我们将展示一些新的元字符和如何使用组来检索被匹配的文本部分。 更多的元字符 还有一些我们还没展示的元字符，其中的大部分将在本节展示。剩下来要讨论的一部分元字符是零宽界定符（zero-width assertions）。它们并不会使引擎在处理字符串时更快;相反，它们根本就没有对应任何字符，只是简单的成功或失败。举个例子， \b 是一个在...
本文是通过Python的 re 模块来使用正则表达式的一个入门教程，和库参考手册的对应章节相比，更为浅显易懂、/zixun/aggregation/32779.html&&循序渐进。Python 自1.5版本起增加了re 模块，它提供 Perl 风格的正则表达式模式。Python 1.5之前版本则是通过 regex 模块提供 Emac...
GNU grep是一个基于快速lazy-state匹配程序的字符串搜索工具，使用完整的正则表达式匹配进行文本字符搜索。搜索结果比Unix grep或egrep速度快很多倍。 grep 2.10该版本的“CHAR”不再是一个符号类型系统上处理不当位设置模式字节。现在拒绝的命令行，可能会导致在一个无限的磁盘填充循环。 软件信息：http://www.gnu.org/software/grep/...
&1、MySQL存在text和blob：(1)、相同在TEXT或BLOB列的存储或检索过程中，不存在大小写转换,当未运行在严格模式时，如果你为BLOB或TEXT列分配一个超过该列类型的最大长度的值值，值被截取以保证适合。如果截掉的字符不是空格，将会产生一条警告。使用严格SQL模式，会产生错误，并且值将被拒绝而不是截取并给出警告。BLOB和TEXT列不能有默认值。当保存或检索BLOB...
&在Sun的Java JDK 1.40版本中，Java自带了支持正则表达式的包，本文就抛砖引玉地介绍了如何使用java.util.regex包。 　　可粗略估计一下，除了偶尔用Linux的外，其他Linu x用户都会遇到正则表达式。正则表达式是个极端强大工具，而且在字符串模式-匹配和字符串模式-替换方面富有弹性。在Unix世界里，正则表达式几乎没有什么限制，可肯定的是，它应用非常之...
&SQL中的单记录函数 1.ASCII返回与指定的字符对应的十进制数;SQL& select ascii('A') A,ascii('a') a,ascii('0') zero,ascii(' ') &&&&&&& A&&&&&amp...
若您要投稿、删除文章请联系邮箱：zixun-group@，工作人员会在5个工作日内回复。
售前咨询热线
服务与支持
账号与支持
关注阿里云
InternationalJava语言的关键字，数据类型 - ITeye问答
请问:
标识符，字面值，字符，字符串他们的区别是什么？
我刚开始学计算机语言，不懂之处请多多关照！！！
举一个例子：
姓名：张三
那个姓名就是标识符，那个名字就是字面值。
字符和字符串的区别，就是字符是用的单引号('')而字符串用的是双引号("")
当然在计算机中他们具体存储方式是完全不一样的。
标识符就是有特定意义的标记识别的符号,就如一个狮子(名字标记为狮子的动物)去捕猎(标记为捕猎的动作),这样,编程时我们可以清楚明白发生了什么事情.如java标识符中有特别意义的标识符int,就代表整数的意思了.
23,在没有其他明确的情况下,你不知道23可以怎么称呼23,可以是整数的23,可以是自然数的23,但这个时候没有任何名称比"23"(字面值)称呼23更好了,所以这样的情况"23"就是23字面值了.简单点就是说,23的字面值是23,v的字面值是v
字符,是根据不同字符编码方案展现出来的单个字符.如ASCII方案中的'a'就是一个字符,'7'也是一个字符,一些特别的如空格都是一个字符.通常在程序中,以单引号''标记的.
字符串,就是一连串的字符,如"i am new",通常在程序中,以双引号""标记的.
char a='a';
String b="b";
a和b就叫标识符
'a'是字符，字面值是a
"b"是字符串，字面值是b
从来没想过它们的区别。
标示符：好比一个东西的名字
字面值：只能用一个值才称呼它
字符：单元素。'a'表示一个字符
字符串：'aaaaa'表示一个字符串
已解决问题
未解决问题sponsored links
java中的正则表达式详解
转自：/category/91108?show_full=true
想必很多人都对正则表达式都头疼。今天，我以我的认识，加上网上一些文章，希望用常人都可以理解的表达方式来和大家分享学习经验。
　　开篇,还是得说说 ^ 和 $ 他们是分别用来匹配字符串的开始和结束，以下分别举例说明：
　　"^The": 开头一定要有"The"字符串;
　　"of despair$": 结尾一定要有"of despair" 的字符串;
　　"^abc$": 就是要求以abc开头和以abc结尾的字符串，实际上是只有abc匹配。
　　"notice": 匹配包含notice的字符串。
　　你可以看见如果你没有用我们提到的两个字符(最后一个例子)，就是说 模式(正则表达式) 可以出现在被检验字符串的任何地方，你没有把他锁定到两边。
　　接着,说说 '*', '+',和 '?',
　　他们用来表示一个字符可以出现的次数或者顺序. 他们分别表示：
　　"zero or more"相当于{0,},
　　"one or more"相当于{1,},
　　"zero or one."相当于{0,1}, 这里是一些例子:
　　"ab*": 和ab{0,}同义,匹配以a开头,后面可以接0个或者N个b组成的字符串("a", "ab", "abbb", 等);
　　"ab+": 和ab{1,}同义,同上条一样，但最少要有一个b存在 ("ab", "abbb", 等.);
　　"ab?":和ab{0,1}同义,可以没有或者只有一个b;
　　"a?b+$": 匹配以一个或者0个a再加上一个以上的b结尾的字符串.
　　要点, '*', '+',和 '?'只管它前面那个字符.
　　你也可以在大括号里面限制字符出现的个数，比如
　　"ab{2}": 要求a后面一定要跟两个b(一个也不能少)("abb");
　　"ab{2,}": 要求a后面一定要有两个或者两个以上b(如"abb", "abbbb", 等.);
　　"ab{3,5}": 要求a后面可以有2-5个b("abbb", "abbbb", or "abbbbb").
　　现在我们把一定几个字符放到小括号里，比如：
　　"a( bc) *": 匹配 a 后面跟0个或者一个"bc";
　　"a( bc) {1,5}": 一个到5个 "bc."
　　还有一个字符 '│', 相当于OR 操作:
　　"hi│hello": 匹配含有"hi" 或者 "hello" 的 字符串;
　　"(b│cd)ef": 匹配含有 "bef" 或者 "cdef"的字符串;
　　"(a│b)*c": 匹配含有这样多个(包括0个)a或b，后面跟一个c的字符串;
　　一个点('.' )可以代表所有的单一字符,不包括"/n"
　　如果,要匹配包括"/n"在内的所有单个字符,怎么办?
　　对了,用'[/n.]'这种模式.
　　"a.[0-9] ": 一个a加一个字符再加Java编程
字符串处理是许多程序中非常重要的一部分,它们可以用于文本显示,数据表示,查找键和很多目的.在Unix下,用户可以使用正则表达式的强健功能实现
这些目的,从Java1.4起,Java核心API就引入了java.util.regex程序包,它是一种有价值的基础工具,可以用于很多类型的文本处理,如匹配,搜索,提取
和分析结构化内容.
java.util.regex是一个用正则表达式所订制的模式来对字符串进行匹配工作的类库包。它包括两个类：Pattern和Matcher.Pattern是一个正则表达式经编译后的表现模式。 在java中,通过适当命名的Pattern类可以容易确定String是否匹配某种模式.模式可以象匹配某个特
定的String那样简单,也可以很复杂,需要采用分组和字符类,如空白,数字,字母或控制符.因为Java字符串基于统一字符编码(Unicode),正则表达式也
适用于国际化的应用程序.
Pattern类的方法简述方法 说明 static Pettern compile(String regex,int flag) 编译模式,参数regex表示输入的正则表达式,flag表示模式类型(Pattern.CASE_INSENSITIVE 表示
不区分大小写) Matcher match(CharSequence input) 获取匹配器,input时输入的待处理的字符串 static boolean matches(String regex, CharSequence input) 快速的匹配调用,直接根据输入的模式regex匹配input String[] split(CharSequence input,int limit) 分隔字符串input,limit参数可以限制分隔的次数
Matcher 一个Matcher对象是一个状态机器，它依据Pattern对象做为匹配模式对字符串展开匹配检查。首先一个Pattern实例订制了一个所用语法与
PERL的类似的正则表达式经编译后的模式，然后一个Matcher实例在这个给定的Pattern实例的模式控制下进行字符串的匹配工作。
Matcher类的方法简述方法 说明 boolean matches() 对整个输入字符串进行模式匹配. boolean lookingAt() 从输入字符串的开始处进行模式匹配 boolean find(int start) 从start处开始匹配模式 int groupCount() 返回匹配后的分组数目 String replaceAll(String replacement) 用给定的replacement全部替代匹配的部分 String repalceFirst(String replacement) 用给定的replacement替代第一次匹配的部分 Matcher appendReplacement(StringBuffer sb,String replacement) 根据模式用replacement替换相应内容,并将匹配的结果添加到sb当前位置之后 StringBuffer appendTail(StringBuffer sb) 将输入序列中匹配之后的末尾字串添加到sb当前位置之后.
正则表达式中常见通配符:对于单字符串比较而言,使用正则表达式没有什么优势.Regex的真正强大之处在于体现在包括字符类和量词(*,+,?)的更复杂的模式上.字符类包括:/d 数字/D 非数字/w 单字字符(0-9,A-Z,a-z)/W 非单字字符/s 空白(空格符,换行符,回车符,制表符)/S 非空白[] 由方括号内的一个字符列表创建的自定义字符类.&& 匹配任何单个字符下面的字符将用于控制将一个子模式应用到匹配次数的过程.? 重复前面的子模式0次到一次* 重复前面的子模式0次或多次+ 重复前面的子模式一次到多次
以下是实例部分:
实例一:正则式是最简单的能准确匹配一个给定String的模式,模式与要匹配的文本是等价的.静态的Pattern.matches方法用于比较一个String是否匹配一个给
定模式.例程如下:String data="java";boolean result=Pattern.matches("java",data);
实例二:String[] dataArr = { "moon", "mon", "moon", "mono" };
&&& for (String str : dataArr) {String patternStr="m(o+)n";boolean result = Pattern.matches(patternStr, str);if (result) {System.out.println("字符串"+str+"匹配模式"+patternStr+"成功");}else{System.out.println("字符串"+str+"匹配模式"+patternStr+"失败");}&&&& }
模式是&m(o+)n&,它表示mn中间的o可以重复一次或多次,因此moon,mon,mooon能匹配成功,而mono在n后多了一个o,和模式匹配不上.
注:+表示一次或多次;?表示0次或一次;*表示0次或多次.
实例三:String[] dataArr = { "ban", "ben", "bin", "bon" ,"bun","byn","baen"};
&&& for (String str : dataArr) {String patternStr="b[aeiou]n";boolean result = Pattern.matches(patternStr, str);if (result) {System.out.println("字符串"+str+"匹配模式"+patternStr+"成功");}else{System.out.println("字符串"+str+"匹配模式"+patternStr+"失败");}&&&& }
注:方括号中只允许的单个字符,模式&b[aeiou]n&指定,只有以b开头,n结尾,中间是a,e,i,o,u中任意一个的才能匹配上,所以数组的前五个可以匹配,
后两个元素无法匹配.
方括号[]表示只有其中指定的字符才能匹配.
实例四:String[] dataArr = { "been", "bean", "boon", "buin" ,"bynn"};
&&& for (String str : dataArr) {String patternStr="b(ee|ea|oo)n";boolean result = Pattern.matches(patternStr, str);if (result) {System.out.println("字符串"+str+"匹配模式"+patternStr+"成功");}else{System.out.println("字符串"+str+"匹配模式"+patternStr+"失败");}&&&& }
如果需要匹配多个字符,那么[]就不能用上了,这里我们可以用()加上|来代替,()表示一组,|表示或的关系,模式b(ee|ea|oo)n就能匹配been,bean,boon
等.因此前三个能匹配上,而后两个不能.
实例五:String[] dataArr = { "1", "10", "101", "1010" ,"100+"};
&&& for (String str : dataArr) {String patternStr="//d +";boolean result = Pattern.matches(patternStr, str);if (result) {System.out.println("字符串"+str+"匹配模式"+patternStr+"成功");}else{System.out.println("字符串"+str+"匹配模式"+patternStr+"失败");}&&&& }
注:从前面可以知道,//d表示的是数字,而+表示一次或多次,所以模式//d +就表示一位或多位数字.因此前四个能匹配上,最后一个因为+号是非数字字符而匹配不上.
实例六:String[] dataArr = { "a100", "b20", "c30", "df10000" ,"gh0t"};
&&& for (String str : dataArr) {String patternStr="//w+//d +";boolean result = Pattern.matches(patternStr, str);if (result) {System.out.println("字符串"+str+"匹配模式"+patternStr+"成功");}else{System.out.println("字符串"+str+"匹配模式"+patternStr+"失败");}&&&& }
模式//w+//d +表示的是以多个单字字符开头,多个数字结尾的字符串,因此前四个能匹配上,最后一个因为数字后还含有单字字符而不能匹配.
实例七:String str="薪水,职位 姓名;年龄 性别";String[] dataArr =str.split("[,//s;]");for (String strTmp : dataArr) {System.out.println(strTmp); }
String类的split函数支持正则表达式,上例中模式能匹配&,&,单个空格,&;&中的一个,split函数能把它们中任意一个当作分隔符,将一个字符串劈
分成字符串数组.
实例八:String str="日";Pattern p = pile("[年月日]"); String[] dataArr =p.split(str);for (String strTmp : dataArr) {System.out.println(strTmp);}
Pattern是一个正则表达式经编译后的表现模式 ,它的split方法能有效劈分字符串.注意其和String.split()使用上的不同.
实例九:String str="10元 1000人民币 10000元 100000RMB";str=str.replaceAll("(//d +)(元|人民币|RMB)", "$1￥");System.out.println(str);
上例中,模式&(//d +)(元|人民币|RMB)&按括号分成了两组,第一组//d +匹配单个或多个数字,第二组匹配元,人民币,RMB中的任意一个,替换部分$1表
示第一个组匹配的部分不变,其余组替换成￥.
替换后的str为￥10 ￥1000 ￥10000 ￥100000
实例十:Pattern p = pile("m(o+)n",Pattern.CASE_INSENSITIVE);
// 用Pattern类的matcher()方法生成一个Matcher对象Matcher m = p.matcher("moon mooon Mon mooooon Mooon");StringBuffer sb = new StringBuffer();
// 使用find()方法查找第一个匹配的对象boolean result = m.find();
// 使用循环找出模式匹配的内容替换之,再将内容加到sb里while (result) {m.appendReplacement(sb, "moon");result = m.find();}// 最后调用appendTail()方法将最后一次匹配后的剩余字符串加到sb里；m.appendTail(sb);
System.out.println("替换后内容是" + sb.toString());
实例十一:除了用+表示一次或多次,*表示0次或多次,?表示0次或一次外,还可以用{}来指定精确指定出现的次数,X{2,5}表示X最少出现2次,最多出现5次;X{2,}表
示X最少出现2次,多则不限;X{5}表示X只精确的出现5次.例程:String[] dataArr = { "google", "gooogle", "gooooogle", "goooooogle","ggle"};
for (String str : dataArr) {String patternStr = "g(o{2,5})gle";
&&& boolean result = Pattern.matches(patternStr, str);if (result) {System.out.println("字符串" + str + "匹配模式" + patternStr + "成功");} else {System.out.println("字符串" + str + "匹配模式" + patternStr + "失败");}}
实例十二:-表示从..到&,如[a-e]等同于[abcde]String[] dataArr = { "Tan", "Tbn", "Tcn", "Ton","Twn"};
&&& for (String str : dataArr) {String regex = "T[a-c]n";
&&&&& boolean result = Pattern.matches(regex, str);if (result) {System.out.println("字符串" + str + "匹配模式" + regex + "成功");} else {System.out.println("字符串" + str + "匹配模式" + regex + "失败");}}实例十三:不区分大小写匹配.正则表达式默认都是区分大小写的,使用了Pattern.CASE_INSENSITIVE则不对大小写进行区分.
String patternStr="ab";Pattern pile(patternStr, Pattern.CASE_INSENSITIVE);String[] dataArr = { "ab", "Ab", "AB"};for (String str : dataArr) {Matcher matcher=pattern.matcher(str);if(matcher.find()){System.out.println("字符串" + str + "匹配模式" + patternStr + "成功");}}
实例十四:使用正则表达式劈分字符串.注意这里要把复杂的模式写在前面,否则简单模式会先匹配上.
String input="职务=GM 薪水=50000 , 姓名=职业经理人 ; 性别=男 年龄=45 ";String patternStr="(//s*,//s*)|(//s*;//s*)|(//s +)";Pattern pile(patternStr);String[] dataArr=pattern.split(input);for (String str : dataArr) {System.out.println(str);}实例十五:解析正则表达式中的文字,//1对应第一个小括号括起来的group1.String regex="&(//w+)&(//w+)&///1 &";Pattern pile(regex);String input="&name&Bill&/name&&salary&50000&/salary&&title&GM&/title&";Matcher matcher=pattern.matcher(input);while(matcher.find()){System.out.println(matcher.group(2));}
实例十六:将单词数字混合的字符串的单词部分大写.String regex="([a-zA-Z]+[0-9]+)";&& Pattern pile(regex);String input="age45 salary00 title";Matcher matcher=pattern.matcher(input);StringBuffer sb=new StringBuffer();while(matcher.find()){String replacement=matcher.group(1).toUpperCase();matcher.appendReplacement(sb, replacement);}matcher.appendTail(sb);System.out.println("替换完的字串为"+sb.toString());
2009-12-29
JAVA正则表达式类的使用
文章分类:Java编程
import java.util.regex.Mimport java.util.regex.P
/* @author ZhuYuanXi* 正则表达式的使用*/public class Test {
/* 字符串匹配* @param expression 正则表达式字符串* @param text 要进行匹配的字符串*/private static void matchingText(String expression, String text) {&& Pattern p = pile(expression); // 正则表达式&& Matcher m = p.matcher(text); // 操作的字符串&& boolean b = m.matches();&& System.out.println(b);}/* 字符串替换* @param expression 正则表达式字符串* @param text 要进行替换操作的字符串* @param str 要替换的字符串*/private static void replaceText(String expression, String text, String str) {&& Pattern p = pile(expression); // 正则表达式&& Matcher m = p.matcher(text); // 操作的字符串&& String s = m.replaceAll(str);&& System.out.println(s);}/* 字符串查找* @param expression 正则表达式字符串* @param text 要进行查找操作的字符串* @param str 要查找的字符串*/private static void findText(String expression, String text, String str) {&& Pattern p = pile(expression); // 正则表达式&& Matcher m = p.matcher(text); // 操作的字符串&& StringBuffer sb = new StringBuffer();&& int i = 0;&& while (m.find()) {&&& m.appendReplacement(sb, str);&&& i++;&& }&& m.appendTail(sb);&& System.out.println(sb.toString());&& System.out.println(i);}/* 字符串分割* @param expression 正则表达式字符串* @param text 要进行分割操作的字符串*/private static void splitText(String expression, String text) {&& Pattern p = pile(expression); // 正则表达式&& String[] a = p.split(text);&& for (int i = 0; i & a. i++) {&&& System.out.println(a[i]);&& }}/* @param args*/public static void main(String[] args) {&& matchingText("^card_([_0-9a-zA-Z]+[_0-9a-zA-Z-/]*[_0-9a-zA-Z]+)/?.shtml$", "card_.shtml");&& // 字符串匹配，这是不符合的&& matchingText("a*b", "baaaaab");&& // 字符串匹配，这是符合的&& matchingText("a*b", "aaaaab");&& // 字符串匹配，通用匹配&& matchingText("^([_0-9a-zA-Z]+[_0-9a-zA-Z-/]*[_0-9a-zA-Z]+)/?", "aaaaab");
&& // 字符串替换&& replaceText("ab", "aaaaab", "d");&& replaceText("a*b", "aaaaab", "d");&& replaceText("a*b", "caaaaab", "d");
&& // 字符串查找&& findText("cat", "one cat two cats in the yard", "dog");&& findText("(fds){2,}", "dsa da fdsfds aaafdsafds aaf", "dog");&&&& // 字符串分割&& splitText("a+", "caaaaaat");&& splitText("a+", "c aa aaaa t");&& splitText(" +", "c aa&&& aaaa t");&& splitText("//+", "dsafasdfdsafsda+dsagfasdfa+sdafds");}
2009-12-29
学点Java正则表达式 选择自 DotJox 的 Blog
文章分类:Java编程
&正则表达式用来指定字符串模式。当你需要定位匹配某种模式的字符串时就可以使用正则表达式。例如，我们下面的一个例程就是在一个HTML文件中通过查找字符串模式&a href="..."&来定位所有的超链接。&&& 当然，为了指定一种模式，使用...这种记号是不够精确的。你需要精确地指定什么样的字符
排列是一个合法的匹配。当描述某种模式时，你需要使用一种特殊的语法。&&& 这里有一个简单例子。正则表达式[Jj]ava.+匹配下列形式的任何字符串：
作者Blog： http://blog.csdn.net/DotJox/
学点Java正则表达式
TCP存活定时器（TCP Keepalive Timer）
TCP持续定时器（TCP Persist Timer）
uClinux在S3C44B0X上的移植
首字母是J或j
后续的三个字母是ava
字符串的剩余部分由一个或多个任意字符组成
&&& 例如，字符串&javaness&匹配这个特殊的正则表达式，但是字符串&Core Java&却不匹配。&&& 如你所见，你需要了解一点语法来理解正则表达式的含意。幸运的是对于大多数的用途，使用少量的简单构造（straightforward constructs）就已足够。
字符类是可选自符的集合，用&[&封装，比如[Jj],[0-9],[A-Za-z]或[^0-9]。这里的-表示范围（Unicode落在两个边界之间的所有字符），^表示求补（指定字符外的所有字符）。
有许多预定以的字符类，像/d（数字）或/p{Sc}（Unicode货币符号），见表12-8和12-9。
大多数字符与它们自身匹配，像上例中的ava字符。
符号.匹配任何字符（可能行终止符（line terminators）除外，这依赖于标识设置（flag settings））
/用作转义符，比如/.匹配一个句点，//匹配一个反斜杠。
&^和$分别匹配行头和行尾
如果X和Y都是正则表达式，则XY表示&X的匹配后面跟着Y的匹配&。X|Y表示&任何X或Y的匹配&
可以将量词（quantifier）用到表达式中，X+ 表示X重复1次或多次，X* 表示X重复0次或多次，X? 表示X重复0次或1次
&默认地，一个量词总是与使总体成功匹配的最长的可能重复匹配。可以加上后缀？（称为reluctant或stingy 匹配，用以匹配最小的重复数），和+（称为possessive或贪婪匹配，用以即使在总体匹配失败的情况下也匹配最大的重复数）来更改这种属性。
例如，字符串cab匹配[a-z]*ab，但不匹配[a-z]*+ab。第一种情况下，[a-z]*只匹配字符c，因此字符ab正好与模式的剩余部分匹配。但是贪婪版本[a-z]*+就与字符cab匹配，模式的剩余部分ab就匹配失败（，这样总体也就匹配失败）。
可以使用分组来定义子表达式。将分组封装在（）中，如([+-]?)([0-9]+)。然后你可以让模式匹配符（the pattern matcher）返回每个分组的匹配，或者使用/n来回引分组（refer back to a group with /n），其中n是组号（以/1起始）
&&& 这里有一个稍微有点复杂却又很有用的正则表达式－－它用来描述十进制和十六进制的整数。[+-]?[0-9]+|0[Xx][0-9A-Fa-f]+&&& 不幸的是，在使用正则表达式的各种程序和库之间，它的语法还没有完全标准化。对基本的构造上已达成了共识，但在细节方面有许多令人&抓狂&的区别（many maddening differences）。Java的正则表达式类使用了与Perl语言类似的语法，但也不尽相同。表12-8显示了Java语法的所有正则表达式构造。要了解更多关于正则表达式的信息，请参考Pattern类的API文档，或者Jeffrey E. F. Friedl的著作《Mastering Regular Expressions》(O'Reilly and Associates, 1997)（刚去第二书店查了一下，东南大学出版社已经引入了其第二版，影印）表12-8 正则表达式语法
语法&& &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& 解释
字符 c&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& 字符c/unnnn, /xnn, /0n, /0nn, /0nnn&&&&&&&&& 带有十六或八进制值的代码单元
/0n&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& 八进制0n代表的字符（0&=n&=7）
/0nn&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& 八进制0nn代表的字符(0&=n&=7)
/0mnn&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& 八进制0mnn代表的字符(0&=m&=3,0&=n&=7)
/xnn&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& 十六进制 0xnn所代表的字符
/uhhhh&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& 十六进制 0xhhhh所代表的字符
/t, /n, /r, /f, /a, /e&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& 控制字符，依次是制表符，换行符，回车符，换页符，报警符和转义符/cc&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& 控制字符中出现的相应字符c
字符类 [C1C2. . .]&&&&&&&&&&&&&&&&&&&&&& C1、C2&&中的任何字符。Ci可以是字符，字符范围（C1-C2）或者字符类。[^. . .]&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& 字符类的补集[ . . . && . . .]&&&&&&&&&&&&&&&&&&& 两个字符类的交集
预定义字符类 .&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& 除行终止符外的任何字符（如果DOTALL标志置位，则表示任何字符）/d&&& & & & & & & & & & & & & & & & & & 数字[0-9]/D&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& 非数字[^0-9]/s&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& 空白字符[/t/n/r/f/x0B]/S&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& 非空白字符/w&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& 单词字符[a-zA-Z0-9_]/W&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& 非单词字符/p{name}&&&&&&&&&&&&&&&&&&&&&&& 一个指定的字符类，见表12-9/P{name}&&&&&&&&&&&&&&&&&&&&&& 指定字符类的补集
边界匹配符 ^ $&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& 输入的开头和结尾(在多行模式(multiline mode)下是行的开头和结尾)/b&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& 单词边界/B&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& 非单词边界/A&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& 输入的开头/z&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& 输入的结尾/Z& & & & & & & & & & & & & & & & & & 除最后行终止符之外的输入结尾/G&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& 上个匹配的结尾
量词 X?&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& 可选的X（即X可能出现，也可能不出现）X*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& X，可以重复0次或多次X+& & & & & & & & & & & & & & & & & & X，可以重复1次或多次X{n} X{n,} X{n,m}&&&&&&&&& X重复n次，至少重复n次，重复n到m次
量词后缀 ?&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& 设默认（贪婪）匹配为reluctant匹配+&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& 设默认（贪婪）匹配为possessive匹配
集合操作 XY&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& X的匹配后面跟着Y的匹配X|Y&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& X或Y的匹配
分组 (X) & & & & & & & & & & & & & & && 匹配X并且在一个自动计数的分组中捕获它/n&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& 与第n个分组的匹配
转义 /c&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& 字符c（必须不是字母）/Q.../E&&&&&&&&&&&&&&&&&&&&&&&&&&& 逐字地引用...（？...）&&&&&&&&&&&&&&&&&&&&&& 特殊构造，看Pattern类的API
&&& 正则表达式的最简单使用是测试一个特殊的字符串是否与之匹配。这里有一个Java写的测试程序。首先从表示正则表达式的字符串构造一个Pattern对象。然后从该模式获得一个Matcher对象，并且调用它的matches()方法：
Pattern pattern = pile(patternString, Pattern.CASE_INSENSITIVE + Pattern.UNICODE_CASE);
下面CASE_INSENSITIVE：匹配字符时与大小写无关，该标志默认只考虑US ASCII字符。
UNICODE_CASE：当与CASE_INSENSITIVE结合时，使用Unicode字母匹配
MULTILINE：^和$匹配一行的开始和结尾，而不是整个输入
UNIX_LINES： 当在多行模式下匹配^和$时，只将'/n'看作行终止符
DOTALL: 当使用此标志时，.符号匹配包括行终止符在内的所有字符
CANON_EQ: 考虑Unicode字符的规范等价
&&&& 如果正则表达式包含分组，Matcher对象能够揭示分组边界 。方法
int start(int groupIndex)
int end(int groupIndex)
返回某个特殊分组的起始索引和结尾后索引（past-the-end index ）。通过调用String group(int groupIndex)，你可以简单地得到匹配的字符串。 第0个分组代表所有的分组，第一个实际分组的索引是1。调用groupCount来获得总的分组数。&&&& 使用开放圆括号来安排嵌套分组。例如，给定模式((1?[0-9]):([0-5][0-9]))[ap]m，并且输入11:59am,Matcher对象报告下列分组((1?[0-9]):([0-5][0-9]))[ap]m并输入11:59ammatcher报告下列分组
分组索引& 起始& 结束& 字符串
0 & & & & & && 0 & & & && 7 &&&& 11;59am1 & & & & & && 0 & & & && 5 & && 11:592 & & & & & && 0 & & & && 2 & && 113 & & & & & && 3 & & & && 5 & && 59
&例12－9提示输入一个模式和一个欲匹配的字符串。它将输出输入的字符串是否匹配模式。如果输入匹配包含分组的模式，程序将会使用圆括号来打印分组边界，如((11):(59))amExample 12-9. RegexTest.java&1. import java.util.*;&2. import java.util.regex.*;&3.&4. /&5.&&& This program tests regular expression matching.&6.&&& Enter a pattern and strings to match, or hit Cancel&7.&&& to exit. If the pattern contains groups, the group&8.&&& boundaries are displayed in the match.&9. */10. public class RegExTest11. {12.&& public static void main(String[] args)13.&& {14.&&&&& Scanner in = new Scanner(System.in); 15.&&&&& System.out.println("Enter pattern: ");16.&&&&& String patternString = in.nextLine();17.18.&&&&& Pattern pattern =19.&&&&& try20.&&&&& {21.&&&&&&&& pattern = pile(patternString);22.&&&&& }23.&&&&& catch (PatternSyntaxException e)24.&&&&& {25.&&&&&&&& System.out.println("Pattern syntax error");26.&&&&&&&& System.exit(1);27.&&&&& }28.29.&&&&& while (true)30.&&&&& {31.&&&&&&&& System.out.println("Enter string to match: ");32.&&&&&&&& String input = in.nextLine(); 33.&&&&&&&& if (input == null || input.equals(""))34.&&&&&&&& Matcher matcher = pattern.matcher(input); 35.&&&&&&&& if (matcher.matches())36.&&&&&&&& {37.&&&&&&&&&&& System.out.println("Match");38.&&&&&&&&&&& int g = matcher.groupCount();39.&&&&&&&&&&& if (g & 0)40.&&&&&&&&&&& {41.&&&&&&&&&&&&&& for (int i = 0; i & input.length(); i++)42.&&&&&&&&&&&&&& {43.&&&&&&&&&&&&&&&&& for (int j = 1; j &= j++)44.&&&&&&&&&&&&&&&&&&&& if (i == matcher.start(j))45.&&&&&&&&&&&&&&&&&&&&&&& System.out.print('(');46.&&&&&&&&&&&&&&&&& System.out.print(input.charAt(i));47.&&&&&&&&&&&&&&&&& for (int j = 1; j &= j++)48.&&&&&&&&&&&&&&&&&&&& if (i + 1 == matcher.end(j))49.&&&&&&&&&&&&&&&&&&&&&&& System.out.print(')');50.&&&&&&&&&&&&&& }51.&&&&&&&&&&&&&& System.out.println();52.&&&&&&&&&&& }53.&&&&&&&& }54.&&&&&&&& else55.&&&&&&&&&&& System.out.println("No match");56.&&&&& }57.&& }58. }&&&& 通常地，你不希望匹配整个输入到某个正则表达式，而是希望在输入中找出一个或多个匹配的子字符串。使用Matcher类的find方法来寻找下一个匹配。如果它返回True，再使用start和end方法找出匹配的范围。
while (matcher.find())
&& int start = matcher.start();
&& int end = matcher.end();
&& String match = input.substring(start, end);
例12-10用到了这种机制。它在一个网页中定位所有的超文本引用并打印它们。为运行程序，在命令行提供一个URL，比如java HrefMatch
Example 12-10. HrefMatch.java&1. import java.io.*;&2. import java.net.*;&3. import java.util.regex.*;&4.&5. /&6.&&& This program displays all URLs in a web page by&7.&&& matching a regular expression that describes the&8.&&& &a href=...& HTML tag. Start the program as&9.&&& java HrefMatch URL10. */11. public class HrefMatch12. {13.&&& public static void main(String[] args)14.&&& {15.&&&&&& try16.&&&&&& {17.&&&&&&&&& // get URL string from command line or use default18.&&&&&&&&& String urlS19.&&&&&&&&& if (args.length & 0) urlString = args[0];20.&&&&&&&&& else urlString = " "; 21.22.&&&&&&&&& // open reader for URL23.&&&&&&&&& InputStreamReader in = new InputStreamReader(new URL(urlString).openStream());24.25.&&&&&&&&& // read contents into string buffer26.&&&&&&&&& StringBuilder input = new StringBuilder();27.&&&&&&&&&28.&&&&&&&&& while ((ch = in.read()) != -1) input.append((char) ch);29.30.&&&&&&&&& // search for all occurrences of pattern31.&&&&&&&&& String patternString = "&a//s+href//s*=//s*(/"[^/"]*/"|[^//s&])//s*&";32.&&&&&&&&& Pattern pattern = pile(patternString, Pattern.CASE_INSENSITIVE);33.&&&&&&&&& Matcher matcher = pattern.matcher(input);34.35.&&&&&&&&& while (matcher.find())36.&&&&&&&&& {37.&&&&&&&&&&&& int start = matcher.start();38.&&&&&&&&&&&& int end = matcher.end();39.&&&&&&&&&&&& String match = input.substring(start, end);40.&&&&&&&&&&&& System.out.println(match);41.&&&&&&&&& }42.&&&&&& }43.&&&&&& catch (IOException e)44.&&&&&& {45.&&&&&&&&& e.printStackTrace();46.&&&&&& }47.&&&&&& catch (PatternSyntaxException e)48.&&&&&& {49.&&&&&&&&& e.printStackTrace();50.&&&&&& }51.&&& }52. }&Pattern pattern = pile("//s*//p{Punct}//s*");
String[] tokens = pattern.split(input);
java.util.regex.Pattern 1.4
方法 static Pattern compile(String expression)static Pattern compile(String expression, int flags)编译正则表达式字符串到pattern对象用以匹配的快速处理参数:&expression 正则表达式&flags&&&&&&&&&&& 下列标志中的一个或多个 CASE_INSENSITIVE, UNICODE_CASE, MULTILINE, UNIX_LINES, DOTALL, and CANON_EQ&Matcher matcher(CharSequence input)返回一个matcher对象，它可以用来在一个输入中定位模式匹配String[] split(CharSequence input)String[] split(CharSequence input, int limit)将输入字符串分离成记号，并由pattern来指定分隔符的形式。返回记号数组。分隔符并不是记号的一部分。参数:input 分离成记号的字符串limit 生成的最大字符串数。
java.util.regex.Matcher 1.4
boolean matches()返回输入是否与模式匹配boolean lookingAt()如果输入的起始匹配模式则返回Trueboolean find()boolean find(int start)尝试查找下一个匹配，并在找到匹配时返回True参数:&start& 开始搜索的索引&int start()int end()返回当前匹配的起始位置和结尾后位置String group()返回当前匹配int groupCount()返回输入模式中的分组数int start(int groupIndex)int end(int groupIndex)返回一个给定分组当前匹配中的起始位置和结尾后位置参数:&groupIndex分组索引（从1开始），0表示整个匹配String group(int groupIndex)返回匹配一个给定分组的字符串参数:&groupIndex&分组索引（从1开始），0表示整个匹配String replaceAll(String replacement)String replaceFirst(String replacement)返回从matcher输入得到的字符串，但已经用替换表达式替换所有或第一个匹配参数:&replacement 替换字符串 Matcher reset()Matcher reset(CharSequence input)复位mather状态。
浏览 (340)
分类: RegEx
2009-12-29
Java正则表达式详解
文章分类:Java编程
如果你曾经用过Perl或任何其他内建正则表达式支持的语言，你一定知道用正则表达式处理文本和匹配模式是多么简单。如果你不熟悉这个术语，那么&正则表达式&（Regular Expression）就是一个字符构成的串，它定义了一个用来搜索匹配字符串的模式。
许多语言，包括Perl、PHP、Python、JavaScript和JScript，都支持用正则表达式处理文本，一些文本编辑器用正则表达式实现高级&搜索-替换&功能。那么Java又怎样呢？本文写作时，一个包含了用正则表达式进行文本处理的Java规范需求（Specification Request）已经得到认可，你可以期待在JDK的下一版本中看到它。
然而，如果现在就需要使用正则表达式，又该怎么办呢？你可以从Apache.org下载源代码开放的Jakarta-ORO库。本文接下来的内容先简要地介绍正则表达式的入门知识，然后以Jakarta-ORO API为例介绍如何使用正则表达式。
我们先从简单的开始。假设你要搜索一个包含字符&cat&的字符串，搜索用的正则表达式就是&cat&。如果搜索对大小写不敏感，单词&catalog&、&Catherine&、&sophisticated&都可以匹配。也就是说：
1.1 句点符号
假设你在玩英文拼字游戏，想要找出三个字母的单词，而且这些单词必须以&t&字母开头，以&n&字母结束。另外，假设有一本英文字典，你可以用正则表达式搜索它的全部内容。要构造出这个正则表达式，你可以使用一个通配符&&句点符号&.& 。这样，完整的表达式就是 &t.n&，它匹配&tan&、&ten&、&tin&和&ton&，还匹配&t#n&、&tpn&甚至&t n&，还有其他许多无意义的组合。这是因为句点符号匹配所有字符，包括空格、Tab字符甚至换行符：
1.2 方括号符号
为了解决句点符号匹配范围过于广泛这一问题，你可以在方括号（&[]&）里面指定看来有意义的字符。此时，只有方括号里面指定的字符才参与匹配。也就是说，正则表达式&t[aeio]n&只匹配&tan&、&Ten&、&tin&和&ton&。但&Toon&不匹配，
1.3 &或&符号
如果除了上面匹配的所有单词之外，你还想要匹配&toon&，那么，你可以使用&|&操作符。&|&操作符的基本意义就是&或&运算。要匹配&toon&，使用&t(a|e|i|o|oo)n&正则表达式。这里不能使用方扩号 ，因为方括号
1.4 表示匹配次数的符号
表一显示了表示匹配次数的符号，这些符号用来确定紧靠该符号左边的符号出现的次数：
假设我们要在文本文件中搜索美国的社会安全号码。这个号码的格式是999-99-9999。用来匹配它的正则表达式如图一所示。在正则表达式中，连字符（&-&）有着特殊的意义，它表示一个范围，比如从0到9。因此，匹配社会安全号码中的连字符号时，它的前面要加上一个转义字符&/&。
图一：匹配所有123-12-1234形式的社会安全号码
假设进行搜索的时候，你希望连字符号可以出现，也可以不出现&&即，999-99-999都属于正确的格式。这时，你可以在连字符号后面加上&？&数量限定符号，如图二所示：
图二：匹配所有123-12-234形式的社会安全号码
下面我们再来看另外一个例子。美国汽车牌照的一种格式是四个数字加上二个字母。它的正则表达式前面是数字部分&[0-9]{4}&，再加上字母部分&[A-Z]{2}&。图三显示了完整的正则表达式。
图三：匹配典型的美国汽车牌照号码，如8836KV
1.5 &否&符号
&^&符号称为&否&符号。如果用在方括号内，&^&表示不想要匹配的字符。例如，图四的正则表达式匹配所有单词，但以&X&字母开头的单词除外。
图四：匹配所有单词，但&X&开头的除外
1.6 圆括号和空白符号
假设要从格式为&June 26, 1951&的生日日期中提取出月份部分，用来匹配该日期的正则表达式可以如图五所示：
图五：匹配所有Moth DD,YYYY格式的日期
新出现的&/s&符号是空白符号，匹配所有的空白字符，包括Tab字符。如果字符串正确匹配，接下来如何提取出月份部分呢？只需在月份周围加上一个圆括号创建一个组，然后用ORO API（本文后面详细讨论）提取出它的值。修改后的正则表达式如图六所示：
图六：匹配所有Month DD,YYYY格式的日期，定义月份值为第一个组
1.7 其它符号
为简便起见，你可以使用一些为常见正则表达式创建的快捷符号。如表二所示：
表二：常用符号
例如，在前面社会安全号码的例子中，所有出现&[0-9]&的地方我们都可以使用&/d&。修改后的正则表达式如图七所示：
图七：匹配所有123-12-1234格式的社会安全号码
有许多源代码开放的正则表达式库可供Java程序员使用，而且它们中的许多支持Perl 5兼容的正则表达式语法。我在这里选用的是Jakarta-ORO正则表达式库，它是最全面的正则表达式API之一，而且它与Perl 5正则表达式完全兼容。另外，它也是优化得最好的API之一。
Jakarta-ORO库以前叫做OROMatcher，Daniel Savarese大方地把它赠送给了Jakarta Project。你可以按照本文最后参考资源的说明下载它。
我首先将简要介绍使用Jakarta-ORO库时你必须创建和访问的对象，然后介绍如何使用Jakarta-ORO API。
▲ PatternCompiler对象
首先，创建一个Perl5Compiler类的实例，并把它赋值给PatternCompiler接口对象。Perl5Compiler是PatternCompiler接口的一个实现，允许你把正则表达式编译成用来匹配的Pattern对象。
▲ Pattern对象
要把正则表达式编译成Pattern对象，调用compiler对象的compile()方法，并在调用参数中指定正则表达式。例如，你可以按照下面这种方式编译正则表达式&t[aeio]n&：
默认情况下，编译器创建一个大小写敏感的模式（pattern）。因此，上面代码编译得到的模式只匹配&tin&、&tan&、 &ten&和&ton&，但不匹配&Tin&和&taN&。要创建一个大小写不敏感的模式，你应该在调用编译器的时候指定一个额外的参数：
创建好Pattern对象之后，你就可以通过PatternMatcher类用该Pattern对象进行模式匹配。
▲ PatternMatcher对象
PatternMatcher对象根据Pattern对象和字符串进行匹配检查。你要实例化一个 Perl5Matcher类并把结果赋值给PatternMatcher接口。Perl5Matcher类是PatternMatcher接口的一个实现，它根据Perl 5正则表达式语法进行模式匹配：
使用PatternMatcher对象，你可以用多个方法进行匹配操作，这些方法的第一个参数都是需要根据正则表达式进行匹配的字符串：
& boolean matches(String input, Pattern pattern)：当输入字符串和正则表达式要精确匹配时使用。换句话说，正则表达式必须完整地描述输入字符串。
& boolean matchesPrefix(String input, Pattern pattern)：当正则表达式匹配输入字符串起始部分时使用。
& boolean contains(String input, Pattern pattern)：当正则表达式要匹配输入字符串的一部分时使用（即，它必须是一个子串）。
另外，在上面三个方法调用中，你还可以用PatternMatcherInput对象作为参数替代String对象；这时，你可以从字符串中最后一次匹配的位置开始继续进行匹配。当字符串可能有多个子串匹配给定的正则表达式时，用PatternMatcherInput对象作为参数就很有用了。用PatternMatcherInput对象作为参数替代String时，上述三个方法的语法如下：
& boolean matches(PatternMatcherInput input, Pattern pattern)
& boolean matchesPrefix(PatternMatcherInput input, Pattern pattern)
& boolean contains(PatternMatcherInput input, Pattern pattern)
下面我们来看看Jakarta-ORO库的一些应用实例。
3.1 日志文件处理
任务：分析一个Web服务器日志文件，确定每一个用户花在网站上的时间。在典型的BEA WebLogic日志文件中，日志记录的格式如下：
分析这个日志记录，可以发现，要从这个日志文件提取的内容有两项：IP地址和页面访问时间。你可以用分组符号（圆括号）从日志记录提取出IP地址和时间标记。
首先我们来看看IP地址。IP地址有4个字节构成，每一个字节的值在0到255之间，各个字节通过一个句点分隔。因此，IP地址中的每一个字节有至少一个、最多三个数字。图八显示了为IP地址编写的正则表达式：
图八：匹配IP地址
IP地址中的句点字符必须进行转义处理（前面加上&/&），因为IP地址中的句点具有它本来的含义，而不是采用正则表达式语法中的特殊含义。句点在正则表达式中的特殊含义本文前面已经介绍。
日志记录的时间部分由一对方括号包围。你可以按照如下思路提取出方括号里面的所有内容：首先搜索起始方括号字符（&[&），提取出所有不超过结束方括号字符（&]&）的内容，向前寻找直至找到结束方括号字符。图九显示了这部分的正则表达式。
图九：匹配至少一个字符，直至找到&]&
现在，把上述两个正则表达式加上分组符号（圆括号）后合并成单个表达式，这样就可以从日志记录提取出IP地址和时间。注意，为了匹配&- -&（但不提取它），正则表达式中间加入了&/s-/s-/s&。完整的正则表达式如图十所示。
图十：匹配IP地址和时间标记
现在正则表达式已经编写完毕，接下来可以编写使用正则表达式库的Java代码了。
为使用Jakarta-ORO库，首先创建正则表达式字符串和待分析的日志记录字符串：
这里使用的正则表达式与图十的正则表达式差不多完全相同，但有一点例外：在Java中，你必须对每一个向前的斜杠（&/&）进行转义处理。图十不是Java的表示形式，所以我们要在每个&/&前面加上一个&/&以免出现编译错误。遗憾的是，转义处理过程很容易出现错误，所以应该小心谨慎。你可以首先输入未经转义处理的正则表达式，然后从左到右依次把每一个&/&替换成&//&。如果要复检，你可以试着把它输出到屏幕上。
初始化字符串之后，实例化PatternCompiler对象，用PatternCompiler编译正则表达式创建一个Pattern对象：
现在，创建PatternMatcher对象，调用PatternMatcher接口的contain()方法检查匹配情况：
接下来，利用PatternMatcher接口返回的MatchResult对象，输出匹配的组。由于logEntry字符串包含匹配的内容，你可以看到类如下面的输出：
3.2 HTML处理实例一
下面一个任务是分析HTML页面内FONT标记的所有属性。HTML页面内典型的FONT标记如下所示：
程序将按照如下形式，输出每一个FONT标记的属性：
在这种情况下，我建议你使用两个正则表达式。第一个如图十一所示，它从字体标记提取出&"face="Arial, Serif" size="+2" color="red"&。
图十一：匹配FONT标记的所有属性
第二个正则表达式如图十二所示，它把各个属性分割成名字-值对。
图十二：匹配单个属性，并把它分割成名字-值对
分割结果为：
现在我们来看看完成这个任务的Java代码。首先创建两个正则表达式字符串，用Perl5Compiler把它们编译成 Pattern对象。编译正则表达式的时候，指定Perl5Compiler.CASE_INSENSITIVE_MASK选项，使得匹配操作不区分大小写。
接下来，创建一个执行匹配操作的Perl5Matcher对象。
假设有一个String类型的变量html，它代表了HTML文件中的一行内容。如果html字符串包含FONT标记，匹配器将返回true。此时，你可以用匹配器对象返回的MatchResult对象获得第一个组，它包含了FONT的所有属性：
接下来创建一个PatternMatcherInput对象。这个对象允许你从最后一次匹配的位置开始继续进行匹配操作，因此，它很适合于提取FONT标记内属性的名字-值对。创建PatternMatcherInput对象，以参数形式传入待匹配的字符串。然后，用匹配器实例提取出每一个FONT的属性。这通过指定PatternMatcherInput对象（而不是字符串对象）为参数，反复地调用 PatternMatcher对象的contains()方法完成。PatternMatcherInput对象之中的每一次迭代将把它内部的指针向前移动，下一次检测将从前一次匹配位置的后面开始。
本例的输出结果如下：
3.3 HTML处理实例二
下面我们来看看另一个处理HTML的例子。这一次，我们假定Web服务器从移到了。现在你要修改一些页面中的链接：
执行这个搜索的正则表达式如图十三所示：
图十三：匹配修改前的链接
如果能够匹配这个正则表达式，你可以用下面的内容替换图十三的链接：
注意#字符的后面加上了$1。Perl正则表达式语法用$1、$2等表示已经匹配且提取出来的组。图十三的表达式把所有作为一个组匹配和提取出来的内容附加到链接的后面。
现在，返回Java。就象前面我们所做的那样，你必须创建测试字符串，创建把正则表达式编译到Pattern对象所必需的对象，以及创建一个PatternMatcher对象：
接下来，用com.oroinc.text.regex包Util类的substitute()静态方法进行替换，输出结果字符串：
Util.substitute()方法的语法如下：
这个调用的前两个参数是以前创建的PatternMatcher和Pattern对象。第三个参数是一个 Substiution对象，它决定了替换操作如何进行。本例使用的是Perl5Substitution对象，它能够进行Perl5风格的替换。第四个参数是想要进行替换操作的字符串，最后一个参数允许指定是否替换模式的所有匹配子串（Util.SUBSTITUTE_ALL），或只替换指定的次数。
在这篇文章中，我为你介绍了正则表达式的强大功能。只要正确运用，正则表达式能够在字符串提取和文本修改中起到很大的作用。另外，我还介绍了如何在Java程序中通过Jakarta-ORO库利用正则表达式。至于最终采用老式的字符串处理方式（使用StringTokenizer，charAt，和substring），还是采用正则表达式，这就有待你自己决定了。
本来对正则表达式就不是很了解,结果要做个四则计算器,必须用到了,这里就补充下,内容均来自网络,若有侵犯,请联系本人!Java代码
String s2=&this is a test&;
String sarray[]=s2.split(&/s&);
System.out.println(&sarray ...
JS中使用正则表达式详解 简介 简单的说,正则表达式是一种可以用于模式匹配和替换的强有力的工具.其作用如下: 测试字符串的某个模式.例如,可以对一个输入字符串进行测试,看在该字符串是否存在一个电话号码模式或一个信用卡号码模式.这称为数据有效性验证. 替换文本.可以在文档中使用一个正则表达式来标识特定文字,然后可以全部将其删除,或者替换为别的文字. 根据模式匹 ...
java中 中文问题详解转贴
作者:yuking 预备知识:
1.字节和unicode
Java内核是unicode的,就连class文件也是,但是很多媒体,包括文件/流的保存方式
是使用字节流的. 因此Java要对这些字节流经行转化.char是unicode的,而byte是字节.
Java中byte/c ...
JAVA基础-关于Java中中文问题详解 作者: 发文时间: 来源:jspcn
这篇文章主要介绍了final关键字,通过final关键字的基本用法和对final关键字的理解展开,有需要的朋友可以参考下谈到final关键字,想必很多人都不陌生,在使用匿名内部类的时候可能会经常用到final关键字.另外,Java中的String类就是一个final类,那么今天我们就来了解final这个关键字的用法.主要介绍:一.final关键字的基本用法. ...