博客园_LIFE , NOT IF ELSE

运维工程师必会的109个Linux命令

2011-10-28T02:22:00Z

【摘要】1 文件管理 1 文件管理 1.1 basename 1.1.1 功能说明从文件名中去掉路径和扩展名例：basename include/stdio.h .h Output "stdio". 1.1.2 选项 --help 显示此帮助信息并离开 --version显示版本信息并离开 1.2 cat 1.2.1 功能说明把档案串连接后传到基本输出（屏幕或加 > filename 到另一个档案） 1.2.2 语法 cat [-AbeEnstTuv] [--help] [--version] filename 1.2.3 参数 -n 或 --numbe... http://www.cnblogs.com/glaivelee/archive/2011/10/28/2227356.html

本文链接

bmp/gif/jpg图象最底层原理分析

2011-10-10T02:07:00Z

bmp/gif/jpg图象最底层原理分析（１）－－－－ JPG

《探索图像文件的奥秘》，清华大学出版社，1996年

写在前面的　

＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊

24位bmp是公认最好的图片存储格式,存储了图片所有的信息

24位bmp是每像素用24位二进制存储该像素点的图像信息，相当于3字节

所以，图像占用空间大小就可以算了{

将图像长宽单位换位像素（比如：1024X960 800X600），则文件大小为　（长X宽X３）字节

如：800X600的图片大小为800X600X3＝1440000字节=1.44兆

1024X960的图像大小为2.95兆

16位bmp则是24为的三分之二大小

8．．．．．．．．．．．．一．．

1．．．．．．．．．24．．１．．

256色是２的８次方，相当于８位的bmp

同理自己根据二进制换算

＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊

１．jpg图片压缩过程

jpg压缩比例不固定

本文仅讨论静止图像的压缩基本算法，图像压缩的目的在于以较少的数据来表示图像以节约存储费用，或者传输时间和费用。

jpeg压缩算法可以用失真的压缩方式来处理图像，但失真的程度却是肉眼所无法辩认的。这也就是为什么jpeg会有如此满意的压缩比例的原因。下面主要讨论，jpeg基本压缩法。

一.jpeg压缩过程 jpeg压缩分四个步骤实现：

1.颜色模式转换及采样； 2.dct变换； 3.量化； 4.编码。

二.

1．颜色模式转换及采样 rgb色彩系统是我们最常用的表示颜色的方式。jpeg采用的是ycbcr色彩系统。

想要用jpeg基本压缩法处理全彩色图像，得先把rgb颜色模式图像数据，转换为ycbcr颜色模式的数据。y代表亮度，cb和cr则代表色度、饱和度。

通过下列计算公式可完成数据转换。

y=0.2990r+0.5870g+0.1140b cb=-0.1687r-0.3313g+0.5000b+128 cr=0.5000r-0.4187g-0.0813b＋128

人类的眼晴对低频的数据比对高频的数据具有更高的敏感度，事实上，人类的眼睛对亮度的改变也比对色彩的改变要敏感得多，也就是说y成份的数据是比较重要的。

既然cb成份和cr成份的数据比较相对不重要，就可以只取部分数据来处理。

以增加压缩的比例。jpeg通常有两种采样方式：yuv411和yuv422，它们所代表的意义是y、cb和cr三个成份的数据取样比例。

2.dct变换 dct变换的全称是离散余弦变换(discrete cosine transform)，是指将一组光强数据转换成频率数据，以便得知强度变化的情形。若对高频的数据做些修饰，再转回原来形式的数据时，显然与原始数据有些差异，但是人类的眼睛却是不容易辨认出来。

压缩时，将原始图像数据分成8*8数据单元矩阵，

例如亮度值的第一个矩阵内容如下： jpeg将整个亮度矩阵与色度cb矩阵，饱和度cr矩阵，视为一个基本单元称作mcu。每个mcu所包含的矩阵数量不得超过10个。

例如，行和列采样的比例皆为4:2:2，则每个mcu将包含四个亮度矩阵，一个色度矩阵及一个饱和度矩阵。

当图像数据分成一个8*8矩阵后，还必须将每个数值减去128，然后一一代入dct变换公式中，即可达到dct变换的目的。图像数据值必须减去128，是因为dct转换公式所接受的数字范围是在-128到+127之间。 dct变换公式： x,y代表图像数据矩阵内某个数值的坐标位置f(x,y)代表图像数据矩阵内的数个数值u,v代表dct变换后矩阵内某个数值的坐标位置f(u,v)代表dct变换后矩阵内的某个数值 u=0 且 v=0 c(u)c(v)=1/1.414 u>0 或 v>0 c(u)c(v)=1 经过dct变换后的矩阵数据自然数为频率系数，这些系数以f（0，0）的值最大，称为dc，其余的63个频率系数则多半是一些接近于0的正负浮点数，一概称之为ac。

3、量化图像数据转换为频率系数后，还得接受一项量化程序，才能进入编码阶段。量化阶段需要两个8*8矩阵数据，一个是专门处理亮度的频率系数，另一个则是针对色度的频率系数，将频率系数除以量化矩阵的值，取得与商数最近的整数，即完成量化。当频率系数经过量化后，将频率系数由浮点数转变为整数，这才便于执行最后的编码。不过，经过量化阶段后，所有数据只保留整数近似值，也就再度损失了一些数据内容，jpeg提供的量化表如下：

4、编码 huffman编码无专利权问题，成为jpeg最常用的编码方式，huffman编码通常是以完整的mcu来进行的。

编码时，每个矩阵数据的dc值与63个ac值，将分别使用不同的huffman编码表，而亮度与色度也需要不同的huffman编码表，所以一共需要四个编码表，才能顺利地完成jpeg编码工作。

dc编码 dc是彩采用差值脉冲编码调制的差值编码法，也就是在同一个图像分量中取得每个dc值与前一个dc值的差值来编码。dc采用差值脉冲编码的主要原因是由于在连续色调的图像中，其差值多半比原值小，对差值进行编码所需的位数，会比对原值进行编码所需的位数少许多。

例如差值为5，它的二进制表示值为101，如果差值为-5，则先改为正整数5，再将其二进制转换成1的补数即可。

所谓1的补数，就是将每个bit若值为0，便改成1；bit为1，则变成0。差值5应保留的位数为3，下表即列出差值所应保留的bit数与差值内容的对照。在差值前端另外加入一些差值的霍夫曼码值，例如亮度差值为5（101）的位数为3，则霍夫曼码值应该是100，两者连接在一起即为100101。下列两份表格分别是亮度和色度dc差值的编码表。根据这两份表格内容，即可为dc差值加上霍夫曼码值，完成dc的编码工作。

ac编码 ac编码方式与dc略有不同，在ac编码之前，首先得将63个ac值按zig-zag排序，即按照下图箭头所指示的顺序串联起来。 63个ac值排列好的，将ac系数转换成中间符号，中间符号表示为rrrr/ssss，rrrr是指第非零的ac之前，其值为0的ac个数，ssss是指ac值所需的位数，ac系数的范围与ssss的对应关系与dc差值bits数与差值内容对照表相似。

如果连续为0的ac个数大于15，则用15/0来表示连续的16个0，15/0称为zrl（zero rum length），而（0/0）称为eob（enel of block）用来表示其后所剩余的ac系数皆等于0，以中间符号值作为索引值，从相应的ac编码表中找出适当的霍夫曼码值，再与ac值相连即可。例如某一组亮度的中间符为5/3，ac值为4，首先以5/3为索引值，从亮度ac的huffman编码表中找到1111111110011110霍夫曼码值，于是加上原来100（4）即是用来取[5，4]的huffman编码1111111110011110100，[5，4]表示ac值为4的前面有5个零。由于亮度ac，色度ac霍夫曼编码表比较长，在此省略去，有兴趣者可参阅相关书籍。

实现上述四个步骤，即完成一幅图像的jpeg压缩。

参考资料

[1] 林福宗《图像文件格式（上）——windows 编程》，清华大学出版社， 1996年

[2] 李振辉、李仁各编著，《探索图像文件的奥秘》，清华大学出版社，1996年

[3] 黎洪松、成实译《jpeg静止数据压缩标准》，学苑出版社，1996年

bmp/gif/jpg图象最底层原理分析（１）－－－－gif(１)

1.概述
~~~~~~~~

GIF(Graphics Interchange Format，图形交换格式)文件是由 CompuServe公司开发的图形文件格式，版权所有，任何商业目的使用均须 CompuServe公司授权。
GIF图象是基于颜色列表的（存储的数据是该点的颜色对应于颜色列表的索引值），最多只支持8位（256色）。GIF文件内部分成许多存储块，用来存储多幅图象或者是决定图象表现行为的控制块，用以实现动画和交互式应用。GIF文件还通过LZW压缩算法压缩图象数据来减少图象尺寸（关于LZW算法和GIF数据压缩>>...）。

2.GIF文件存储结构
~~~~~~~~~~~~~~~~~~~

GIF文件内部是按块划分的，包括控制块（ Control Block ）和数据块（Data Sub-blocks）两种。控制块是控制数据块行为的，根据不同的控制块包含一些不同的控制参数；数据块只包含一些8-bit的字符流，由它前面的控制块来决定它的功能，每个数据块大小从0到255个字节，数据块的第一个字节指出这个数据块大小（字节数），计算数据块的大小时不包括这个字节，所以一个空的数据块有一个字节，那就是数据块的大小0x00。下表是一个数据块的结构：

BYTE	7	6	5	4	3	2	1	0	BIT
0	块大小								Block Size - 块大小，不包括这个这个字节（不计算块大小自身）
1									Data Values - 块数据，8-bit的字符串
2
...
254
255

一个GIF文件的结构可分为文件头(File Header)、GIF数据流(GIF Data Stream)和文件终结器(Trailer)三个部分。文件头包含GIF文件署名(Signature)和版本号(Version)；GIF数据流由控制标识符、图象块(Image Block)和其他的一些扩展块组成；文件终结器只有一个值为0x3B的字符（';'）表示文件结束。下表显示了一个GIF文件的组成结构：

GIF署名		文件头
版本号
逻辑屏幕标识符		GIF数据流
全局颜色列表
...
图象标识符	图象块
图象局部颜色列表图
基于颜色列表的图象数据

...
GIF结尾		文件结尾

下面就具体介绍各个部分:

文件头部分(Header)
~~~~~~~~~~~~~~~~~

GIF署名(Signature)和版本号(Version)
~~~~~~~~~~~~~~~~~~~~~~~~~~~
GIF署名用来确认一个文件是否是GIF格式的文件，这一部分由三个字符组成："GIF";文件版本号也是由三个字节组成,可以为"87a"或"89a".具体描述见下表:

BYTE	7	6	5	4	3	2	1	0	BIT
1	'G'								GIF文件标识
2	'I'
3	'F'
4	'8'								GIF文件版本号：87a - 1987年5月　 89a - 1989年7月
5	'7'或'9'
6	'a'

GIF数据流部分(GIF Data Stream)

~~~~~~~~~~~~~~~~~~~~~~~~~~~~

逻辑屏幕标识符(Logical Screen Descriptor)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
这一部分由7个字节组成，定义了GIF图象的大小(Logical Screen Width & Height)、颜色深度(Color Bits)、背景色(Blackground Color Index)以及有无全局颜色列表(Global Color Table)和颜色列表的索引数(Index Count)，具体描述见下表：

BYTE	7	6	5	4	3	2	1	0	BIT
1	逻辑屏幕宽度								像素数，定义GIF图象的宽度
2
3	逻辑屏幕高度								像素数，定义GIF图象的高度
4
5	m	cr			s	pixel			具体描述见下...
6	背景色								背景颜色(在全局颜色列表中的索引，如果没有全局颜色列表，该值没有意义)
7	像素宽高比								像素宽高比(Pixel Aspect Radio)

m - 全局颜色列表标志(Global Color Table Flag)，当置位时表示有全局颜色列表，pixel值有意义.
cr - 颜色深度(Color ResoluTion)，cr+1确定图象的颜色深度.
s - 分类标志(Sort Flag)，如果置位表示全局颜色列表分类排列.
pixel - 全局颜色列表大小，pixel+1确定颜色列表的索引数（2的pixel+1次方）.

全局颜色列表(Global Color Table)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
全局颜色列表必须紧跟在逻辑屏幕标识符后面，每个颜色列表索引条目由三个字节组成，按R、G、B的顺序排列。

BYTE	7	6	5	4	3	2	1	0	BIT
1	索引1的红色值
2	索引1的绿色值
3	索引1的蓝色值
4	索引2的红色值
5	索引2的绿色值
6	索引2的蓝色值
7	...

图象标识符(Image Descriptor)
~~~~~~~~~~~~~~~~~~~~~~~~~
一个GIF文件内可以包含多幅图象，一幅图象结束之后紧接着下是一幅图象的标识符，图象标识符以0x2C(',')字符开始，定义紧接着它的图象的性质，包括图象相对于逻辑屏幕边界的偏移量、图象大小以及有无局部颜色列表和颜色列表大小，由10个字节组成：

BYTE	7	6	5	4	3	2	1	0	BIT
1	0	0	1	0	1	1	0	0	图象标识符开始，固定值为','
2	X方向偏移量								必须限定在逻辑屏幕尺寸范围内
3	X方向偏移量
4	Y方向偏移量
5	Y方向偏移量
6	图象宽度
7	图象宽度
8	图象高度
9	图象高度
10	m	i	s	r		pixel

m - 局部颜色列表标志(Local Color Table Flag)
置位时标识紧接在图象标识符之后有一个局部颜色列表，供紧跟在它之后的一幅图象使用；值否时使用全局颜色列表，忽略pixel值。
i - 交织标志(Interlace Flag)，置位时图象数据使用交织方式排列（详细描述...），否则使用顺序排列。
s - 分类标志(Sort Flag)，如果置位表示紧跟着的局部颜色列表分类排列.
r - 保留，必须初始化为0.
pixel - 局部颜色列表大小(Size of Local Color Table)，pixel+1就为颜色列表的位数

局部颜色列表(Local Color Table)
~~~~~~~~~~~~~~~~~~~~~~~~~~
如果上面的局部颜色列表标志置位的话，则需要在这里（紧跟在图象标识符之后）定义一个局部颜色列表以供紧接着它的图象使用，注意使用前应线保存原来的颜色列表，使用结束之后回复原来保存的全局颜色列表。如果一个GIF文件即没有提供全局颜色列表，也没有提供局部颜色列表，可以自己创建一个颜色列表，或使用系统的颜色列表。局部颜色列表的排列方式和全局颜色列表一样：RGBRGB......

基于颜色列表的图象数据(Table-Based Image Data)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
由两部分组成：LZW编码长度(LZW Minimum Code Size)和图象数据(Image Data)。

BYTE	7	6	5	4	3	2	1	0	BIT
1	LZW编码长度								LZW编码初始码表大小的位数，详细描述见LZW编码...
	...								图象数据，由一个或几个数据块(Data Sub-blocks)组成
	数据块
	...

GIF图象数据使用了LZW压缩算法（详细介绍请看后面的『LZW算法和GIF数据压缩』），大大减小了图象数据的大小。图象数据在压缩前有两种排列格式：连续的和交织的(由图象标识符的交织标志控制)。连续方式按从左到右、从上到下的顺序排列图象的光栅数据；交织图象按下面的方法处理光栅数据:

bmp/gif/jpg图象最底层原理分析（１）－－－－gif(3)

编码器(Compressor)
~~~~~~~~~~~~~~~~

编码数据，第一步，初始化一个编译表，假设这个编译表的大小是12位的，也就是最多有4096个单位，另外假设我们有32个不同的字符（也可以认为图象的每个像素最多有32种颜色），表示为a，b，c，d，e...，初始化编译表：第0项为a，第1项为b，第2项为c...一直到第31项，我们把这32项就称为根。
开始编译，先定义一个前缀对象Current Prefix，记为[.c.]，现在它是空的，然后定义一个当前字符串Current String，标记为[.c.]k，[.c.]就为Current Prefix，k就为当前读取字符。现在来读取数据流的第一个字符，假如为p，那么Current String就等于[.c.]p（由于[.c.]为空，实际上值就等于p），现在在编译表中查找有没有Current String的值，由于p就是一个根字符，我们已经初始了32个根索引，当然可以找到，把p设为Current Prefix的值，不做任何事继续读取下一个字符，假设为q，Current String就等于[.c.]q（也就是pq），看看在编译表中有没有该值，当然。没有，这时我们要做下面的事情：将Current String的值（也就是pq）添加到编译表的第32项，把Current Prefix的值（也就是p）在编译表中的索引输出到编码流，修改Current Prefix为当前读取的字符（也就是q）。继续往下读，如果在编译表中可以查找到Current String的值([.c.]k)，则把Current String的值([.c.]k)赋予Current Prefix；如果查找不到，则添加Current String的值([.c.]k)到编译表，把Current Prefix的值([.c.])在编译表中所对应的索引输出到编码流，同时修改Current Prefix为k ，这样一直循环下去直到数据流结束。伪代码看起来就像下面这样：

编码器伪代码
Initialize String Table;
[.c.] = Empty;
[.c.]k = First Character in CharStream;
while ([.c.]k != EOF )
{
if ( [.c.]k is in the StringTable)
{
[.c.] = [.c.]k;
}
else
{
add [.c.]k to the StringTable;
Output the Index of [.c.] in the StringTable to the CodeStream;
[.c.] = k;
}
[.c.]k = Next Character in CharStream;
}
Output the Index of [.c.] in the StringTable to the CodeStream;

来看一个具体的例子,我们有一个字母表a，b，c，d.有一个输入的字符流abacaba。现在来初始化编译表：#0=a,#1=b,#2=c,#3=d.现在开始读取第一个字符a，[.c.]a=a，可以在在编译表中找到，修改[.c.]=a;不做任何事继续读取第二个字符b，[.c.]b=ab，在编译表中不能找，那么添加[.c.]b到编译表：#4=ab，同时输出[.c.]（也就是a）的索引#0到编码流，修改[.c.]=b；读下一个字符a，[.c.]a=ba，在编译表中不能找到：添加编译表#5=ba，输出[.c.]的索引#1到编码流，修改[.c.]=a；读下一个字符c，[.c.]c=ac，在编译表中不能找到：添加编译表#6=ac，输出[.c.]的索引#0到编码流，修改[.c.]=c；读下一个字符a，[.c.]c=ca，在编译表中不能找到：添加编译表#7=ca，输出[.c.]的索引#2到编码流，修改[.c.]=a；读下一个字符b，[.c.]b=ab，编译表的#4=ab，修改[.c.]=ab；读取最后一个字符a，[.c.]a=aba，在编译表中不能找到：添加编译表#8=aba，输出[.c.]的索引#4到编码流，修改[.c.]=a；好了，现在没有数据了，输出[.c.]的值a的索引#0到编码流，这样最后的输出结果就是：#0#1#0#2#4#0.

解码器(Decompressor)
~~~~~~~~~~~~~~~~~~

好了，现在来看看解码数据。数据的解码，其实就是数据编码的逆向过程，要从已经编译的数据（编码流）中找出编译表，然后对照编译表还原图象的光栅数据。
首先，还是要初始化编译表。GIF文件的图象数据的第一个字节存储的就是LZW编码的编码大小（一般等于图象的位数），根据编码大小，初始化编译表的根条目（从0到2的编码大小次方），然后定义一个当前编码Current Code，记作[code]，定义一个Old Code，记作[old]。读取第一个编码到[code]，这是一个根编码，在编译表中可以找到，把该编码所对应的字符输出到数据流，[old]=[code]；读取下一个编码到[code]，这就有两种情况：在编译表中有或没有该编码，我们先来看第一种情况：先输出当前编码[code]所对应的字符串到数据流，然后把[old]所对应的字符（串）当成前缀prefix [...]，当前编码[code]所对应的字符串的第一个字符当成k，组合起来当前字符串Current String就为[...]k，把[...]k添加到编译表，修改[old]=[code]，读下一个编码；我们来看看在编译表中找不到该编码的情况，回想一下编码情况：如果数据流中有一个p[...]p[...]pq这样的字符串，p[...]在编译表中而p[...]p不在，编译器将输出p[...]的索引而添加p[...]p到编译表，下一个字符串p[...]p就可以在编译表中找到了，而p[...]pq不在编译表中，同样将输出p[...]p的索引值而添加p[...]pq到编译表，这样看来，解码器总比编码器『慢一步』，当我们遇到p[...]p所对应的索引时，我们不知到该索引对应的字符串（在解码器的编译表中还没有该索引，事实上，这个索引将在下一步添加），这时需要用猜测法：现在假设上面的p[...]所对应的索引值是#58，那么上面的字符串经过编译之后是#58#59，我们在解码器中读到#59时，编译表的最大索引只有#58，#59所对应的字符串就等于#58所对应的字符串(也就是p[...])加上这个字符串的第一个字符(也就是p)，也就是p[...]p。事实上，这种猜测法是很准确（有点不好理解，仔细想一想吧）。上面的解码过程用伪代码表示就像下面这样：

解码器伪代码 Initialize String Table;
[code] = First Code in the CodeStream;
Output the String for [code] to the CharStream;
[old] = [code];
[code] = Next Code in the CodeStream;
while ([code] != EOF )
{
if ( [code] is in the StringTable)
{
Output the String for [code] to the CharStream; // 输出[code]所对应的字符串
[...] = translation for [old]; // [old]所对应的字符串
k = first character of translation for [code]; // [code]所对应的字符串的第一个字符
add [...]k to the StringTable;
[old] = [code];
}
else
{
[...] = translation for [old];
k = first character of [...];
Output [...]k to CharStream;
add [...]k to the StringTable;
[old] = [code];
}
[code] = Next Code in the CodeStream;
}

GIF数据压缩
~~~~~~~~~~~

下面是GIF文件的图象数据结构：

BYTE	7	6	5	4	3	2	1	0	BIT
1	编码长度								LZW Code Size - LZW压缩的编码长度，也就是要压缩的数据的位数
	...								数据块
	块大小								数据块，如果需要可重复多次
	编码数据								数据块，如果需要可重复多次
	...								数据块
	块终结器								一个图象的数据编码结束，固定值0

把光栅数据序列（数据流）压缩成GIF文件的图象数据（字符流）可以按下面的步骤进行：
1.定义编码长度
GIF图象数据的第一个字节就是编码长度(Code Size)，这个值是指要表现一个像素所需要的最小位数，通常就等于图象的色深；
2.压缩数据
通过LZW压缩算法将图象的光栅数据流压缩成GIF的编码数据流。这里使用的LZW压缩算法是从标准的LZW压缩算法演变过来的，它们之间有如下的差别：
[1]GIF文件定义了一个编码大小(Clear Code)，这个值等于2的『编码长度』次方，在从新开始一个编译表（编译表溢出）时均须输出该值，解码器遇到该值时意味着要从新初始化一个编译表；
[2]在一个图象的编码数据结束之前（也就是在块终结器的前面），需要输出一个Clear Code+1的值，解码器在遇到该值时就意味着GIF文件的一个图象数据流的结束；
[3]第一个可用到的编译表索引值是Clear Code+2（从0到Clear Code-1是根索引，再上去两个不可使用，新的索引从Clare Code+2开始添加）；
[4]GIF输出的编码流是不定长的，每个编码的大小从Code Size + 1位到12位，编码的最大值就是4095（编译表需要定义的索引数就是4096），当编码所须的位数超过当前的位数时就把当前位数加1，这就需要在编码或解码时注意到编码长度的改变。
3.编译成字节序列
因为GIF输出的编码流是不定长的，这就需要把它们编译成固定的8-bit长度的字符流，编译顺序是从右往左。下面是一个具体例子：编译5位长度编码到8位字符

0	b	b	b	a	a	a	a	a
1	d	c	c	c	c	c	b	b
2	e	e	e	e	d	d	d	d
3	g	g	f	f	f	f	f	e
4	h	h	h	h	h	g	g	g
	...
N

　
4.打包
前面讲过，一个GIF的数据块的大小从0到255个字节，第一个字节是这个数据块的大小（字节数），这就需要将编译编后的码数据打包成一个或几个大小不大于255个字节的数据包。然后写入图象数据块中。

bmp/gif/jpg图象最底层原理分析（１）－－－－bmp

简介

BMP(Bitmap-File)图形文件是Windows采用的图形文件格式，在Windows环境下运行的所有图象处理软件都支持BMP图象文件格式。Windows系统内部各图像绘制操作都是以BMP为基础的。Windows 3.0以前的BMP图文件格式与显示设备有关，因此把这种BMP图象文件格式称为设备相关位图DDB(device-dependent bitmap)文件格式。Windows 3.0以后的BMP图象文件与显示设备无关，因此把这种BMP图象文件格式称为设备无关位图DIB(device-independent bitmap)格式（注：Windows 3.0以后，在系统中仍然存在DDB位图，象BitBlt()这种函数就是基于DDB位图的，只不过如果你想将图像以BMP格式保存到磁盘文件中时，微软极力推荐你以DIB格式保存），目的是为了让Windows能够在任何类型的显示设备上显示所存储的图象。BMP位图文件默认的文件扩展名是BMP或者bmp（有时它也会以.DIB或.RLE作扩展名）。

6.1.2 文件结构

位图文件可看成由4个部分组成：位图文件头(bitmap-file header)、位图信息头(bitmap-information header)、彩色表(color table)和定义位图的字节阵列，它具有如下所示的形式。

位图文件的组成	结构名称	符号
位图文件头(bitmap-file header)	BITMAPFILEHEADER	bmfh
位图信息头(bitmap-information header)	BITMAPINFOHEADER	bmih
彩色表(color table)	RGBQUAD	aColors[]
图象数据阵列字节	BYTE	aBitmapBits[]

位图文件结构可综合在表6-01中。

表01 位图文件结构内容摘要

偏移量

域的名称

大小

内容

图象文件

头

0000h

文件标识

2 bytes

两字节的内容用来识别位图的类型：

‘BM’ ： Windows 3.1x, 95, NT, …

‘BA’ ：OS/2 Bitmap Array

‘CI’ ：OS/2 Color Icon

‘CP’ ：OS/2 Color Pointer

‘IC’ ： OS/2 Icon

‘PT’ ：OS/2 Pointer

注：因为OS/2系统并没有被普及开，所以在编程时，你只需判断第一个标识“BM”就行。

0002h

File Size

1 dword

用字节表示的整个文件的大小

0006h

Reserved

1 dword

保留，必须设置为0

000Ah

Bitmap Data Offset

1 dword

从文件开始到位图数据开始之间的数据(bitmap data)之间的偏移量

000Eh

Bitmap Header Size

1 dword

位图信息头(Bitmap Info Header)的长度，用来描述位图的颜色、压缩方法等。下面的长度表示：

28h - Windows 3.1x, 95, NT, …

0Ch - OS/2 1.x

F0h - OS/2 2.x

注：在Windows95、98、2000等操作系统中，位图信息头的长度并不一定是28h，因为微软已经制定出了新的BMP文件格式，其中的信息头结构变化比较大，长度加长。所以最好不要直接使用常数28h，而是应该从具体的文件中读取这个值。这样才能确保程序的兼容性。

0012h

Width

1 dword

位图的宽度，以象素为单位

0016h

Height

1 dword

位图的高度，以象素为单位

001Ah

Planes

1 word

位图的位面数（注：该值将总是1）

图象

信息

头

001Ch

Bits Per Pixel

1 word

每个象素的位数

1 - 单色位图（实际上可有两种颜色，缺省情况下是黑色和白色。你可以自己定义这两种颜色）

4 - 16 色位图

8 - 256 色位图

16 - 16bit 高彩色位图

24 - 24bit 真彩色位图

32 - 32bit 增强型真彩色位图

001Eh

Compression

1 dword

压缩说明：

0 - 不压缩 (使用BI_RGB表示)

1 - RLE 8-使用8位RLE压缩方式(用BI_RLE8表示)

2 - RLE 4-使用4位RLE压缩方式(用BI_RLE4表示)

3 - Bitfields-位域存放方式(用BI_BITFIELDS表示)

0022h

Bitmap Data Size

1 dword

用字节数表示的位图数据的大小。该数必须是4的倍数

0026h

HResolution

1 dword

用象素/米表示的水平分辨率

002Ah

VResolution

1 dword

用象素/米表示的垂直分辨率

002Eh

Colors

1 dword

位图使用的颜色数。如8-比特/象素表示为100h或者 256.

0032h

Important Colors

1 dword

指定重要的颜色数。当该域的值等于颜色数时（或者等于0时），表示所有颜色都一样重要

调色板数据

根据BMP版本的不同而不同

Palette

N * 4 byte

调色板规范。对于调色板中的每个表项，这4个字节用下述方法来描述RGB的值：

	1字节用于蓝色分量
	1字节用于绿色分量
	1字节用于红色分量
	1字节用于填充符(设置为0)

图象数据

根据BMP版本及调色板尺寸的不同而不同

Bitmap Data

xxx bytes

该域的大小取决于压缩方法及图像的尺寸和图像的位深度，它包含所有的位图数据字节，这些数据可能是彩色调色板的索引号，也可能是实际的RGB值，这将根据图像信息头中的位深度值来决定。

构件详解

1. 位图文件头
位图文件头包含有关于文件类型、文件大小、存放位置等信息，在Windows 3.0以上版本的位图文件中用BITMAPFILEHEADER结构来定义：
typedef struct tagBITMAPFILEHEADER { /* bmfh */
UINT bfType;
DWORD bfSize;
UINT bfReserved1;
UINT bfReserved2;
DWORD bfOffBits;
} BITMAPFILEHEADER;
其中：

bfType
说明文件的类型.（该值必需是0x4D42，也就是字符'BM'。我们不需要判断OS/2的位图标识，这么做现在来看似乎已经没有什么意义了，而且如果要支持OS/2的位图，程序将变得很繁琐。所以，在此只建议你检察'BM'标识）
bfSize
说明文件的大小，用字节为单位
bfReserved1
保留，必须设置为0
bfReserved2
保留，必须设置为0
bfOffBits
说明从文件头开始到实际的图象数据之间的字节的偏移量。这个参数是非常有用的，因为位图信息头和调色板的长度会根据不同情况而变化，所以你可以用这个偏移值迅速的从文件中读取到位数据。
2. 位图信息头
位图信息用BITMAPINFO结构来定义，它由位图信息头(bitmap-information header)和彩色表(color table)组成，前者用BITMAPINFOHEADER结构定义，后者用RGBQUAD结构定义。BITMAPINFO结构具有如下形式：
typedef struct tagBITMAPINFO { /* bmi */
BITMAPINFOHEADER bmiHeader;
RGBQUAD bmiColors[1];
} BITMAPINFO;
其中：

bmiHeader
说明BITMAPINFOHEADER结构，其中包含了有关位图的尺寸及位格式等信息
bmiColors
说明彩色表RGBQUAD结构的阵列，其中包含索引图像的真实RGB值。
BITMAPINFOHEADER结构包含有位图文件的大小、压缩类型和颜色格式，其结构定义为：
typedef struct tagBITMAPINFOHEADER { /* bmih */
DWORD biSize;
LONG biWidth;
LONG biHeight;
WORD biPlanes;
WORD biBitCount;
DWORD biCompression;
DWORD biSizeImage;
LONG biXPelsPerMeter;
LONG biYPelsPerMeter;
DWORD biClrUsed;
DWORD biClrImportant;
} BITMAPINFOHEADER;
其中：

biSize
说明BITMAPINFOHEADER结构所需要的字数。注：这个值并不一定是BITMAPINFOHEADER结构的尺寸，它也可能是sizeof(BITMAPV4HEADER)的值，或是sizeof(BITMAPV5HEADER)的值。这要根据该位图文件的格式版本来决定，不过，就现在的情况来看，绝大多数的BMP图像都是BITMAPINFOHEADER结构的（可能是后两者太新的缘故吧:-）。
biWidth
说明图象的宽度，以象素为单位
biHeight
说明图象的高度，以象素为单位。注：这个值除了用于描述图像的高度之外，它还有另一个用处，就是指明该图像是倒向的位图，还是正向的位图。如果该值是一个正数，说明图像是倒向的，如果该值是一个负数，则说明图像是正向的。大多数的BMP文件都是倒向的位图，也就是时，高度值是一个正数。（注：当高度值是一个负数时（正向图像），图像将不能被压缩（也就是说biCompression成员将不能是BI_RLE8或BI_RLE4）。
biPlanes
为目标设备说明位面数，其值将总是被设为1
biBitCount
说明比特数/象素，其值为1、4、8、16、24、或32
biCompression
说明图象数据压缩的类型。其值可以是下述值之一：
BI_RGB：没有压缩；
BI_RLE8：每个象素8比特的RLE压缩编码，压缩格式由2字节组成(重复象素计数和颜色索引)；
BI_RLE4：每个象素4比特的RLE压缩编码，压缩格式由2字节组成
BI_BITFIELDS：每个象素的比特由指定的掩码决定。
biSizeImage
说明图象的大小，以字节为单位。当用BI_RGB格式时，可设置为0
biXPelsPerMeter
说明水平分辨率，用象素/米表示
biYPelsPerMeter
说明垂直分辨率，用象素/米表示
biClrUsed
说明位图实际使用的彩色表中的颜色索引数（设为0的话，则说明使用所有调色板项）
biClrImportant
说明对图象显示有重要影响的颜色索引的数目，如果是0，表示都重要。
现就BITMAPINFOHEADER结构作如下说明：
(1) 彩色表的定位
应用程序可使用存储在biSize成员中的信息来查找在BITMAPINFO结构中的彩色表，如下所示：
pColor = ((LPSTR) pBitmapInfo + (WORD) (pBitmapInfo->bmiHeader.biSize))
(2) biBitCount
biBitCount=1 表示位图最多有两种颜色，缺省情况下是黑色和白色，你也可以自己定义这两种颜色。图像信息头装调色板中将有两个调色板项，称为索引0和索引1。图象数据阵列中的每一位表示一个象素。如果一个位是0，显示时就使用索引0的RGB值，如果位是1，则使用索引1的RGB值。
biBitCount=4 表示位图最多有16种颜色。每个象素用4位表示，并用这4位作为彩色表的表项来查找该象素的颜色。例如，如果位图中的第一个字节为0x1F，它表示有两个象素，第一象素的颜色就在彩色表的第2表项中查找，而第二个象素的颜色就在彩色表的第16表项中查找。此时，调色板中缺省情况下会有16个RGB项。对应于索引0到索引15。
biBitCount=8 表示位图最多有256种颜色。每个象素用8位表示，并用这8位作为彩色表的表项来查找该象素的颜色。例如，如果位图中的第一个字节为0x1F，这个象素的颜色就在彩色表的第32表项中查找。此时，缺省情况下，调色板中会有256个RGB项，对应于索引0到索引255。
biBitCount=16 表示位图最多有2¹⁶种颜色。每个色素用16位（2个字节）表示。这种格式叫作高彩色，或叫增强型16位色，或64K色。它的情况比较复杂，当biCompression成员的值是BI_RGB时，它没有调色板。16位中，最低的5位表示蓝色分量，中间的5位表示绿色分量，高的5位表示红色分量，一共占用了15位，最高的一位保留，设为0。这种格式也被称作555 16位位图。如果biCompression成员的值是BI_BITFIELDS，那么情况就复杂了，首先是原来调色板的位置被三个DWORD变量占据，称为红、绿、蓝掩码。分别用于描述红、绿、蓝分量在16位中所占的位置。在Windows 95（或98）中，系统可接受两种格式的位域：555和565，在555格式下，红、绿、蓝的掩码分别是：0x7C00、0x03E0、0x001F，而在565格式下，它们则分别为：0xF800、0x07E0、0x001F。你在读取一个像素之后，可以分别用掩码“与”上像素值，从而提取出想要的颜色分量（当然还要再经过适当的左右移操作）。在NT系统中，则没有格式限制，只不过要求掩码之间不能有重叠。（注：这种格式的图像使用起来是比较麻烦的，不过因为它的显示效果接近于真彩，而图像数据又比真彩图像小的多，所以，它更多的被用于游戏软件）。
biBitCount=24 表示位图最多有2²⁴种颜色。这种位图没有调色板（bmiColors成员尺寸为0），在位数组中，每3个字节代表一个象素，分别对应于颜色R、G、B。
biBitCount=32 表示位图最多有2³²种颜色。这种位图的结构与16位位图结构非常类似，当biCompression成员的值是BI_RGB时，它也没有调色板，32位中有24位用于存放RGB值，顺序是：最高位—保留，红8位、绿8位、蓝8位。这种格式也被成为888 32位图。如果 biCompression成员的值是BI_BITFIELDS时，原来调色板的位置将被三个DWORD变量占据，成为红、绿、蓝掩码，分别用于描述红、绿、蓝分量在32位中所占的位置。在Windows 95(or 98)中，系统只接受888格式，也就是说三个掩码的值将只能是：0xFF0000、0xFF00、0xFF。而在NT系统中，你只要注意使掩码之间不产生重叠就行。（注：这种图像格式比较规整，因为它是DWORD对齐的，所以在内存中进行图像处理时可进行汇编级的代码优化（简单））。
(3) ClrUsed
BITMAPINFOHEADER结构中的成员ClrUsed指定实际使用的颜色数目。如果ClrUsed设置成0，位图使用的颜色数目就等于biBitCount成员中的数目。请注意，如果ClrUsed的值不是可用颜色的最大值或不是0，则在编程时应该注意调色板尺寸的计算，比如在4位位图中，调色板的缺省尺寸应该是16＊sizeof(RGBQUAD)，但是，如果ClrUsed的值不是16或者不是0，那么调色板的尺寸就应该是ClrUsed＊sizeof(RGBQUAD)。
(4) 图象数据压缩
① BI_RLE8：每个象素为8比特的RLE压缩编码，可使用编码方式和绝对方式中的任何一种进行压缩，这两种方式可在同一幅图中的任何地方使用。
编码方式：由2个字节组成，第一个字节指定使用相同颜色的象素数目，第二个字节指定使用的颜色索引。此外，这个字节对中的第一个字节可设置为0，联合使用第二个字节的值表示：
第二个字节的值为0：行的结束。
第二个字节的值为1：图象结束。
第二个字节的值为2：其后的两个字节表示下一个象素从当前开始的水平和垂直位置的偏移量。
绝对方式：第一个字节设置为0，而第二个字节设置为0x03～0xFF之间的一个值。在这种方式中，第二个字节表示跟在这个字节后面的字节数，每个字节包含单个象素的颜色索引。压缩数据格式需要字边界(word boundary)对齐。下面的例子是用16进制表示的8-位压缩图象数据：
03 04 05 06 00 03 45 56 67 00 02 78 00 02 05 01 02 78 00 00 09 1E 00 01
这些压缩数据可解释为：
压缩数据
扩展数据
03 04 04 04 04
05 06 06 06 06 06 06
00 03 45 56 67 00 45 56 67
02 78 78 78
00 02 05 01 从当前位置右移5个位置后向下移一行
02 78 78 78
00 00 行结束
09 1E 1E 1E 1E 1E 1E 1E 1E 1E 1E
00 01 RLE编码图象结束
② BI_RLE4：
编码方式：由2个字节组成，第一个字节指定象素数目，第二个字节包含两种颜色索引，一个在高4位，另一个在低4位。第一个象素使用高4位的颜色索引，第二个使用低4位的颜色索引，第3个使用高4位的颜色索引，依此类推。
绝对方式：这个字节对中的第一个字节设置为0，第二个字节包含有颜色索引数，其后续字节包含有颜色索引，颜色索引存放在该字节的高、低4位中，一个颜色索引对应一个象素。此外，BI_RLE4也同样联合使用第二个字节中的值表示：
第二个字节的值为0：行的结束。
第二个字节的值为1：图象结束。
第二个字节的值为2：其后的两个字节表示下一个象素从当前开始的水平和垂直位置的偏移量。
下面的例子是用16进制数表示的4-位压缩图象数据：
03 04 05 06 00 06 45 56 67 00 04 78 00 02 05 01 04 78 00 00 09 1E 00 01
这些压缩数据可解释为：
压缩数据
扩展数据
03 04 0 4 0
05 06 0 6 0 6 0
00 06 45 56 67 00 4 5 5 6 6 7
04 78 7 8 7 8
00 02 05 01 从当前位置右移5个位置后向下移一行
04 78 7 8 7 8
00 00 行结束
09 1E 1 E 1 E 1 E 1 E 1
00 01 RLE图象结束
3. 彩色表
彩色表包含的元素与位图所具有的颜色数相同，象素的颜色用RGBQUAD结构来定义。对于24-位真彩色图象就不使用彩色表（同样也包括16位、和32位位图），因为位图中的RGB值就代表了每个象素的颜色。彩色表中的颜色按颜色的重要性排序，这可以辅助显示驱动程序为不能显示足够多颜色数的显示设备显示彩色图象。RGBQUAD结构描述由R、G、B相对强度组成的颜色，定义如下：
typedef struct tagRGBQUAD { /* rgbq */
BYTE rgbBlue;
BYTE rgbGreen;
BYTE rgbRed;
BYTE rgbReserved;
} RGBQUAD;
其中：

rgbBlue
指定蓝色强度
rgbGreen
指定绿色强度
rgbRed
指定红色强度
rgbReserved
保留，设置为0
4. 位图数据
紧跟在彩色表之后的是图象数据字节阵列。图象的每一扫描行由表示图象象素的连续的字节组成，每一行的字节数取决于图象的颜色数目和用象素表示的图象宽度。扫描行是由底向上存储的，这就是说，阵列中的第一个字节表示位图左下角的象素，而最后一个字节表示位图右上角的象素。（只针对与倒向DIB，如果是正向DIB，则扫描行是由顶向下存储的），倒向DIB的原点在图像的左下角，而正向DIB的原点在图像的左上角。同时，每一扫描行的字节数必需是4的整倍数，也就是DWORD对齐的。如果你想确保图像的扫描行DWORD对齐，可使用下面的代码：

(((width*biBitCount)+31)>>5)<<2

BMP 格式详解

位图文件头的格式：

typedef struct{
int bfType;//bfType(2字节)，这里恒定等于&H4D42,ASCII字符'BM'
long bfSize;//文件大小，以4字节为单位
int bfReserve1;//备用
int bfReserve2;//备用
long bfoffBits;//数据区在文件中的位置偏移量
}BITMAPFILEHEADER;//文件头结构体，14字节

typedef struct{
long bitSize;//位图信息头大小
long biWidth;//图象宽度，像素单位
long biHeight;//图象高度，像素单位
          int biPlanes;//位平面树=1
          int biBitCount;//单位像素的位数，表示bmp图片的颜色位数，即24位图、32位图
          long biCompression;//图片的压缩属性，bmp图片是不压缩的，等于0
          long biSizeImage;表示bmp图片数据区的大小，当上一个属性biCompression等于0时，这里的值可以省略不填
          long biXPlosPerMeter;//水平分辨率，可省略
          long biYPlosPerMeter;//垂直分辨率，可省略
          long biClrUsed;//表示使用了多少个颜色索引表，一般biBitCount属性小于16才会用到，等于0时表示有2^biBitCount个颜色索引表
          long biClrImportant;//表示有多少个重要的颜色，等于0时表示所有颜色都很重要
}BITMAPINFOHEADER;//位图信息头，40字节

BMP文件详解（2）2007-03-21 12:26一个bmp文件以BITMAPFILEHEADER结构体开始，BITMAPFILEHEADER的第1个属性是bfType(2字节)，这里恒定等于&H4D42。由于内存中的数据排列高位在左，低位在右，所以内存中从左往右看就显示成(42 4D)，所以在UltraEdit中头两个字节显示为(42 4D)就是这样形成的，以后的数据都是这个特点，不再作重复说明。

BITMAPFILEHEADER的第2个属性是bfSize(4字节)，表示整个bmp文件的大小，这里等于&H000004F8=1272字节。

BITMAPFILEHEADER的第3个、第4个属性分别是bfReserved1、bfReserved2(各2字节)，这里是2个保留属性，都为0，这里等于&H0000、&H0000。

BITMAPFILEHEADER的第5个属性是bfOffBits(4字节)，表示DIB数据区在bmp文件中的位置偏移量，这里等于&H00000076=118，表示数据区从文件开始往后数的118字节开始。
BITMAPFILEHEADER结构体这里就讲完了，大家会发现BITMAPFILEHEADER只占了bmp文件开始的14字节长度，但需要特别说明的是在vb中定义一个BITMAPFILEHEADER结构体变量，其长度占了16个字节，原因就是第1个属性本来应该只分配2个字节，但实际被分配了4个字节，多出来2个字节，所以如果想保存一张bmp图片，写入BITMAPFILEHEADER结构体时一定要注意这一点。

接下来是BITMAPINFO结构体部分。BITMAPINFO段由两部分组成：BITMAPINFOHEADER结构体和RGBQUAD结构体。其中RGBQUAD结构体表示图片的颜色信息，有些时候可以省略，一般的24位图片和32位图片都不带RGBQUAD结构体，因为DIB数据区直接表示的RGB值，一般4位图片和8位图片才带有RGBQUAD结构体。(多少位的图片就是用多少位来表示一个颜色信息，例如4位图片表示用4个bit来表示一个颜色信息。)一个bmp文件中有没有RGBQUAD结构体，可以根据前面BITMAPFILEHEADER结构体的第5个属性bfOffBits来判断，因为BITMAPINFOHEADER结构体长度为40bit，如果BITMAPINFOHEADER结构体结束后还未到DIB数据区的偏移量，就说明接下来的数据是RGBQUAD结构体部分。这里讲的C:\WINDOWS\Blue Lace 16.bmp是一个4bit图片，所以它带有 RGBQUAD结构体。

下面进入正题BITMAPINFOHEADER部分。

BITMAPINFOHEADER的第1个属性是biSize(4字节)，表示BITMAPINFOHEADER结构体的长度，最常见的长度是40字节，UltraEdit中可以看到紧接着的4个字节等于&H00000028=40字节。

BITMAPINFOHEADER的第2个属性是biWidth(4字节)，表示bmp图片的宽度，这里等于&H00000030=48像素。

BITMAPINFOHEADER的第3个属性是biHeight(4字节)，表示bmp图片的高度，这里等于&H00000030=48像素。

BITMAPINFOHEADER的第4个属性是biPlanes(2字节)，表示bmp图片的平面属，显然显示器只有一个平面，所以恒等于1，这里等于&H0001。

BITMAPINFOHEADER的第5个属性是biBitCount(2字节)，表示bmp图片的颜色位数，即24位图、32位图等等。这里等于&H0004，表示该图片为4位图。

BITMAPINFOHEADER的第6个属性是biCompression(4字节)，表示图片的压缩属性，bmp图片是不压缩的，等于0，所以这里为&H00000000。

BITMAPINFOHEADER的第7个属性是biSizeImage(4字节)，表示bmp图片数据区的大小，当上一个熟悉biCompression等于0时，这里的值可以省略不填，所以这里等于&H00000000。

BITMAPINFOHEADER的第8个属性是biXPelsPerMeter(4字节)，表示图片X轴每米多少像素，可省略，这里等于&H00000EC3=3779像素/米。

BITMAPINFOHEADER的第9个属性是biYPelsPerMeter(4字节)，表示图片Y轴每米多少像素，可省略，这里等于&H00000EC3=3779像素/米。

BITMAPINFOHEADER的第10个属性是biClrUsed(4字节)，表示使用了多少个颜色索引表，一般biBitCount属性小于16才会用到，等于0时表示有2^biBitCount个颜色索引表，所以这里仍等于&H00000000。

BITMAPINFOHEADER的第11个属性是biClrImportant(4字节)，表示有多少个重要的颜色，等于0时表示所有颜色都很重要，所以这里等于&H00000000。

至此BITMAPINFOHEADER结构体结束。

由于这个图片到这里还未到达DIB数据区的偏移量，所以接下来的部分是RGBQUAD结构体。RGBQUAD结构体由4个字节型数据组成，所以一个RGBQUAD结构体只占用4字节空间，从左到右每个字节依次表示(蓝色，绿色，红色，未使用)。举例的这个图片我数了数总共有16个RGBQUAD结构体，由于该图片是4位图，2^4正好等于16，所以它把16种颜色全部都枚举出来了，这些颜色就是一个颜色索引表。颜色索引表编号从0开始，总共16个颜色，所以编号为0-15。从UltraEdit中可以看到按照顺序，这16个RGBQUAD结构体依次为：

编号：(蓝，绿，红，空)

0号：(00，00，00，00)

1号：(00，00，80，00)

2号：(00，80，00，00)

3号：(00，80，80，00)

4号：(80，00，00，00)

5号：(80，00，80，00)

6号：(80，80，00，00)

7号：(80，80，80，00)

8号：(C0，C0，C0，00)

9号：(00，00，FF，00)

10号：(00，FF，00，00)

11号：(00，FF，FF，00)

12号：(FF，00，00，00)

13号：(FF，00，FF，00)

14号：(FF，FF，00，00)

15号：(FF，FF，FF，00)

为了更直观的表示这些颜色，可以见后面的图片。

到这里，正好满足DIB数据区的偏移量，所以后面的字节就是图片内容了。这里需要提醒的是所有的DIB数据扫描行是上下颠倒的，也就是说一幅图片先绘制底部的像素，再绘制顶部的像素，所以这些DIB数据所表示的像素点就是从图片的左下角开始，一直表示到图片的右上角。

由于这里的图片是4位图片，也就是说4bit就表示一个像素，一个字节有8个bit，所以一个字节能表示2个像素。

从UltraEdit中可以看到，DIB数据区第一个字节是&H44，16进制正好是将2进制数每4个一组书写的，跟4bit图片正好吻合，所以&H44表示两个像素，高位的4表示第一个像素，低位的4表示第二个像素。这里的4不是表示RGB颜色，而是表示颜色索引号为4，由于索引号从0开始编号的，所以4表示索引表中第5个颜色，从附图中可以看到索引号为4的是蓝色。这是第一字节，表示的是图片左下角开始2个像素，如果有 PhotoShop打开这个图片可以看到，左下角2个像素取出来的颜色RGB值正好等于索引表中第5个颜色的RGB值。后面的DIB数据以此类推。

至此一个bmp图片就全部解析完了，根据这些信息就可以完整的绘制一张bmp图片来。

============================================

如果你还不明白,还有:

1. BMP文件组成
BMP文件由文件头、位图信息头、颜色信息和图形数据四部分组成。
2. BMP文件头
BMP文件头数据结构含有BMP文件的类型、文件大小和位图起始位置等信息。

其结构定义如下:

typedef struct tagBITMAPFILEHEADER
{
WORDbfType; // 位图文件的类型，必须为BM
DWORD bfSize; // 位图文件的大小，以字节为单位
WORDbfReserved1; // 位图文件保留字，必须为0
WORDbfReserved2; // 位图文件保留字，必须为0
DWORD bfOffBits; // 位图数据的起始位置，以相对于位图
// 文件头的偏移量表示，以字节为单位
} BITMAPFILEHEADER;

3. 位图信息头

BMP位图信息头数据用于说明位图的尺寸等信息。
typedef struct tagBITMAPINFOHEADER{
DWORD biSize; // 本结构所占用字节数
LONGbiWidth; // 位图的宽度，以像素为单位
LONGbiHeight; // 位图的高度，以像素为单位
WORD biPlanes; // 目标设备的级别，必须为1
WORD biBitCount// 每个像素所需的位数，必须是1(双色),
// 4(16色)，8(256色)或24(真彩色)之一
DWORD biCompression; // 位图压缩类型，必须是 0(不压缩),
// 1(BI_RLE8压缩类型)或2(BI_RLE4压缩类型)之一
DWORD biSizeImage; // 位图的大小，以字节为单位
LONGbiXPelsPerMeter; // 位图水平分辨率，每米像素数
LONGbiYPelsPerMeter; // 位图垂直分辨率，每米像素数
DWORD biClrUsed;// 位图实际使用的颜色表中的颜色数
DWORD biClrImportant;// 位图显示过程中重要的颜色数
} BITMAPINFOHEADER;

4. 颜色表
颜色表用于说明位图中的颜色，它有若干个表项，每一个表项是一个RGBQUAD类型的结构，定义一种颜色。RGBQUAD结构的定义如下:

typedef struct tagRGBQUAD {
BYTErgbBlue;// 蓝色的亮度(值范围为0-255)
BYTErgbGreen; // 绿色的亮度(值范围为0-255)
BYTErgbRed; // 红色的亮度(值范围为0-255)
BYTErgbReserved;// 保留，必须为0
} RGBQUAD;
颜色表中RGBQUAD结构数据的个数有biBitCount来确定:
当biBitCount=1,4,8时，分别有2,16,256个表项;
当biBitCount=24时，没有颜色表项。
位图信息头和颜色表组成位图信息，BITMAPINFO结构定义如下:
typedef struct tagBITMAPINFO {
BITMAPINFOHEADER bmiHeader; // 位图信息头
RGBQUAD bmiColors[1]; // 颜色表
} BITMAPINFO;

5. 位图数据
位图数据记录了位图的每一个像素值，记录顺序是在扫描行内是从左到右,扫描行之间是从下到上。位图的一个像素值所占的字节数:

当biBitCount=1时，8个像素占1个字节;
当biBitCount=4时，2个像素占1个字节;
当biBitCount=8时，1个像素占1个字节;
当biBitCount=24时,1个像素占3个字节;
Windows规定一个扫描行所占的字节数必须是
4的倍数(即以long为单位),不足的以0填充，
一个扫描行所占的字节数计算方法:
DataSizePerLine= (biWidth* biBitCount+31)/8;
// 一个扫描行所占的字节数
DataSizePerLine= DataSizePerLine/4*4; // 字节数必须是4的倍数
位图数据的大小(不压缩情况下):
DataSize= DataSizePerLine* biHeight;

本文链接

模拟火车带你游西藏

2011-10-06T01:52:00Z

青藏铁路

注：请你用鼠标点‘发车’火车就出发了。火车到下一站会停下。

会有图片出现，把当地的景点介绍给你。看完介绍请你关闭图片

火车就又向下一站开动了........

本文链接

生活百态第三版 < 持续更新>

2011-08-21T04:59:00Z

史上最牛毕业生：大学美女抱着亲生女儿拍毕业照

中国十大暴利行业揭秘

最高人民法院对《婚姻法》新解释对中国女人的影响

这年头拼的就是经验

为什么美国高工资低物价，而中国却反过来低工资高物价

从睡觉的姿势看人的性格

新居 ? 旧宅 ?

一封震撼全国的信件

男人沉默的背后意味着什么

马上会被删的经典贴！至于你信不信，反正我信了

网上购物欺骗工商局提供警惕收货环节

这年头小偷也不好混啊! 暴力的友情提示

《裸婚时代》告诉我们13条硬道理

【中国房价真相大解密】 “买房养老”理论早晚害死你

看懂这个故事，你就看懂了中国，看懂了中国楼市

从锋芝婚变看分手哲学

中关村的部分奸商手段

男人过早告白得不到信赖

牢骚怪话往往都是至理名言

十分神奇的心理学

2011.6.7药家鑫执行死刑现场日记

一位网友看《蜗居》有感，我们都是精神上的“二奶”

【感动心灵的震撼】兽犹如此人何以堪

幽默的经济学原理

谁的钱最好忽悠

北京一套房只卖8万元的秘密

电脑游戏黑幕：就是要让你上瘾！

如果你是豹子你会？

慈不掌兵、情不立事、义不理财、善不为官

从诸多明星的离开来剖析现代医疗的状况

盘点靠拉登之死引发的畅销产品

创意无限 --- 公交表情图

国内最可怕的骗局：连锁加盟!

假如中美开战了

两性关系新破解实在是太有才了与大家分享下

藏在被子里的爱

我爸是李刚；大结局！！！引发中国现状！

献给世上所有动过真情的人

生活技巧及经验之谈第一部值得收藏

生活技巧及经验之谈第二部值得收藏

解密日本房屋如何抗震！很有必要知道

王朔谈成功：什么叫成功，不就挣点钱，被其他的人知道而已

色戒乎？色不戒乎？

男女情感的秘密 1/2

男女情感的秘密 2/2

《昨天》80后必看

大实话段子，个个都让你叫绝

你能在宝马里哭多久？

几首歌能让她们这么High?

告诉你一个北京公务员的真实待遇

2011年给力最新语录

追MM必杀技大揭秘：据说成功率高达99%……

20个华而不实的专业

惨烈！108个监控探头爆光菏泽车祸中生命消失瞬间！

怀着莫名的心情看完此文

日本最红的心理测试。有点邪乎，准的有点BT

做人要有气场哪怕你是个端盘子的

我们穷啊~~~

有车的朋友要注意了啊！加油时你注意到加油员的这个小动作了吗?

一位已全家移民美国的国企老总自白

其实爱不爱没那么重要

夫妻俩之间的经典问答

中国人暴富與赤貧的秘密

温州老板就是牛啊

现代未婚人群中为何普遍存在恐婚的现象?

2011春晚穿帮镜头集锦

人体死亡全过程

世界十大奇特夫妻

同学聚会·相见不如怀念

揭密“天上人间”：知名夜店及其十大头牌美女

最具中国特色的脑筋急转弯问题

2011第一强帖：最给力扫地老太太

他感动了中国,却没有感动CCTV的冷漠评委

话说春晚

房地产那点事儿

扫描男人临睡前的秘密行动

大学毕业出路利弊一览表

人们踩到屎后会有怎样的反应

姚晨写在分手后－－今生欠我一个婚礼

一名大学毕业生的反思：轰动中国万言帖最露骨大学生活

过年了你到家了吗

太精辟了!是谁把人生说的如此透彻

【八岁女童的遗书】我来过，我很乖.

关于婚姻的几点体会和教训

火葬场火化遗体真实过程

中行网银可能存漏洞骗子瞬间转走用户资金

请每一个孝顺的儿媳妇耐心地看下去

贫二代的求职路

看透但不要看破

生活的境界

真爷们

太吓人了！街头骗术大全（多看几遍，小心为妙）

一个房地产开发商建议年轻人不要贷款买房，看了这个我释然了

黑社会资料影像，珍惜生命，远离黑社会

从国外看中国人的真实国际地位 : 没有自由的繁荣是另一种贫困

一个让人辛酸的《农民工的故事》

业内人士惊曝商场潜规则

男人难呐

何时可以不用这样

美国人眼里的中国社会

不见液晶不上轿的新娘新郎愤而转身娶旧爱

单身个性男的生活小技巧

周立波的最新爆强语录

心情不好的时候进来看看

如今的社会如今的男人如今的女人

三国人物之性格匹配测试

男女关系33个绝妙比喻

从经济角度谈谈东分食堂强制使用饭卡的利益博弈

网友评“最给力”山寨版2010年“感动中国”人物

是什么毁了中国的大学?

卖家不是妓女

中国骗子大全！绝对长学问

房地产内幕：让我们以实际行动抑制房价

结婚七年间的惊人改变

如果这就是生活……

【一个理想主义者的创业故事】2010年老罗全国巡演完结篇

结婚的那些事儿

中国教育的文化

【生意经】各地商人性格参考

不知哪位天才总结的“社会写真”总结得太精辟太给力了

蜗居中的人物原型

活在中国

山东沂蒙年仅十岁的钢铁男孩

【生活之美】5分钟看遍世界上最美的50个落日

福利彩票内部人员曝光的内幕

由总部在美国纽约的经济实验室集团(EconomicLba)颁布的中国贫富标准线，看看你生活在哪个层次

随便发些图片，都是生活的点滴

大家来看看KFC的汉堡里有什么？！？！？！

【有良心人请转载】一个老人去世的全过程看了想哭

你有几个朋友，已经失去

大学生找工作最有效的十大证书

一个关于生活的故事 1/2

一个关于生活的故事 2/2

网友深度报料超市的惊人内幕看完目瞪口呆

传说中名企大公司的工资收入，看完你会自卑还是自豪？

给腾讯一段真诚的忠告——《做人不能太腾讯》,我看着你长大，看着你变坏.

拒绝油老鼠油枪一停一顿暗藏巨大利润

中国民生纪实时过境迁却仍震撼心灵（组图）

走高速的朋友注意了现在的作案手段太残忍

生活百态

街头人体漂浮魔术

瞧瞧人家美国乞丐要饭的水平

小心！小偷的各种偷包方法

18种会致流产，让宝宝变傻的食物!

央视都不敢播的写实照片

阿里巴巴访谈亚洲创富第一人杜云生

女足青训：改年龄同性恋泛滥女足主帅被逼走

破解人体十三个奇怪现象

一个让5000万人哭的电话

上了大学才会知道的事情

告诉中国彩民一个残酷的事实别再做黄粱美梦了

深圳街头卖艺老人三次捐款感动中国

有些东西不是给人吃的，劝大家都看看，为自己为家人

中国特色滴国情 --- 34个精彩小段子

太带劲了,是中国人，一定要看

郑渊洁：我从1995年起就不信任疫苗

让人馋爆眼球的职业

【东成西就】为什么留学生出国不愿意回国发展？

世界上最寂寞的47件事

很震撼的视频！请永远记住，开玩笑绝对绝对绝对要有个度！！不然……

一位有良知厨师的忠告：少去饭店吃饭！

【现实版神雕侠侣】传奇故事爱情天梯

美国给年轻人看的励志短片《DID YOU KNOW》(中英对照版)

紧急寻女儿---请帮忙转载帖

中国各省人性格特点（二）

中国各省人性格特点-1

中国物价为何比美国还高？

一门英语扼杀了多少艺术人才？中国的教育体制，侮辱了艺术，毁灭了人才！

职场必看的十部经典电影

日本人为什么不吃小龙虾？！

如果您是有良心的人，您就进来看完这段视频！（有文字解说）

看看什么才是真正的社会主义国家！我为什么留在澳洲?

[快乐接力] 骗子要你汇款的短信先别忙着删除

监狱和公司之间的差异

社会养老保险交得越多越亏？——一看吓一跳

别相信电影！——子弹击中人体后真实的威力有多大

震惊！收银员竟这样“偷”您的钱

我来告诉你，大部分美女都嫁给什么人了！

中国人都来看看真相吧！高薪养廉是混帐逻辑!

关于手机出现三角形漫游符号的正确解释

全国娶老婆成本排行

中国的房价到底高成啥样？

轰动全网络的经典帖子 - 疯娘

激光近视手术－－－－医学界的一个惊天阴谋!

【法律常识】律师提醒书写借条、欠条、收条应注意什么？

各种银行卡的收费标准情况

准备做房奴的姐妹兄弟们，看好了，这是装修后才后悔的79件事

告诉你什么是五险一金，即社会保险.

牛人超节约室内空间创意设计,广大蜗居人士必看

80后最经典的婚房设计(50张图片)

超全的食盐妙用139 <你肯定用的到》

真是太有用了——整理央视《家有妙招》生活小常识

生活小常识 <记录下来，说不定何时有用>

请没有买房和买车的朋友一定认真的看一下

奶茶的做法

60个生活常识，欢迎补充

分手短信!有点可惜了! 大家觉得哪出问题了呢,欢迎发表自己的看法.

200条装修小常识 2/2

200条装修小常识 1/2

做饭技巧

亲戚图-实用

塑料回收标志

本文链接

了解【北京中清研信息技术研究院】朋友进来聊聊

2011-06-25T15:57:00Z

主办机构：北京中清研信息技术研究院

项目特色：

1、业务特征与软件架构间如何关联？如何设计最佳的软件架构来适应业务的需求？如何选择一个最佳的开发模式？如何评价一个软件产品，如何做好过程改进管理？如何管理软件产品的全生命周期？本班设计了全新的培养体系，从知识体系，方法论思想，技术手段，能力框架几方面培养软件产品设计专家和架构师； 2、课程体系以产品设计方法论为基础，以需求分析为导引，系统地传授软件产品设计方法和设计技术（而非开发技术）以及研发过程管理技术。在全新构建的知识体系基础上，透过合理的实践推导机制，演变为学生的产品设计能力； 3、符合条件的本班学员均可被推荐进入国内著名高校攻读工程硕士学位。（自主命题、自主招生的入学方式，无须参加全国统考，直接攻读硕士学位）

适合对象：

1、IT/软件企业的研发骨干技术和技术管理人员； 2、企事业单位信息化项目管理和实施人员； 3、 IT项目经理，IT产品经理具有IT技术背景和工作经验，有志提升自己职业生涯水平或创业的人士。

学位和证书：

符合条件并经考核合格者可获得：北京中清研信息技术研究院结业证书通过入学考试，并达到所在学校各项要求可获得：工程硕士学位证书

后续服务：该班学员将会自动获得学习俱乐部会员资格，免费享受各种活动。

学制：约2.5年

上课时间：非全日制(在职)班，业余时间上课。

报名条件：1、具备国民教育序列大学本科毕业资格 2、1年以上工作经验。

提交材料：1、本人身份证（军官证）复印件3份； 2、本科毕业证书、学士学位证复印件各4份； 3、个人简历纸质2份、电子版1份。

课程设置：

模块	课程名称
IT产品研发管理技术	IT项目管理
IT产品研发管理技术	IT产品研发管理体系（IPD）
体系结构技术和系统分析	信息分析方法
	软件体系结构
	应用系统架构与分析
	应用系统集成技术
研发架构及设计模式	需求分析与需求建模
	软件架构与设计模式
	软件架构案例分析与设计实践
过程管理技术研究	研发过程改进
	测试评审方法
	软件开发管理及实践
软件产品本质特征研究	软件性能设计与评价
	软件安全设计与评价
	软件度量
管理理论与技术	技术创新经济学
	研发团队建设与绩效管理
	产品协同开发技术
	产品生命周期管理（PLM）
软件产品设计技术	软件重用技术
	软件可靠性设计技术
	虚拟技术
	界面设计艺术与鉴赏
	数据挖掘与报表展现技术
产品架构专题综合讲座	RUP
	XP
	游戏软件
	中间件技术
	SOA
	SAAS
实践机制	设计实践
	项目实操
	学位论文

多个华丽的 Web 日历组件

联想电脑各型号区别

常用 Web Service 服务汇总（天气预报，列车时刻表）

EditPlus的编码自动完成功能及配置文件下载

Windows 7 / 2008 R2 with SP1 简体中文版MSDN镜像下载

Microsoft .NET Framework 4 下载

 Microsoft Office Professional Plus 2010简体中文版下载及激活

 全世界名人博客你可以学到太多太多

 Windows常用运行库下载 (DirectX、VC++、.Net Framework等)

《藏地密码》大结局藏地密码第十部内容揭秘

 全球十大恐怖电影

 感动到流泪的中文情歌

 中央直属企业名单赶紧收藏

 文件对比工具Beyond Compare 3.2.4.13298简体中文版+密钥

 神断狄仁杰全集下载

 全国各大报社的投稿地址赚点稿费吧

 清宫珍藏生男育女表

 【英语想过4.6.8级请认真看】236组高频词组笔记

 可以单曲循环一整天的歌

 UML 建模工具下载

 VMware Workstation 7.0 正式版下载及序列号,支持支持Win7全特效

 【资源分享】新网页图文编辑器 xhEditor

Eclipse最新插件的下载地址大全

 2011央视春晚央视春晚节目单

 介绍一本职场技能书籍 <<“A4纸”工作法 >>

机票购买渠道

 LiveRecorder - 屏幕录像直播器软件介绍及下载

 实用QQ聊天图片

 最新国际网络银行PayBox（目前处于招募会员阶段）

广州各行各业批发市场地址

 【资源分享】北大和人大两年整理出来的阅读书单 --- 无论你是什么专业

 java开发工具 MyEclipse 8.5下载及注册码

 UltraISO软碟通 9.3 下载及注册

 每日学一点英文

 心动

 采购岗位的面试题

 75道题: 能做6道以上 => High IQ

全国高校免费网上图书馆入口地址大全值得收藏 1

全国高校免费网上图书馆入口地址大全值得收藏 2

大学生都应该脱口而出的英语口语

 a常用的美语口语

 50名优秀的学习c/c++网站和网页清单

 【资源分享】一位美工朋友多年工作经历中收集的小工具和素材下载站

 ５秒钟内反映过来的就是高手

 【影视剧下载】为大家推荐一下电影电视剧下载的好地方

 电脑内存之DDR2与DDR3的区别

 QQ表情推荐

 女孩自我提升的好网站

 中国明星自己的QQ

谋杀上班时间的30个小众网站

 为什么要娶处女？？？科学大揭秘！！！

世上最全的中国皇帝顺序，很难得到，值得收藏！

百家姓QQ头像【闪图大全】 ——超美，值得收藏

 视频格式详细介绍（刻录需知）

光盘刻录知识全集

 记住这些生意QQ群，有机会用的上的

 广州服装进货经验之谈留着也许用得着

 广州货源进货内幕全攻略（超齐全，不看后悔）

求职者在试用期内，享有哪些权益？

中国各省省名之由来

 【笔记本装机推荐】电脑公司 GhostXP_SP3 笔记本通用版 2010.10 BY CN

2010动态头像大全

 百度二级域名大全 1/2

百度二级域名大全 2/2

【推荐】网页制作程序开发学习手册大全

 好经典啊，随便一句都可当QQ签名

 点击网赚是怎样骗人的

 微软所有的资源MSDN版

 Visual Studio 2010 支持的操作系统版本

 爱旅游的注意了！中国最美丽地方排行榜及游览最佳时间

 备份百度空间软件导出百度空间搬家程序新浪博客备份搜狐博客备份QQ空间博客中国网易博WordPress

灌篮高手后传

 显示器分辨率大全

 国外优秀的php开源内容管理系统

 2010十大手机必备软件

 腾讯公司高层管理人员QQ号及昵称和相关职位

 一家软件公司性格测试题!准的一塌糊涂~

这些网站你全都没进过，那你就真要恶补一下了

 中国移动的指令大全！（不再需要人工台）

宝贝起名做参考

 最新的第6套人民币

 水浒英雄谱

 受欢迎的编程开发资源资料

 中国历代王朝地图及其国土面积详细介绍

 诡刺

 浴火之凤

 精选最新优秀源码下载网站排行

 MSN.com 邮箱注册方法

 比google牛十倍的搜索类网站

 慧眼识英雄！诺基亚N93改版机挑选

 硬件测试及应用软件集合_CPU相关_1

硬件测试及应用软件集合_显示相关_2

硬件测试及应用软件集合_存储相关_3

硬件测试及应用软件集合_整体检测_4

硬件测试及应用软件集合_其他测试_5

硬件测试及应用软件集合_显卡测试_6

本文链接

蔡妍性感 MV性感到你流鼻血

2011-05-06T12:55:00Z

2011-05-06T12:55:00Z2011-05-06T12:55:00Zglaiveleehttp://www.cnblogs.com/glaivelee/

本文链接

js 获取硬件及系统信息

2011-03-25T12:34:00Z

<!DOCTYPEHTMLPUBLIC"-//W3C//DTD HTML 4.0 Transitional//EN">

<html>

　<head>

<title>javascript获得客户端硬件信息-www.web2bar.cn/</title>

<metaname="GENERATOR"content="Microsoft Visual Studio .NET

7.1">

<metaname="vs_targetSchema"

content="http://schemas.microsoft.com/intellisense/ie5">

　<scriptid=clientEventHandlersJSlanguage=javascript>

<!--

function Button2_onclick() {//CPU 信息

　var locator = new ActiveXObject ("WbemScripting.SWbemLocator");

　var service = locator.ConnectServer(".");

　var properties = service.ExecQuery("SELECT * FROM Win32_Processor");

　var e = new Enumerator (properties);

　document.write("<table border=1>");

　for (;!e.atEnd();e.moveNext ())

　{

var p = e.item ();

document.write("<tr>");

document.write("<td>cpu信息</td>");

document.write("<td>" + p.Caption + "</td>");

document.write("<td>" + p.DeviceID + "</td>");

document.write("<td>" + p.Name + "</td>");

document.write("<td>" + p.CpuStatus + "</td>");

document.write("<td>" + p.Availability + "</td>");

document.write("<td>" + p.Level + "</td>");

document.write("<td>" + p.ProcessorID + "</td>");

document.write("<td>" + p.SystemName + "</td>");

document.write("<td>" + p.ProcessorType + "</td>");

document.write("</tr>");

　}

　document.write("</table>");

}

function Button1_onclick() {//磁盘序列号

　var locator = new ActiveXObject ("WbemScripting.SWbemLocator");

　var service = locator.ConnectServer(".");

　var properties = service.ExecQuery("SELECT * FROM Win32_DiskDrive");

　var e = new Enumerator (properties);

　document.write("<table border=1>");

　for (;!e.atEnd();e.moveNext ())

　{

var p = e.item ();

document.write("<tr>");

document.write("<td>磁盘序列号</td>");

document.write("<td>" + p.signature + "</td>");

document.write("</tr>");

　}

　document.write("</table>");

}

function Button3_onclick() {//CD-ROM 信息

　var locator = new ActiveXObject ("WbemScripting.SWbemLocator");

　var service = locator.ConnectServer(".");

　var properties = service.ExecQuery("SELECT * FROM Win32_CDROMDrive");

　var e = new Enumerator (properties);

　document.write("<table border=1>");

　for (;!e.atEnd();e.moveNext ())

　{

var p = e.item ();

document.write("<tr>");

document.write("<td>cd-rom信息</td>");

document.write("<td>" + p.Caption + "</td>");

document.write("<td>" + p.Description + "</td>");

document.write("<td>" + p.Drive + "</td>");

document.write("<td>" + p.Status + "</td>");

document.write("<td>" + p.MediaLoaded + "</td>");

document.write("</tr>");

　}

　document.write("</table>");

}

function Button4_onclick() {//键盘信息

　var locator = new ActiveXObject ("WbemScripting.SWbemLocator");

　var service = locator.ConnectServer(".");

　var properties = service.ExecQuery("SELECT * FROM Win32_Keyboard");

　var e = new Enumerator (properties);

　document.write("<table border=1>");

　for (;!e.atEnd();e.moveNext ())

　{

var p = e.item ();

document.write("<tr>");

document.write("<td>键盘信息</td>");

document.write("<td>" + p.Description + "</td>");

document.write("<td>" + p.Name + "</td>");

document.write("<td>" + p.Status + "</td>");

document.write("</tr>");

　}

　document.write("</table>");

}

function Button5_onclick() {//主板信息

　var locator = new ActiveXObject ("WbemScripting.SWbemLocator");

　var service = locator.ConnectServer(".");

　var properties = service.ExecQuery("SELECT * FROM Win32_BaseBoard");

　var e = new Enumerator (properties);

　document.write("<table border=1>");

　for (;!e.atEnd();e.moveNext ())

　{

var p = e.item ();

document.write("<tr>");

document.write("<td>主板信息</td>");

document.write("<td>" + p.HostingBoard + "</td>");

document.write("<td>" + p.Manufacturer + "</td>");

document.write("<td>" + p.PoweredOn + "</td>");

document.write("<td>" + p.Product + "</td>");

document.write("<td>" + p.SerialNumber + "</td>");

document.write("<td>" + p.Version + "</td>");

document.write("</tr>");

　}

　document.write("</table>");

}

function getinfo()

{

Button1_onclick();

Button2_onclick()

Button3_onclick()

Button4_onclick()

Button5_onclick()

}

//-->

</script>

</head>

　<body>

<INPUTid="Button1"type="button"value="Button"

name="Button1"language=javascriptonclick="return getinfo()">

　</body>

</html>

PHP 将汉字转成拼音的方法

2011-01-01T01:58:00Z

/**
* 将字符串转化为拼音
*/
function Pinyin($_String, $_Code='gb2312') {
    $_DataKey ="a|ai|an|ang|ao|ba|bai|ban|bang|bao|bei|ben|beng|bi|bian|biao|bie|bin|bing|bo|bu|ca|cai|can|cang|cao|ce|ceng|cha".
            "|chai|chan|chang|chao|che|chen|cheng|chi|chong|chou|chu|chuai|chuan|chuang|chui|chun|chuo|ci|cong|cou|cu|".
            "cuan|cui|cun|cuo|da|dai|dan|dang|dao|de|deng|di|dian|diao|die|ding|diu|dong|dou|du|duan|dui|dun|duo|e|en|er".
            "|fa|fan|fang|fei|fen|feng|fo|fou|fu|ga|gai|gan|gang|gao|ge|gei|gen|geng|gong|gou|gu|gua|guai|guan|guang|gui".
            "|gun|guo|ha|hai|han|hang|hao|he|hei|hen|heng|hong|hou|hu|hua|huai|huan|huang|hui|hun|huo|ji|jia|jian|jiang".
            "|jiao|jie|jin|jing|jiong|jiu|ju|juan|jue|jun|ka|kai|kan|kang|kao|ke|ken|keng|kong|kou|ku|kua|kuai|kuan|kuang".
            "|kui|kun|kuo|la|lai|lan|lang|lao|le|lei|leng|li|lia|lian|liang|liao|lie|lin|ling|liu|long|lou|lu|lv|luan|lue".
            "|lun|luo|ma|mai|man|mang|mao|me|mei|men|meng|mi|mian|miao|mie|min|ming|miu|mo|mou|mu|na|nai|nan|nang|nao|ne".
            "|nei|nen|neng|ni|nian|niang|niao|nie|nin|ning|niu|nong|nu|nv|nuan|nue|nuo|o|ou|pa|pai|pan|pang|pao|pei|pen".
            "|peng|pi|pian|piao|pie|pin|ping|po|pu|qi|qia|qian|qiang|qiao|qie|qin|qing|qiong|qiu|qu|quan|que|qun|ran|rang".
            "|rao|re|ren|reng|ri|rong|rou|ru|ruan|rui|run|ruo|sa|sai|san|sang|sao|se|sen|seng|sha|shai|shan|shang|shao|".
            "she|shen|sheng|shi|shou|shu|shua|shuai|shuan|shuang|shui|shun|shuo|si|song|sou|su|suan|sui|sun|suo|ta|tai|".
            "tan|tang|tao|te|teng|ti|tian|tiao|tie|ting|tong|tou|tu|tuan|tui|tun|tuo|wa|wai|wan|wang|wei|wen|weng|wo|wu".
            "|xi|xia|xian|xiang|xiao|xie|xin|xing|xiong|xiu|xu|xuan|xue|xun|ya|yan|yang|yao|ye|yi|yin|ying|yo|yong|you".
            "|yu|yuan|yue|yun|za|zai|zan|zang|zao|ze|zei|zen|zeng|zha|zhai|zhan|zhang|zhao|zhe|zhen|zheng|zhi|zhong|".
            "zhou|zhu|zhua|zhuai|zhuan|zhuang|zhui|zhun|zhuo|zi|zong|zou|zu|zuan|zui|zun|zuo";

    $_DataValue = "-20319|-20317|-20304|-20295|-20292|-20283|-20265|-20257|-20242|-20230|-20051|-20036|-20032|-20026|-20002|-19990".
            "|-19986|-19982|-19976|-19805|-19784|-19775|-19774|-19763|-19756|-19751|-19746|-19741|-19739|-19728|-19725".
            "|-19715|-19540|-19531|-19525|-19515|-19500|-19484|-19479|-19467|-19289|-19288|-19281|-19275|-19270|-19263".
            "|-19261|-19249|-19243|-19242|-19238|-19235|-19227|-19224|-19218|-19212|-19038|-19023|-19018|-19006|-19003".
            "|-18996|-18977|-18961|-18952|-18783|-18774|-18773|-18763|-18756|-18741|-18735|-18731|-18722|-18710|-18697".
            "|-18696|-18526|-18518|-18501|-18490|-18478|-18463|-18448|-18447|-18446|-18239|-18237|-18231|-18220|-18211".
            "|-18201|-18184|-18183|-18181|-18012|-17997|-17988|-17970|-17964|-17961|-17950|-17947|-17931|-17928|-17922".
            "|-17759|-17752|-17733|-17730|-17721|-17703|-17701|-17697|-17692|-17683|-17676|-17496|-17487|-17482|-17468".
            "|-17454|-17433|-17427|-17417|-17202|-17185|-16983|-16970|-16942|-16915|-16733|-16708|-16706|-16689|-16664".
            "|-16657|-16647|-16474|-16470|-16465|-16459|-16452|-16448|-16433|-16429|-16427|-16423|-16419|-16412|-16407".
            "|-16403|-16401|-16393|-16220|-16216|-16212|-16205|-16202|-16187|-16180|-16171|-16169|-16158|-16155|-15959".
            "|-15958|-15944|-15933|-15920|-15915|-15903|-15889|-15878|-15707|-15701|-15681|-15667|-15661|-15659|-15652".
            "|-15640|-15631|-15625|-15454|-15448|-15436|-15435|-15419|-15416|-15408|-15394|-15385|-15377|-15375|-15369".
            "|-15363|-15362|-15183|-15180|-15165|-15158|-15153|-15150|-15149|-15144|-15143|-15141|-15140|-15139|-15128".
            "|-15121|-15119|-15117|-15110|-15109|-14941|-14937|-14933|-14930|-14929|-14928|-14926|-14922|-14921|-14914".
            "|-14908|-14902|-14894|-14889|-14882|-14873|-14871|-14857|-14678|-14674|-14670|-14668|-14663|-14654|-14645".
            "|-14630|-14594|-14429|-14407|-14399|-14384|-14379|-14368|-14355|-14353|-14345|-14170|-14159|-14151|-14149".
            "|-14145|-14140|-14137|-14135|-14125|-14123|-14122|-14112|-14109|-14099|-14097|-14094|-14092|-14090|-14087".
            "|-14083|-13917|-13914|-13910|-13907|-13906|-13905|-13896|-13894|-13878|-13870|-13859|-13847|-13831|-13658".
            "|-13611|-13601|-13406|-13404|-13400|-13398|-13395|-13391|-13387|-13383|-13367|-13359|-13356|-13343|-13340".
            "|-13329|-13326|-13318|-13147|-13138|-13120|-13107|-13096|-13095|-13091|-13076|-13068|-13063|-13060|-12888".
            "|-12875|-12871|-12860|-12858|-12852|-12849|-12838|-12831|-12829|-12812|-12802|-12607|-12597|-12594|-12585".
            "|-12556|-12359|-12346|-12320|-12300|-12120|-12099|-12089|-12074|-12067|-12058|-12039|-11867|-11861|-11847".
            "|-11831|-11798|-11781|-11604|-11589|-11536|-11358|-11340|-11339|-11324|-11303|-11097|-11077|-11067|-11055".
            "|-11052|-11045|-11041|-11038|-11024|-11020|-11019|-11018|-11014|-10838|-10832|-10815|-10800|-10790|-10780".
            "|-10764|-10587|-10544|-10533|-10519|-10331|-10329|-10328|-10322|-10315|-10309|-10307|-10296|-10281|-10274".
            "|-10270|-10262|-10260|-10256|-10254";
    $_TDataKey = explode('|', $_DataKey);
    $_TDataValue = explode('|', $_DataValue);

    //array_combine:创建一个数组，用一个数组的值作为其键名，另一个数组的值作为其值
    //PHP_VERSION:表示PHP的版本
    $_Data = (PHP_VERSION>='5.0') ? array_combine($_TDataKey, $_TDataValue) : _Array_Combine($_TDataKey, $_TDataValue);
    //arsort:对数组进行逆向排序并保持索引关系
    //reset:将数组的内部指针指向第一个单元
    arsort($_Data);
    reset($_Data);

    /**
     *    假如编码不是gb2312,则启用utf-8
     */
    if($_Code != 'gb2312') $_String = _U2_Utf8_Gb($_String);
    $_Res = '';
    for($i=0; $i<strlen($_String); $i++) {
        $_P = ord(substr($_String, $i, 1));
        /**
         *
         */
        if($_P>160) {
            $_Q = ord(substr($_String, ++$i, 1));
            $_P = $_P*256 + $_Q - 65536;
        }
        $_Res .= _Pinyin($_P, $_Data);
    }
    return preg_replace("/[^a-z0-9]*/", '', $_Res);
}

function _Pinyin($_Num, $_Data) {
    if($_Num>0 && $_Num<160 )
        return chr($_Num);
    elseif($_Num<-20319 || $_Num>-10247)
        return '';
    else {
        foreach($_Data as $k=>$v) {
            if($v<=$_Num)
                break;
        }
        return $k;
    }
}

function _U2_Utf8_Gb($_C) {
    $_String = '';
    if($_C < 0x80) {
        $_String .= $_C;
    }
    elseif($_C < 0x800) {
        $_String .= chr(0xC0 | $_C>>6);
        $_String .= chr(0x80 | $_C & 0x3F);
    }
    elseif($_C < 0x10000) {
        $_String .= chr(0xE0 | $_C>>12);
        $_String .= chr(0x80 | $_C>>6 & 0x3F);
        $_String .= chr(0x80 | $_C & 0x3F);
    }
    elseif($_C < 0x200000) {
        $_String .= chr(0xF0 | $_C>>18);
        $_String .= chr(0x80 | $_C>>12 & 0x3F);
        $_String .= chr(0x80 | $_C>>6 & 0x3F);
        $_String .= chr(0x80 | $_C & 0x3F);
    }
    return @iconv('UTF-8', 'GB2312//IGNORE', $_String);
}

/**
* 等价PHP5版本的array_combine函数
*/
function _Array_Combine($_Arr1, $_Arr2) {
    for($i=0; $i<count($_Arr1); $i++) $_Res[$_Arr1[$i]] = $_Arr2[$i];
    return $_Res;

}

神奇3D圣诞树祝广大技术人员圣诞快乐！

2010-12-26T02:26:00Z

全部代码:

本文链接

Java正则表达式教程

2010-12-25T11:21:00Z

正则表达式善于处理文本，对匹配、搜索和替换等操作都有意想不到的作用。正因如此，正则表达式现在是作为程序员七种基本技能之一*，因此学习和使用它在工作中都能达到很高的效率。

正则表达式应用于程序设计语言中，首次是出现在 Perl 语言，这也让 Perl 奠定了正则表达式旗手的地位。现在，它已经深入到了所有的程序设计语言中，在程序设计语言中，正则表达式可以说是标准配置了。

Java 中从 JDK 1.4 开始增加了对正则表达式的支持，至此正则表达式成为了 Java 中的基本类库，使用时不需要再导入第三方的类库了。Java 正则表达式的语法来源于象征着正则表达式标准的 Perl 语言，但也不是完全相同的，具体的可以参看 Pattern 类的 API 文档说明。

我在一次偶然中发现了位于 java.sun.com 站点上的 Java Tutorial，也在那里看到了关于 Java 的正则表达式教程，感觉它不同于其他的正则表达式教程，文中以大量的匹配实例来进行说明。为了能让 Java 学习者能更好地使用正则表达式，就将其完整地译出了。该教程中所介绍的正则表达式应用仅仅是最为简单的（并没有完全地涉及到 Pattern 类支持的所有正则表达式语法，也没有涉及到高级的应用），适合于从未接触过或者是尚未完全明白正则表达式基础的学习者。在学习完该教程后，应该对正则表达式有了初步的了解，并能熟练地运用 java.util.regex 包中的关于正则表达式的类库，为今后学习更高级的正则表达式技术奠定良好的基础。

教程中所有的源代码都在 src 目录下，可以直接编译运行。由于当前版本的 Java Tutorial 是基于 JDK 6.0 的，因此其中的示例程序也用到了 JDK 6.0 中的新增类库，但正则表达式在 JDK 1.4 就已经存在了，为了方便大家使用，改写了部分的源代码，源代码类名中后缀为“V4”的表示用于 JDK 1.4 或以上版本，“V5”的表示用于 JDK 5.0 或以上版本，没有这些后缀的类在各个版本中均可以正常使用。

* 这是由《程序员》杂志社评出的，刊登在《程序员》2007 年 3 月刊上。这七种基本技能是：数组，字符串与哈希表、正则表达式、调试、两门语言、一个开发环境、SQL 语言和编写软件的思想。

译者序

序

0　引言

0.1　什么是正则表达式？

0.2　java.util.regex 包是如何描述正则表达式的？

1　测试用具

2　字符串

2.1　元字符

3　字符类

3.1　简单类

3.1.1　否定

3.1.2　范围

3.1.3　并集

3.1.4　交集

3.1.5　差集

4　预定义字符类

5　量词

5.1　零长度匹配

5.2　捕获组和字符类中的量词

5.3　贪婪、勉强和侵占量词间的不同

6　捕获组

6.1　编号方式

6.2　反向引用

7　边界匹配器

8　Pattern 类的方法

8.1　使用标志构建模式

8.2　内嵌标志表达式

8.3　使用 matches(String, CharSequence) 方法

8.4　使用 split(String) 方法

8.5　其他有用的方法

8.6　在 java.lang.String 中等价的 Pattern 方法

9　Matcher 类的方法

9.1　使用 start 和 end 方法

9.2　使用 matches 和 lookingAt 方法

9.3　使用 replaceFirst(String) 和 replaceAll(String) 方法

9.4　使用 appendReplacement(StringBuffer, String) 和 appendTail(StringBuffer) 方法

9.5　在 java.lang.String 中等价的 Matcher 方法

10　PatternSyntaxException 类的方法

11　更多的资源

12　问题和练习

注释

译后记

序返回目录

本文介绍如何使用 java.util.regex API 作为正则表达式模式匹配。虽然说这个包中可被接受的语法参数与 Perl 是相似的，但我们并不需要掌握 Perl 的语法知识。本教程将从基础开始，逐层深入到更多的高级技巧。下面是各章节的主要内容：

0　引言

粗略地看一下正则表达式，同时也介绍组成 API 的核心类。

1　测试用具

编写了一个简单的应用程序，用于测试正则表达式的模式匹配。

2　字符串

介绍基本的模式匹配、元字符和引用。

3　字符类

描述简单字符类、否定、范围、并集、交集和差集。

4　预定义字符类

描述空白字符、字母和数字字符等基本的预定义字符。

5　量词

使用贪婪（greedy）、勉强（reluctant）和侵占（possessive）量词，来匹配指定表达式 X 的次数。

6　捕获组

解释如何把多个字符作为一个单独的单元进行处理。

7　边界匹配器

描述行、单词和输入的边界。

8　Pattern 类的方法

测试了 Pattern 中一些有用的方法，以及探究一些高级的特性，诸如：带标记的编译和使用内嵌标记表达式。

9　Matcher 类的方法

描述了 Matcher 类中通常使用的方法。

10　PatternSyntaxException 类的方法

描述了如何检查一个 PatternSyntaxException 异常。

11　更多的资源

要了解更多正则表达式，可以参考这一节。

12　问题和练习

巩固一下本教程所介绍的正则表达式的基本知识，并附有答案。

为了区分文档中的正则表达式和普通字符串，均以\d[abc]{2}的形式表示正则表达式的模式。

0　引言返回目录

0.1　什么是正则表达式？返回目录

正则表达式（regular expressions）是一种描述字符串集的方法，它是以字符串集中各字符串的共有特征为依据的。正则表达式可以用于搜索、编辑或者是操作文本和数据。它超出了 Java 程序设计语言的标准语法，因此有必要去学习特定的语法来构建正则表达式。正则表达式的变化是复杂的，一旦你理解了它们是如何被构造的话，你就能解析或者构建任意的正则表达式了。

本教程讲授 java.util.regex API 所支持的正则表达式语法，以及介绍几个可运行的例子来说明不同的对象间是如何交互的。在正则表达式的世界中，有不同风格的选择，比如：grep[2]、Perl、Tcl、Python、PHP 和 awk。java.util.regex API 中的正则表达式语法与 Perl 中的最为相似。

0.2　java.util.regex 包是如何描述正则表达式的？返回目录

java.util.regex 包主要由三个类所组成：Pattern、Matcher 和 PatternSyntaxException。

Pattern 对象表示一个已编译的正则表达式。Pattern 类没有提供公共的构造方法。要构建一个模式，首先必须调用公共的静态 compile 方法，它将返回一个 Pattern 对象。这个方法接受正则表达式作为第一个参数。本教程的开始部分将教你必需的语法。

Matcher 是一个靠着输入的字符串来解析这个模式和完成匹配操作的对象。与 Pattern 相似，Matcher 也没有定义公共的构造方法，需要通过调用 Pattern 对象的 matcher 方法来获得一个 Matcher 对象。

PatternSyntaxException 对象是一个未检查异常，指示了正则表达式中的一个语法错误。

本教程的最后几节课程会详细地说明各个类。首当其冲的问题是：必须理解正则表达式是如何被构建的，因此下一节引入了一个简单的测试用具，重复地用于探究它们的语法。

1　测试用具返回目录

这节给出了一个可重用的测试用具 RegexTestHarness.java，用于探究构建 API 所支持的正则表达式。使用

java RegexTestHarness

这个命令来运行，没有被接受的命令行参数。这个应用会不停地循环执行下去[3]，提示用户输入正则表达式和字符串。虽然说使用这个测试用具是可选的，但你会发现它用于探究下文所讨论的测试用例将更为方便。

import java.io.Console;

import java.util.regex.Pattern;

import java.util.regex.Matcher;

public class RegexTestHarness {

public static void main(String[] args) {

Console console = System.console();

if (console == null) {

System.err.println("No console.");

System.exit(1);

}

while (true) {

Pattern pattern = Pattern.compile(console.readLine("%nEnter your regex: "));

Matcher matcher = pattern.matcher(console.readLine("Enter input string to search: "));

boolean found = false;

while (matcher.find()) {

console.format("I found the text \"%s\" starting at index %d " +

"and ending at index %d.%n",

matcher.group(), matcher.start(), matcher.end());

found = true;

}

if (!found) {

console.format("No match found.%n");

}

在继续下一节之前，确认开发环境支持必需的包，并保存和编译这段代码。

【译者注】

由于当前版本的 Java Tutorial 是基于 JDK 6.0 编写的，上述的测试用具由于使用到 JDK 6.0 中新增的类库（java.io.Console），所以该用具只能在 JDK 6.0 的环境中编译运行，由于 Console 访问操作系统平台上的控制台，因此这个测试用具只能在操作系统的字符控制台中运行，不能运行在 IDE 的控制台中。

正则表达式是 JDK 1.4 所增加的类库，为了兼容 JDK 1.4 和 JDK 5.0 的版本，重新改写了这个测试用具，让其能适用于不同的版本。

JDK 5.0 适用的测试用具（RegexTestHarnessV5.java，该用具可以在 IDE 中执行），建议 JDK 6.0 环境也采用该用具。

import java.util.Scanner;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

public class RegexTestHarnessV5 {

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

while (true) {

System.out.printf("%nEnter your regex: ");

Pattern pattern = Pattern.compile(scanner.nextLine());

System.out.printf("Enter input string to search: ");

Matcher matcher = pattern.matcher(scanner.nextLine());

boolean found = false;

while (matcher.find()) {

System.out.printf(

"I found the text \"%s\" starting at index %d and ending at index %d.%n",

matcher.group(), matcher.start(), matcher.end()

);

found = true;

}

if (!found) {

System.out.printf("No match found.%n");

}

JDK 1.4 适用的测试用具（RegexTestHarnessV4.java）：

import java.io.BufferedInputStream;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

public class RegexTestHarnessV4 {

public static void main(String[] args) throws IOException {

BufferedReader br = new BufferedReader(

new InputStreamReader(new BufferedInputStream(System.in))

);

while (true) {

System.out.print("\nEnter your regex: ");

Pattern pattern = Pattern.compile(br.readLine());

System.out.print("Enter input string to search: ");

Matcher matcher = pattern.matcher(br.readLine());

boolean found = false;

while (matcher.find()) {

System.out.println("I found the text \"" + matcher.group() +

"\" starting at index " + matcher.start() +

" and ending at index " + matcher.end() +

".");

found = true;

}

if (!found) {

System.out.println("No match found.");

}

2　字符串返回目录

在大多数的情况下，API所支持模式匹配的基本形式是匹配字符串，如果正则表达式是foo，输入的字符串也是 foo，这个匹配将会是成功的，因为这两个字符串是相同的。试着用测试用具来测试一下：

Enter your regex: foo

Enter input string to search: foo

I found the text "foo" starting at index 0 and ending at index 3.

结果确实是成功的。注意当输入的字符串是 3 个字符长度的时候，开始的索引是 0，结束的索引是 3。这个是约定俗成的，范围包括开始的索引，不包括结束的索引，如下图所示：

图 1　字符串“foo”的单元格编号和索引值[4]

字符串中的每一个字符位于其自身的单元格（cell）中，在每个单元格之间有索引指示位。字符串“foo”始于索引 0 处，止于索引 3 处，即使是这些字符它们自己仅占据了 0、1 和 2 号单元格。

就子序列匹配而言，你会注意到一些重叠，下一次匹配开始索引与前一次匹配的结束索引是相同的：

Enter your regex: foo

Enter input string to search: foofoofoo

I found the text "foo" starting at index 0 and ending at index 3.

I found the text "foo" starting at index 3 and ending at index 6.

I found the text "foo" starting at index 6 and ending at index 9.

2.1　元字符返回目录

API 也支持许多可以影响模式匹配的特殊字符。把正则表达式改为cat.并输入字符串“cats”，输出如下所示：

Enter your regex: cat.

Enter input string to search: cats

I found the text "cats" starting at index 0 and ending at index 4.

虽然在输入的字符串中没有点（.），但这个匹配仍然是成功的。这是由于点（.）是一个元字符（metacharacters）（被这个匹配翻译成了具有特殊意义的字符了）。这个例子为什么能匹配成功的原因在于，元字符.指的是“任意字符”。

API 所支持的元字符有：([{\^-$|}])?*+.

注意：在学习过更多的如何构建正则表达式后，你会碰到这些情况：上面的这些特殊字符不应该被处理为元字符。然而也能够使用这个清单来检查一个特殊的字符是否会被认为是元字符。例如，字符 !、@ 和 # 决不会有特殊的意义。

有两种方法可以强制将元字符处理成为普通字符：

1. 在元字符前加上反斜线（\）；

2. 把它放在\Q（引用开始）和\E（引用结束）之间[5]。在使用这种技术时，\Q和\E能被放于表达式中的任何位置（假设先出现\Q[6]）

3　字符类返回目录

如果你曾看过 Pattern 类的说明，会看到一些构建正则表达式的概述。在这一节中你会发现下面的一些表达式：

字符类

[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]]除 b 和 c 之外的 a 到 z 字符：[ad-z]（差集）

[a-z&&[^m-p]]a 到 z，并且不包括 m 到 p：[a-lq-z]（差集）左边列指定正则表达式构造，右边列描述每个构造的匹配的条件。

注意：“字符类（character class）”这个词中的“类（class）”指的并不是一个 .class 文件。在正则表达式的语义中，字符类是放在方括号里的字符集，指定了一些字符中的一个能被给定的字符串所匹配。

3.1　简单类（Simple Classes）返回目录

字符类最基本的格式是把一些字符放在一对方括号内。例如：正则表达式[bcr]at会匹配“bat”、“cat”或者“rat”，这是由于其定义了一个字符类（接受“b”、“c”或“r”中的一个字符）作为它的首字符。

Enter your regex: [bcr]at

Enter input string to search: bat

I found the text "bat" starting at index 0 and ending at index 3.

Enter your regex: [bcr]at

Enter input string to search: cat

I found the text "cat" starting at index 0 and ending at index 3.

Enter your regex: [bcr]at

Enter input string to search: rat

I found the text "rat" starting at index 0 and ending at index 3.

Enter your regex: [bcr]at

Enter input string to search: hat

No match found.

在上面的例子中，在第一个字符匹配字符类中所定义字符中的一个时，整个匹配就是成功的。

3.1.1　否定返回目录

要匹配除那些列表之外所有的字符时，可以在字符类的开始处加上^元字符，这种就被称为否定（negation）。

Enter your regex: [^bcr]at

Enter input string to search: bat

No match found.

Enter your regex: [^bcr]at

Enter input string to search: cat

No match found.

Enter your regex: [^bcr]at

Enter input string to search: rat

No match found.

Enter your regex: [^bcr]at

Enter input string to search: hat

I found the text "hat" starting at index 0 and ending at index 3.

在输入的字符串中的第一个字符不包含在字符类中所定义字符中的一个时，匹配是成功的。

3.1.2　范围返回目录

有时会想要定义一个包含值范围的字符类，诸如，“a 到 h”的字母或者是“1 到 5”的数字。指定一个范围，只要在被匹配的首字符和末字符间插入-元字符，比如：[1-5]或者是[a-h]。也可以在类里每个的边上放置不同的范围来提高匹配的可能性，例如：[a-zA-Z]将会匹配 a 到 z（小写字母）或者 A 到 Z（大写字母）中的任何一个字符。

下面是一些范围和否定的例子：

Enter your regex: [a-c]

Enter input string to search: a

I found the text "a" starting at index 0 and ending at index 1.

Enter your regex: [a-c]

Enter input string to search: b

I found the text "b" starting at index 0 and ending at index 1.

Enter your regex: [a-c]

Enter input string to search: c

I found the text "c" starting at index 0 and ending at index 1.

Enter your regex: [a-c]

Enter input string to search: d

No match found.

Enter your regex: foo[1-5]

Enter input string to search: foo1

I found the text "foo1" starting at index 0 and ending at index 4.

Enter your regex: foo[1-5]

Enter input string to search: foo5

I found the text "foo5" starting at index 0 and ending at index 4.

Enter your regex: foo[1-5]

Enter input string to search: foo6

No match found.

Enter your regex: foo[^1-5]

Enter input string to search: foo1

No match found.

Enter your regex: foo[^1-5]

Enter input string to search: foo6

I found the text "foo6" starting at index 0 and ending at index 4.

3.1.3　并集返回目录

可以使用并集（union）来建一个由两个或两个以上字符类所组成的单字符类。构建一个并集，只要在一个字符类的边上嵌套另外一个，比如：[0-4[6-8]]，这种奇特方式构建的并集字符类，可以匹配 0，1，2，3，4，6，7，8 这几个数字。

Enter your regex: [0-4[6-8]]

Enter input string to search: 0

I found the text "0" starting at index 0 and ending at index 1.

Enter your regex: [0-4[6-8]]

Enter input string to search: 5

No match found.

Enter your regex: [0-4[6-8]]

Enter input string to search: 6

I found the text "6" starting at index 0 and ending at index 1.

Enter your regex: [0-4[6-8]]

Enter input string to search: 8

I found the text "8" starting at index 0 and ending at index 1.

Enter your regex: [0-4[6-8]]

Enter input string to search: 9

No match found.

3.1.4　交集返回目录

建一个仅仅匹配自身嵌套类中公共部分字符的字符类时，可以像[0-9&&[345]]中那样使用&&。这种方式构建出来的交集（intersection）简单字符类，仅仅以匹配两个字符类中的 3，4，5 共有部分。

Enter your regex: [0-9&&[345]]

Enter input string to search: 3

I found the text "3" starting at index 0 and ending at index 1.

Enter your regex: [0-9&&[345]]

Enter input string to search: 4

I found the text "4" starting at index 0 and ending at index 1.

Enter your regex: [0-9&&[345]]

Enter input string to search: 5

I found the text "5" starting at index 0 and ending at index 1.

Enter your regex: [0-9&&[345]]

Enter input string to search: 2

No match found.

Enter your regex: [0-9&&[345]]

Enter input string to search: 6

No match found.

下面演示两个范围交集的例子：

Enter your regex: [2-8&&[4-6]]

Enter input string to search: 3

No match found.

Enter your regex: [2-8&&[4-6]]

Enter input string to search: 4

I found the text "4" starting at index 0 and ending at index 1.

Enter your regex: [2-8&&[4-6]]

Enter input string to search: 5

I found the text "5" starting at index 0 and ending at index 1.

Enter your regex: [2-8&&[4-6]]

Enter input string to search: 6

I found the text "6" starting at index 0 and ending at index 1.

Enter your regex: [2-8&&[4-6]]

Enter input string to search: 7

No match found.

3.1.5　差集返回目录

最后，可以使用差集（subtraction）来否定一个或多个嵌套的字符类，比如：[0-9&&[^345]]，这个是构建一个匹配除 3，4，5 之外所有 0 到 9 间数字的简单字符类。

Enter your regex: [0-9&&[^345]]

Enter input string to search: 2

I found the text "2" starting at index 0 and ending at index 1.

Enter your regex: [0-9&&[^345]]

Enter input string to search: 3

No match found.

Enter your regex: [0-9&&[^345]]

Enter input string to search: 4

No match found.

Enter your regex: [0-9&&[^345]]

Enter input string to search: 5

No match found.

Enter your regex: [0-9&&[^345]]

Enter input string to search: 6

I found the text "6" starting at index 0 and ending at index 1.

Enter your regex: [0-9&&[^345]]

Enter input string to search: 9

I found the text "9" starting at index 0 and ending at index 1.

到此为止，已经涵盖了如何建立字符类的部分。在继续下一节之前，可以试着回想一下那张字符类表。

4　预定义字符类返回目录

Pattern 的 API 包有许多有用的预定义字符类（predefined character classes），提供了常用正则表达式的简写形式。

预定义字符类

.任何字符（匹配或者不匹配行结束符）

\d数字字符：[0-9]

\D非数字字符：[^0-9]

\s空白字符：[\t\n\x0B\f\r]

\S非空白字符：[^\s]

\w单词字符：[a-zA-Z_0-9]

\W非单词字符：[^\w] 上表中，左列是构造右列字符类的简写形式。例如：\d指的是数字范围（0～9），\w指的是单词字符（任何大小写字母、下划线或者是数字）。无论何时都有可能使用预定义字符类，它可以使代码更易阅读，更易从难看的字符类中排除错误。

以反斜线（\）开始的构造称为转义构造（escaped constructs）。回顾一下在字符串一节中的转义构造，在那里我们提及了使用反斜线，以及用于引用的\Q和\E。在字符串中使用转义构造，必须在一个反斜线前再增加一个反斜用于字符串的编译，例如：

private final String REGEX = "\\d"; // 单个数字

这个例子中\d是正则表达式，另外的那个反斜线是用于代码编译所必需的。但是测试用具读取的表达式，是直接从控制台中输入的，因此不需要那个多出来的反斜线。

下面的例子说明了预字义字符类的用法：

Enter your regex: .

Enter input string to search: @

I found the text "@" starting at index 0 and ending at index 1.

Enter your regex: .

Enter input string to search: 1

I found the text "1" starting at index 0 and ending at index 1.

Enter your regex: .

Enter input string to search: a

I found the text "a" starting at index 0 and ending at index 1.

Enter your regex: \d

Enter input string to search: 1

I found the text "1" starting at index 0 and ending at index 1.

Enter your regex: \d

Enter input string to search: a

No match found.

Enter your regex: \D

Enter input string to search: 1

No match found.

Enter your regex: \D

Enter input string to search: a

I found the text "a" starting at index 0 and ending at index 1.

Enter your regex: \s

Enter input string to search:

I found the text " " starting at index 0 and ending at index 1.

Enter your regex: \s

Enter input string to search: a

No match found.

Enter your regex: \S

Enter input string to search:

No match found.

Enter your regex: \S

Enter input string to search: a

I found the text "a" starting at index 0 and ending at index 1.

Enter your regex: \w

Enter input string to search: a

I found the text "a" starting at index 0 and ending at index 1.

Enter your regex: \w

Enter input string to search: !

No match found.

Enter your regex: \W

Enter input string to search: a

No match found.

Enter your regex: \W

Enter input string to search: !

I found the text "!" starting at index 0 and ending at index 1.

在开始的三个例子中，正则表达式是简单的，.（“点”元字符）表示“任意字符”，因此，在所有的三个例子（随意地选取了“@”字符，数字和字母）中都是匹配成功的。在接下来的例子中，都使用了预定义字符类表格中的单个正则表达式构造。你应该可以根据这张表指出前面每个匹配的逻辑：

\d 匹配数字字符

\s 匹配空白字符

\w 匹配单词字符

也可以使用意思正好相反的大写字母：

\D 匹配非数字字符

\S 匹配非空白字符

\W 匹配非单词字符

5　量词返回目录

这一节我们来看一下贪婪（greedy）、勉强（reluctant）和侵占（possessive）量词，来匹配指定表达式X的次数。

量词（quantifiers）允许指定匹配出现的次数，方便起见，当前 Pattern API 规范下，描述了贪婪、勉强和侵占三种量词。首先粗略地看一下，量词X?、X??和X?+都允许匹配 X 零次或一次，精确地做同样的事情，但它们之间有着细微的不同之处，在这节结束前会进行说明。

量　词　种　类意义

贪婪勉强侵占

X?X??X?+匹配 X 零次或一次

X*X*?X*+匹配 X 零次或多次

X+X+?X++匹配 X 一次或多次

X{n}X{n}?X{n}+匹配 X n 次

X{n,}X{n,}?X{n,}+匹配 X 至少 n 次

X{n,m}X{n,m}?X{n,m}+匹配 X 至少 n 次，但不多于 m 次那我们现在就从贪婪量词开始，构建三个不同的正则表达式：字母a后面跟着?、*和+。接下来看一下，用这些表达式来测试输入的字符串是空字符串时会发生些什么：

Enter your regex: a?

Enter input string to search:

I found the text "" starting at index 0 and ending at index 0.

Enter your regex: a*

Enter input string to search:

I found the text "" starting at index 0 and ending at index 0.

Enter your regex: a+

Enter input string to search:

No match found.

5.1　零长度匹配返回目录

在上面的例子中，开始的两个匹配是成功的，这是因为表达式a?和a*都允许字符出现零次。就目前而言，这个例子不像其他的，也许你注意到了开始和结束的索引都是 0。输入的空字符串没有长度，因此该测试简单地在索引 0 上匹配什么都没有，诸如此类的匹配称之为零长度匹配（zero-length matches）。零长度匹配会出现在以下几种情况：输入空的字符串、在输入字符串的开始处、在输入字符串最后字符的后面，或者是输入字符串中任意两个字符之间。由于它们开始和结束的位置有着相同的索引，因此零长度匹配是容易被发现的。

我们来看一下关于零长度匹配更多的例子。把输入的字符串改为单个字符“a”，你会注意到一些有意思的事情：

Enter your regex: a?

Enter input string to search: a

I found the text "a" starting at index 0 and ending at index 1.

I found the text "" starting at index 1 and ending at index 1.

Enter your regex: a*

Enter input string to search: a

I found the text "a" starting at index 0 and ending at index 1.

I found the text "" starting at index 1 and ending at index 1.

Enter your regex: a+

Enter input string to search: a

I found the text "a" starting at index 0 and ending at index 1.

所有的三个量词都是用来寻找字母“a”的，但是前面两个在索引 1 处找到了零长度匹配，也就是说，在输入字符串最后一个字符的后面。回想一下，匹配把字符“a”看作是位于索引 0 和索引 1 之间的单元格中，并且测试用具一直循环下去直到不再有匹配为止。依赖于所使用的量词不同，最后字符后面的索引“什么也没有”的存在可以或者不可以触发一个匹配。

现在把输入的字符串改为一行 5 个“a”时，会得到下面的结果：

Enter your regex: a?

Enter input string to search: aaaaa

I found the text "a" starting at index 0 and ending at index 1.

I found the text "a" starting at index 1 and ending at index 2.

I found the text "a" starting at index 2 and ending at index 3.

I found the text "a" starting at index 3 and ending at index 4.

I found the text "a" starting at index 4 and ending at index 5.

I found the text "" starting at index 5 and ending at index 5.

Enter your regex: a*

Enter input string to search: aaaaa

I found the text "aaaaa" starting at index 0 and ending at index 5.

I found the text "" starting at index 5 and ending at index 5.

Enter your regex: a+

Enter input string to search: aaaaa

I found the text "aaaaa" starting at index 0 and ending at index 5.

在“a”出现零次或一次时，表达式a?寻找到所匹配的每一个字符。表达式a*找到了两个单独的匹配：第一次匹配到所有的字母“a”，然后是匹配到最后一个字符后面的索引 5。最后，a+匹配了所有出现的字母“a”，忽略了在最后索引处“什么都没有”的存在。

在这里，你也许会感到疑惑，开始的两个量词在遇到除了“a”的字母时会有什么结果。例如，在“ababaaaab”中遇到了字母“b”会发生什么呢？

下面我们来看一下：

Enter your regex: a?

Enter input string to search: ababaaaab

I found the text "a" starting at index 0 and ending at index 1.

I found the text "" starting at index 1 and ending at index 1.

I found the text "a" starting at index 2 and ending at index 3.

I found the text "" starting at index 3 and ending at index 3.

I found the text "a" starting at index 4 and ending at index 5.

I found the text "a" starting at index 5 and ending at index 6.

I found the text "a" starting at index 6 and ending at index 7.

I found the text "a" starting at index 7 and ending at index 8.

I found the text "" starting at index 8 and ending at index 8.

I found the text "" starting at index 9 and ending at index 9.

Enter your regex: a*

Enter input string to search: ababaaaab

I found the text "a" starting at index 0 and ending at index 1.

I found the text "" starting at index 1 and ending at index 1.

I found the text "a" starting at index 2 and ending at index 3.

I found the text "" starting at index 3 and ending at index 3.

I found the text "aaaa" starting at index 4 and ending at index 8.

I found the text "" starting at index 8 and ending at index 8.

I found the text "" starting at index 9 and ending at index 9.

Enter your regex: a+

Enter input string to search: ababaaaab

I found the text "a" starting at index 0 and ending at index 1.

I found the text "a" starting at index 2 and ending at index 3.

I found the text "aaaa" starting at index 4 and ending at index 8.

即使字母“b”在单元格 1、3、8 中出现，但在这些位置上的输出报告了零长度匹配。正则表达式a?不是特意地去寻找字母“b”，它仅仅是去找字母“a”存在或者其中缺少的。如果量词允许匹配“a”零次，任何输入的字符不是“a”时将会作为零长度匹配。在前面的例子中，根据讨论的规则保证了 a 被匹配。

对于要精确地匹配一个模式 n 次时，可以简单地在一对花括号内指定一个数值：

Enter your regex: a{3}

Enter input string to search: aa

No match found.

Enter your regex: a{3}

Enter input string to search: aaa

I found the text "aaa" starting at index 0 and ending at index 3.

Enter your regex: a{3}

Enter input string to search: aaaa

I found the text "aaa" starting at index 0 and ending at index 3.

这里，正则表确定式a{3}在一行中寻找连续出现三次的字母“a”。第一次测试失败的原由在于，输入的字符串没有足够的 a 用来匹配；第二次测试输出的字符串正好包括了三个“a”，触发了一次匹配；第三次测试也触发了一次匹配，这是由于在输出的字符串的开始部分正好有三个“a”。接下来的事情与第一次的匹配是不相关的，如果这个模式将在这一点后继续出现，那它将会触发接下来的匹配：

Enter your regex: a{3}

Enter input string to search: aaaaaaaaa

I found the text "aaa" starting at index 0 and ending at index 3.

I found the text "aaa" starting at index 3 and ending at index 6.

I found the text "aaa" starting at index 6 and ending at index 9.

对于需要一个模式出现至少 n 次时，可以在这个数字后面加上一个逗号（,）：

Enter your regex: a{3,}

Enter input string to search: aaaaaaaaa

I found the text "aaaaaaaaa" starting at index 0 and ending at index 9.

输入一样的字符串，这次测试仅仅找到了一个匹配，这是由于一个中有九个“a”满足了“至少”三个“a”的要求。

最后，对于指定出现次数的上限，可以在花括号添加第二个数字。

Enter your regex: a{3,6} // 寻找一行中至少连续出现 3 个（但不多于 6 个）“a”

Enter input string to search: aaaaaaaaa

I found the text "aaaaaa" starting at index 0 and ending at index 6.

I found the text "aaa" starting at index 6 and ending at index 9.

这里，第一次匹配在 6 个字符的上限时被迫终止了。第二个匹配包含了剩余的三个 a（这是匹配所允许最小的字符个数）。如果输入的字符串再少掉一个字母，这时将不会有第二个匹配，之后仅剩余两个 a。

5.2　捕获组和字符类中的量词返回目录

到目前为止，仅仅测试了输入的字符串包括一个字符的量词。实际上，量词仅仅可能附在一个字符后面一次，因此正则表达式abc+的意思就是“a 后面接着 b，再接着一次或者多次的 c”，它的意思并不是指abc一次或者多次。然而，量词也可能附在字符类和捕获组的后面，比如，[abc]+表示一次或者多次的 a 或 b 或 c，(abc)+表示一次或者多次的“abc”组。

我们来指定(dog)组在一行中三次进行说明。

Enter your regex: (dog){3}

Enter input string to search: dogdogdogdogdogdog

I found the text "dogdogdog" starting at index 0 and ending at index 9.

I found the text "dogdogdog" starting at index 9 and ending at index 18.

Enter your regex: dog{3}

Enter input string to search: dogdogdogdogdogdog

No match found.

上面的第一个例子找到了三个匹配，这是由于量词用在了整个捕获组上。然而，把圆括号去掉，这时的量词{3}现在仅用在了字母“g”上，从而导致这个匹配失败。

类似地，也能把量词应用于整个字符类：

Enter your regex: [abc]{3}

Enter input string to search: abccabaaaccbbbc

I found the text "abc" starting at index 0 and ending at index 3.

I found the text "cab" starting at index 3 and ending at index 6.

I found the text "aaa" starting at index 6 and ending at index 9.

I found the text "ccb" starting at index 9 and ending at index 12.

I found the text "bbc" starting at index 12 and ending at index 15.

Enter your regex: abc{3}

Enter input string to search: abccabaaaccbbbc

No match found.

上面的第一个例子中，量词{3}应用在了整个字符类上，但是第二个例子这个量词仅用在字母“c”上。

5.3　贪婪、勉强和侵占量词间的不同返回目录

在贪婪、勉强和侵占三个量词间有着细微的不同。

贪婪量词之所以称之为“贪婪的”，这是由于它们强迫匹配器读入（或者称之为吃掉）整个输入的字符串，来优先尝试第一次匹配，如果第一次尝试匹配（对于整个输入的字符串）失败，匹配器会通过回退整个字符串的一个字符再一次进行尝试，不断地进行处理直到找到一个匹配，或者左边没有更多的字符来用于回退了。赖于在表达式中使用的量词，最终它将尝试地靠着 1 或 0 个字符的匹配。

但是，勉强量词采用相反的途径：从输入字符串的开始处开始，因此每次勉强地吞噬一个字符来寻找匹配，最终它们会尝试整个输入的字符串。

最后，侵占量词始终是吞掉整个输入的字符串，尝试着一次（仅有一次）匹配。不像贪婪量词那样，侵占量词绝不会回退，即使这样做是允许全部的匹配成功。

为了说明一下，看看输入的字符串是 xfooxxxxxxfoo 时。

Enter your regex: .*foo // 贪婪量词

Enter input string to search: xfooxxxxxxfoo

I found the text "xfooxxxxxxfoo" starting at index 0 and ending at index 13.

Enter your regex: .*?foo // 勉强量词

Enter input string to search: xfooxxxxxxfoo

I found the text "xfoo" starting at index 0 and ending at index 4.

I found the text "xxxxxxfoo" starting at index 4 and ending at index 13.

Enter your regex: .*+foo // 侵占量词

Enter input string to search: xfooxxxxxxfoo

No match found.

第一个例子使用贪婪量词.*，寻找紧跟着字母“f”“o”“o”的“任何东西”零次或者多次。由于量词是贪婪的，表达式的.*部分第一次“吃掉”整个输入的字符串。在这一点，全部表达式不能成功地进行匹配，这是由于最后三个字母（“f”“o”“o”）已经被消耗掉了。那么匹配器会慢慢地每次回退一个字母，直到返还的“foo”在最右边出现，这时匹配成功并且搜索终止。

然而，第二个例子采用勉强量词，因此通过首次消耗“什么也没有”作为开始。由于“foo”并没有出现在字符串的开始，它被强迫吞掉第一个字母（“x”），在 0 和 4 处触发了第一个匹配。测试用具会继续处理，直到输入的字符串耗尽为止。在 4 和 13 找到了另外一个匹配。

第三个例子的量词是侵占，所以在寻找匹配时失败了。在这种情况下，整个输入的字符串被.*+消耗了，什么都没有剩下来满足表达式末尾的“foo”。

你可以在想抓取所有的东西，且决不回退的情况下使用侵占量词，在这种匹配不是立即被发现的情况下，它将会优于等价的贪婪量词。

6　捕获组返回目录

在上一节中，学习了每次如何把量词放在一个字符、字符类或者捕获组中。到目前为止，还没有详细地讨论过捕获组的概念。

捕获组（capturing group）是将多个字符作为单独的单元来对待的一种方式。构建它们可以通过把字符放在一对圆括号中而成为一组。例如，正则表达式(dog)建了单个的组，包括字符“d”“o”和“g”。匹配捕获组输入的字符串部分将会存放于内存中，稍后通过反向引用再次调用。（在 6.2 节中将会讨论反向引用）

6.1　编号方式返回目录

在 Pattern 的 API 描述中，捕获组通过从左至右计算开始的圆括号进行编号。例如，在表达式((A)(B(C)))中，有下面的四组：

1. ((A)(B(C)))

2. (A)

3. (B(C))

4. (C)

要找出当前的表达式中有多少组，通过调用 Matcher 对象的 groupCount 方法。groupCount 方法返回 int 类型值，表示当前 Matcher 模式中捕获组的数量。例如，groupCount 返回 4 时，表示模式中包含有 4 个捕获组。

有一个特别的组——组 0，它表示整个表达式。这个组不包括在 groupCount 的报告范围内。以(?开始的组是纯粹的非捕获组（non-capturing group），它不捕获文本，也不作为组总数而计数。（可以看 8 Pattern 类的方法一节中非捕获组的例子。）

Matcher 中的一些方法，可以指定 int 类型的特定组号作为参数，因此理解组是如何编号的是尤为重要的。

public int start(int group)：返回之前的匹配操作期间，给定组所捕获的子序列的初始索引。

public int end(int group)：返回之前的匹配操作期间，给定组所捕获子序列的最后字符索引加 1。

public String group (int group)：返回之前的匹配操作期间，通过给定组而捕获的输入子序列。

6.2　反向引用返回目录

匹配输入字符串的捕获组部分会存放在内存中，通过反向引用（backreferences）稍后再调用。在正则表达式中，反向引用使用反斜线（\）后跟一个表示需要再调用组号的数字来表示。例如，表达式(\d\d)定义了匹配一行中的两个数字的捕获组，通过反向引用\1，表达式稍候会被再次调用。

匹配两个数字，且后面跟着两个完全相同的数字时，就可以使用(\d\d)\1作为正则表达式：

Enter your regex: (\d\d)\1

Enter input string to search: 1212

I found the text "1212" starting at index 0 and ending at index 4.

如果更改最后的两个数字，这时匹配就会失败：

Enter your regex: (\d\d)\1

Enter input string to search: 1234

No match found.

对于嵌套的捕获组而言，反向引用采用完全相同的方式进行工作，即指定一个反斜线加上需要被再次调用的组号。

7　边界匹配器返回目录

就目前而言，我们的兴趣在于指定输入字符串中某些位置是否有匹配，还没有考虑到字符串的匹配产生在什么地方。

通过指定一些边界匹配器（boundary matchers）的信息，可以使模式匹配更为精确。比如说你对某个特定的单词感兴趣，并且它只出现在行首或者是行尾时。又或者你想知道匹配发生在单词边界（word boundary），或者是上一个匹配的尾部。

下表中列出了所有的边界匹配器及其说明。

边界匹配器

^行首

$行尾

\b单词边界

\B非单词边界

\A输入的开头

\G上一个匹配的结尾

\Z输入的结尾，仅用于最后的结束符（如果有的话）

\z输入的结尾接下来的例子中，说明了^和$边界匹配器的用法。注意上表中，^匹配行首，$匹配行尾。

Enter your regex: ^dog$

Enter input string to search: dog

I found the text "dog" starting at index 0 and ending at index 3.

Enter your regex: ^dog$

Enter input string to search: dog

No match found.

Enter your regex: \s*dog$

Enter input string to search: dog

I found the text " dog" starting at index 0 and ending at index 15.

Enter your regex: ^dog\w*

Enter input string to search: dogblahblah

I found the text "dogblahblah" starting at index 0 and ending at index 11.

第一个例子的匹配是成功的，这是因为模式占据了整个输入的字符串。第二个例子失败了，是由于输入的字符串在开始部分包含了额外的空格。第三个例子指定的表达式是不限的空格，后跟着在行尾的 dog。第四个例子，需要 dog 放在行首，后面跟的是不限数量的单词字符。

对于检查一个单词开始和结束的边界模式（用于长字符串里子字符串），这时可以在两边使用\b，例如\bdog\b。

Enter your regex: \bdog\b

Enter input string to search: The dog plays in the yard.

I found the text "dog" starting at index 4 and ending at index 7.

Enter your regex: \bdog\b

Enter input string to search: The doggie plays in the yard.

No match found.

对于匹配非单词边界的表达式，可以使用\B来代替：

Enter your regex: \bdog\B

Enter input string to search: The dog plays in the yard.

No match found.

Enter your regex: \bdog\B

Enter input string to search: The doggie plays in the yard.

I found the text "dog" starting at index 4 and ending at index 7.

对于需要匹配仅出现在前一个匹配的结尾，可以使用\G：

Enter your regex: dog

Enter input string to search: dog dog

I found the text "dog" starting at index 0 and ending at index 3.

I found the text "dog" starting at index 4 and ending at index 7.

Enter your regex: \Gdog

Enter input string to search: dog dog

I found the text "dog" starting at index 0 and ending at index 3.

这里的第二个例子仅找到了一个匹配，这是由于第二次出现的“dog”不是在前一个匹配结尾的开始。[7]

8　Pattern 类的方法返回目录

到目前为止，仅使用测试用具来建立最基本的 Pattern 对象。在这一节中，我们将探讨一些诸如使用标志构建模式、使用内嵌标志表达式等高级的技术。同时也探讨了一些目前还没有讨论过的其他有用的方法。

8.1　使用标志构建模式返回目录

Pattern 类定义了备用的 compile 方法，用于接受影响模式匹配方式的标志集。标志参数是一个位掩码，可以是下面公共静态字段中的任意一个：

Pattern.CANON_EQ

启用规范等价。在指定此标志后，当且仅当在其完整的规范分解匹配时，两个字符被视为匹配。例如，表达式a\u030A[8]在指定此标志后，将匹配字符串“\u00E5”（即字符 å）。默认情况下，匹配不会采用规范等价。指定此标志可能会对性能会有一定的影响。

Pattern.CASE_INSENSITIVE

启用不区分大小写匹配。默认情况下，仅匹配 US-ASCII 字符集中的字符。Unicode 感知（Unicode-aware）的不区分大小写匹配，可以通过指定 UNICODE_CASE 标志连同此标志来启用。不区分大小写匹配也能通过内嵌标志表达式(?i)来启用。指定此标志可能会对性能会有一定的影响。

Pattern.COMMENTS

模式中允许存在空白和注释。在这种模式下，空白和以#开始的直到行尾的内嵌注释会被忽略。注释模式也能通过内嵌标志表达式(?x)来启用。

Pattern.DOTALL

启用 dotall 模式。在 dotall 模式下，表达式.匹配包括行结束符在内的任意字符。默认情况下，表达式不会匹配行结束符。dotall 模式也通过内嵌标志表达式(?x)来启用。［s 是“单行（single-line）”模式的助记符，与 Perl 中的相同。］

Pattern.LITERAL

启用模式的字面分析。指定该标志后，指定模式的输入字符串作为字面上的字符序列来对待。输入序列中的元字符和转义字符不具有特殊的意义了。CASE_INSENSITIVE 和 UNICODE_CASE 与此标志一起使用时，会对匹配产生一定的影响。其他的标志就变得多余了。启用字面分析没有内嵌标志表达式。

Pattern.MULTILINE

启用多行（multiline）模式。在多行模式下，表达式^和$分别匹配输入序列行结束符前面和行结束符的前面。默认情况下，表达式仅匹配整个输入序列的开始和结尾。多行模式也能通过内嵌标志表达式(?m)来启用。

Pattern.UNICODE_CASE

启用可折叠感知 Unicode（Unicode-aware case folding）大小写。在指定此标志后，需要通过 CASE_INSENSITIVE 标志来启用，不区分大小写区配将在 Unicode 标准的意义上来完成。默认情况下，不区分大小写匹配仅匹配 US-ASCII 字符集中的字符。可折叠感知 Unicode 大小写也能通过内嵌标志表达式(?u)来启用。指定此标志可能会对性能会有一定的影响。

Pattern.UNIX_LINES

启用 Unix 行模式。在这种模式下，.、^和$的行为仅识别“\n”的行结束符。Unix 行模式可以通过内嵌标志表达式(?d)来启用。

接下来，将修改测试用具 RegexTestHarness.java，用于构建不区分大小写匹配的模式。

首先，修改代码去调用 complie 的另外一个备用的方法：

Pattern pattern = Pattern.compile(

console.readLine("%nEnter your regex: "),

Pttern.CASE_INSENSITIVE

);

编译并运行这个测试用具，会得出下面的结果：

Enter your regex: dog

Enter input string to search: DoGDOg

I found the text "DoG" starting at index 0 and ending at index 3.

I found the text "DOg" starting at index 3 and ending at index 6.

正如你所看到的，不管是否大小写，字符串字面上是“dog”的都产生了匹配。使用多个标志来编译一个模式，使用按位或操作符“|”分隔各个标志。为了更清晰地说明，下面的示例代码使用硬编码（hardcode）的方式，来取代控制台中的读取：

pattern = Pattern.compile("[az]$", Pattern.MULTILINE | Pattern.UNIX_LINES);

也可以使用一个 int 类型的变量来代替：

final int flags = Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE;

Pattern pattern = Pattern.compile("aa", flags);

8.2　内嵌标志表达式返回目录

使用内嵌标志表达式（embedded flag expressions）也可以启用不同的标志。对于两个参数的 compile 方法，内嵌标志表达式是可选的，因为它在自身的正则表达式中被指定了。下面的例子使用最初的测试用具（RegexTestHarness.java），使用内嵌标志表达式(?i)来启用不区分大小写的匹配。

Enter your regex: (?i)foo

Enter input string to search: FOOfooFoOfoO

I found the text "FOO" starting at index 0 and ending at index 3.

I found the text "foo" starting at index 3 and ending at index 6.

I found the text "FoO" starting at index 6 and ending at index 9.

I found the text "foO" starting at index 9 and ending at index 12.

所有匹配无关大小写都一次次地成功了。

内嵌标志表达式所对应 Pattern 的公用的访问字段表示如下表：

常量等价的内嵌标志表达式

Pattern.CANON_EQ没有

Pattern.CASE_INSENSITIVE(?i)

Pattern.COMMENTS(?x)

Pattern.MULTILINE(?m)

Pattern.DOTALL(?s)

Pattern.LITERAL没有

Pattern.UNICODE_CASE(?u)

Pattern.UNIX_LINES(?d)

8.3　使用 matches(String, CharSequence) 方法返回目录

Pattern 类定义了一个方便的 matches 方法，用于快速地检查模式是否表示给定的输入字符串。与使用所有的公共静态方法一样，应该通过它的类名来调用 matches 方法，诸如 Pattern.matches("\\d","1");。这个例子中，方法返回 true，这是由于数字“1”匹配了正则表达式\d。

8.4　使用 split(String) 方法返回目录

split 方法是一个重要的工具，用于收集依赖于被匹配的模式任一边的文本。如下面的 SplitDemo.java 所示，split 方法能从“one:two:three:four:five”字符串中解析出“one two three four five”单词：

import java.util.regex.Pattern;

public class SplitDemo {

private static final String REGEX = ":";

private static final String INPUT = "one:two:three:four:five";

public static void main(String[] args) {

Pattern p = Pattern.compile(REGEX);

String[] items = p.split(INPUT);

for(String s : items) {

System.out.println(s);

}

输出：

one

two

three

four

five

简而言之，已经使用冒号（:）取代了复杂的正则表达式匹配字符串文字。以后仍会使用 Pattern 和 Matcher 对象，也能使用 split 得到位于任意正则表达式各边的文本。下面的 SplitDemo2.java 是个一样的例子，使用数字作为 split 的参数：

import java.util.regex.Pattern;

public class SplitDemo2 {

private static final String REGEX = "\\d";

private static final String INPUT = "one9two4three7four1five";

public static void main(String[] args) {

Pattern p = Pattern.compile(REGEX);

String[] items = p.split(INPUT);

for(String s : items) {

System.out.println(s);

}

输出：

one

two

three

four

five

8.5　其他有用的方法返回目录

你可以从下面的方法中找到比较好用的方法：

public static String quote(String s)[9]：返回指定字符串字面模式的字符串。此方法会产生一个字符串，能被用于构建一个与字符串 s 匹配的 Pattern，好像它是一个字面上的模式。输入序列中的元字符和转义序列将没有特殊的意义了。

public String toString()：返回这个模式的字符串表现形式。这是一个编译过的模式中的正则表达式。

8.6　在 java.lang.String 中等价的 Pattern 方法返回目录

java.lang.String 通过模拟 java.util.regex.Pattern 行为的几个方法，也可以支持正则表达式。方便起见，下面主要摘录了出现在 API 关键的方法。

public boolean matches(String regex)：告知字符串是否匹配给定的正则表达式。调用 str.matches(regex)方法所产生的结果与作为表达式的 Pattern.matches(regex, str)的结果是完全一致。

public String[] split(String regex, int limit)：依照匹配给定的正则表达式来拆分字符串。调用 str.split(regex, n)方法所产生的结果与作为表达式的 Pattern.compile(regex).split(str, n) 的结果完全一致。

public String[] split(String regex)：依照匹配给定的正则表达式来拆分字符串。这个方法与调用两个参数的 split 方法是相同的，第一个参数使用给定的表达式，第二个参数限制为 0。在结果数组中不包括尾部的空字符串。

还有一个替换方法，把一个 CharSequence 替换成另外一个：

public String replace(CharSequence target,CharSequence replacement)：将字符串中每一个匹配替换匹配字面目标序列的子字符串，替换成指定的字面替换序列。这个替换从字符串的开始处理直至结束，例如，把字符串“aaa”中的“aa”替换成“b”，结果是“ba”，而不是“ab”。

9　Matcher 类的方法返回目录

在这一节中来看看 Matcher 类中其他一些有用的方法。方便起见，下面列出的方法是按照功能来分组的。

索引方法

索引方法（index methods）提供了一些正好在输入字符串中发现匹配的索引值：

public int start()：返回之前匹配的开始索引。

public int start(int group)：返回之前匹配操作中通过给定组所捕获序列的开始索引。

public int end(): 返回最后匹配字符后的偏移量。

public int end(int group): 返回之前匹配操作中通过给定组所捕获序列的最后字符之后的偏移量。

研究方法

研究方法（study methods）回顾输入的字符串，并且返回一个用于指示是否找到模式的布尔值。

public boolean lookingAt(): 尝试从区域开头处开始，输入序列与该模式匹配。

public boolean find(): 尝试地寻找输入序列中，匹配模式的下一个子序列。

public boolean find(int start): 重置匹配器，然后从指定的索引处开始，尝试地寻找输入序列中，匹配模式的下一个子序列。

public boolean matches(): 尝试将整个区域与模式进行匹配

替换方法

替换方法（replacement methods）用于在输入的字符串中替换文本有用处的方法。

public Matcher appendReplacement(StringBuffer sb, String replacement)：实现非结尾处的增加和替换操作。

public StringBuffer appendTail(StringBuffer sb)：实现结尾处的增加和替换操作。

public String replaceAll(String replacement)：使用给定的替换字符串来替换输入序列中匹配模式的每一个子序列。

public String replaceFirst(String replacement)：使用给定的替换字符串来替换输入序列中匹配模式的第一个子序列。

public static String quoteReplacement(String s)：返回指定字符串的字面值来替换字符串。这个方法会生成一个字符串，用作 Matcher 的 appendReplacement 方法中的字面值替换 s。所产生的字符串将与作为字面值序列的 s 中的字符序列匹配。斜线（\）和美元符号（$）将不再有特殊意义了。

9.1　使用 start 和 end 方法返回目录

示例程序 MatcherDemo.java 用于计算输入序列中单词“dog”的出现次数。

import java.util.regex.Pattern;

import java.util.regex.Matcher;

public class MatcherDemo {

private static final String REGEX = "\\bdog\\b";

private static final String INPUT = "dog dog dog doggie dogg";

public static void main(String[] args) {

Pattern p = Pattern.compile(REGEX);

Matcher m = p.matcher(INPUT); // 获得匹配器对象

int count = 0;

while (m.find()) {

count++;

System.out.println("Match number " + count);

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

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

}

输出：

Match number 1

start(): 0

end(): 3

Match number 2

start(): 4

end(): 7

Match number 3

start(): 8

end(): 11

可以看出，这个例子使用了单词边界，用于确保更长单词中的字母“d”“o”“g”就不是子串了。它也输出了一些有用的信息，在输入的字符串中什么地方有匹配。start 方法返回在以前的匹配操作期间，由给定组所捕获子序列的开始处索引，end 方法返回匹配到最后一个字符索引加 1。

9.2　使用 matches 和 lookingAt 方法返回目录

matches 和 lookingAt 方法都是尝试该模式匹配输入序列。然而不同的是，matches 要求匹配整个输入字符串，而 lookingAt 不是这样。这两个方法都是从输入字符串的开头开始的。下面是 MatchesLooking.java 完整的代码：

import java.util.regex.Pattern;

import java.util.regex.Matcher;

public class MatchesLooking {

private static final String REGEX = "foo";

private static final String INPUT = "fooooooooooooooooo";

private static Pattern pattern;

private static Matcher matcher;

public static void main(String[] args) {

// 初始化

pattern = Pattern.compile(REGEX);

matcher = pattern.matcher(INPUT);

System.out.println("Current REGEX is: " + REGEX);

System.out.println("Current INPUT is: " + INPUT);

System.out.println("lookingAt(): " + matcher.lookingAt());

System.out.println("matches(): " + matcher.matches());

}

输出：

Current REGEX is: foo

Current INPUT is: fooooooooooooooooo

lookingAt(): true

matches(): false

9.3　使用 replaceFirst(String) 和 replaceAll(String) 方法返回目录

replaceFirst 和 replaceAll 方法替换匹配给定正则表达式的文本。从它们的名字可以看出，replaceFirst 替换第一个匹配到的，而 replaceAll 替换所有匹配的。下面是 ReplaceDemo.java 的代码：

import java.util.regex.Pattern;

import java.util.regex.Matcher;

public class ReplaceDemo {

private static String REGEX = "dog";

private static String INPUT = "The dog says meow. All dogs say meow.";

private static String REPLACE = "cat";

public static void main(String[] args) {

Pattern p = Pattern.compile(REGEX);

Matcher m = p.matcher(INPUT); // 获得匹配器对象

INPUT = m.replaceAll(REPLACE);

System.out.println(INPUT);

}

输出：

The cat says meow. All cats say meow.

在上面的例子中，所有的 dog 都被替换成了 cat。但是为什么在这里停下来了呢？你可以替换匹配任何正则表达式的文本，这样优于替换一个简单的像 dog 一样的文字。

这个方法的 API 描述了“给定正则表达式a*b，在输入‘aabfooaabfooabfoob’和替换的字符串是‘-’情况下，表达式的匹配器调用方法后，会产生成字符串‘-foo-foo-foo-’。”

下面是 ReplaceDemo2.java 的代码：

import java.util.regex.Pattern;

import java.util.regex.Matcher;

public class ReplaceDemo2 {

private static String REGEX = "a*b";

private static String INPUT = "aabfooaabfooabfoob";

private static String REPLACE = "-";

public static void main(String[] args) {

Pattern p = Pattern.compile(REGEX);

Matcher m = p.matcher(INPUT); // 获得匹配器对象

INPUT = m.replaceAll(REPLACE);

System.out.println(INPUT);

}

输出：

-foo-foo-foo-

仅要替换模式一次时，可以简单地调用 replaceFirst 用于取代 replaceAll，它接受相同的参数。

9.4　使用 appendReplacement(StringBuffer, String) 和

　 appendTail(StringBuffer) 方法返回目录

Matcher 类也提供了 appendReplacement 和 appendTail 两个方法用于文本替换。下面的这个例子（RegexDemo.java）使用了这两个方法完成与 replaceAll 相同的功能。

import java.util.regex.Pattern;

import java.util.regex.Matcher;

public class RegexDemo {

private static String REGEX = "a*b";

private static String INPUT = "aabfooaabfooabfoob";

private static String REPLACE = "-";

public static void main(String[] args) {

Pattern p = Pattern.compile(REGEX);

Matcher m = p.matcher(INPUT); // 获得匹配器对象

StringBuffer sb = new StringBuffer();

while (m.find()) {

m.appendReplacement(sb, REPLACE);

}

m.appendTail(sb);

System.out.println(sb.toString());

}

输出：

-foo-foo-foo-

9.5　在 java.lang.String 中等价的 Matcher 方法返回目录

为了使用方便，String 类看上去还不错地模仿了 Matcher 的两个方法：

public String replaceFirst(String regex, String replacement)：使用给定的替换字符串替换该字符串中匹配了给定正则表达式的第一个子字符串。调用 str.replaceFirst(regex, repl)方法与使用 Pattern.compile(regex).matcher(str).replaceFirst(repl)产生的结果是完全相同的。

public String replaceAll(String regex, String replacement)：使用给定的替换字符串替换该字符串中匹配了给定正则表达式的每一个子字符串。调用 str.replaceAll(regex, repl)方法与使用 Pattern.compile(regex).matcher(str).replaceAll(repl)产生的结果是完全相同的。

10　PatternSyntaxException 类的方法返回目录

PatternSyntaxException 是未检查异常，指示正则表达式模式中的语法错误。PatternSyntaxException 类提供了下面的一些方法，用于确定在什么地方发生了错误：

public String getDescription()：获得错误描述。

public int getIndex()：获得错误索引。

public String getPattern()：获得字符串形式的错误正则表达式。

public String getMessage()：获得一个多行的字符串，包括语法错误和错误的索引、错误的正则表达式模式，以及模式内可视化的索引指示。

下面的源代码（RegexTestHarness2.java[10]）更新了测试用具，用于检查不正确的正则表达式：

import java.io.Console;

import java.util.regex.Pattern;

import java.util.regex.Matcher;

import java.util.regex.PatternSyntaxException;

public class RegexTestHarness2 {

public static void main(String[] args){

Pattern pattern = null;

Matcher matcher = null;

Console console = System.console();

if (console == null) {

System.err.println("No console.");

System.exit(1);

}

while (true) {

try {

pattern = Pattern.compile(console.readLine("%nEnter your regex: "));

matcher = pattern.matcher(console.readLine("Enter input string to search: "));

} catch (PatternSyntaxException pse){

console.format("There is a problem with the regular expression!%n");

console.format("The pattern in question is: %s%n", pse.getPattern());

console.format("The description is: %s%n", pse.getDescription());

console.format("The message is: %s%n", pse.getMessage());

console.format("The index is: %s%n", pse.getIndex());

System.exit(0);

}

boolean found = false;

while (matcher.find()) {

console.format("I found the text \"%s\" starting at " +

"index %d and ending at index %d.%n",

matcher.group(), matcher.start(), matcher.end()

);

found = true;

}

if (!found){

console.format("No match found.%n");

}

运行该测试，输入?i)foo作为正则表达式。这是个臆想出来的错误，程序员在使用内嵌标志表达式(?i)时忘记输入左括号了。这样做会产生下面的结果：

Enter your regex: ?i)

There is a problem with the regular expression!

The pattern in question is: ?i)

The description is: Dangling meta character '?'

The message is: Dangling meta character '?' near index 0

?i)

The index is: 0

从这个输出中，可以看出在索引 0 处的元字符（?）附近有语法错误。缺少左括号是导致这个错误的最魁祸首。

11　更多的资源返回目录

现在已经结束了正则表达式的课程，你也许会发现，主要引用了 Pattern、Matcher 和 PatternSyntaxException 类的 API 文档。

构建正则表达式更详细地描述，推荐阅读 Jeffrey E.F.Friedl 的Mastering Regular Expressions[11]。

12　问题和练习返回目录

〖问题〗

1. 在 java.util.regex 包中有哪三个公共的类？描述一下它们的作用。

2. 考虑一下字符串“foo”，它的开始索引是多少？结束索引是多少？解释一下这些编号的意思。

3. 普通字符和元字符有什么不同？各给出它们的一个例子。

4. 如何把元字符表现成像普通字符那样？

5. 附有方括号的字符集称为什么？它有什么作用？

6. 这里是三个预定义的字符类：\d、\s和\w。描述一下它们各表示什么？并使用方括号的形式将它们重写。

7. 对于\d、\s和\w，写出两个简单的表达式，匹配它们相反的字符集。

8. 思考正则表达式(dog){3}，识别一下其中的两个子表达式。这个表达式会匹配什么字符串？

〖练习〗

1. 使用反向引用写一个表达式，用于匹配一个人的名字，假设这个人的 first 名字与 last 名字是相同的。

【问题答案】

1. 问：在 java.util.regex 包中有哪三个公共的类？描述一下它们的作用。

答：

编译后的 Pattern 实例表示正则表达式。

Matcher 实例是解析模式和靠着输入的字符串完成匹配操作的引擎。

PatternSyntaxException 定义一个未检查异常，指示正则表达式中的语法错误。

2. 问：考虑一下字符串“foo”，它的开始索引是多少？结束索引是多少？解释一下这些编号的意思。

答：字符串中的每一个字符位于其自身的单元格中。索引位置在两个单元格之间。字符串“foo”开始于索引 0，结束于索引 3，即便是这些字符仅占用了 0、1 和 2 号单元格。

3. 问：普通字符和元字符有什么不同？各给出它们的一个例子。

答：正则表达式中的普通字符匹配其本身。元字符是一个特殊的字符，会影响被匹配模式的方式。字母A是一个普通字符。标点符号.是一个元字符，其匹配任意的单字符。

4. 问：如何把元字符表现成像普通字符那样？

答：有两种方法：

在元字符前加上反斜线（\）；

把元字符置于\Q（开始）\E（结束）的引用表达式中。

5. 问：附有方括号的字符集称为什么？它有什么作用？

答：是一个字符类。通过方括号间的表达式，匹配指定字符类中的任意一个字符。

6. 问：这里是三个预定义的字符类：\d、\s和\w。描述一下它们各表示什么？并使用方括号的形式将它们重写。

答：\d 匹配任意数字[0-9]

\s 匹配任意空白字符[ \t\n-x0B\f\r]

\w 匹配任意单词字符[a-zA-Z_0-9]

7. 问：对于\d、\s和\w，写出两个简单的表达式，匹配它们相反的字符集。

答：\d \D [^\d]

\s \S [^\s]

\w \W [^\w]

8. 问：思考正则表达式(dog){3}，识别一下其中的两个子表达式。这个表达式会匹配什么字符串？

答：表达式由捕获组(dog)和接着的贪婪量词{3}所组成。它匹配字符串“dogdogdog”。

【练习答案】

1. 练习：使用反向引用写一个表达式，用于匹配一个人的名字，假设这个人的 first 名字与 last 名字是相同的。

解答：([A-Z][a-zA-Z]*)\s\1

注释返回目录

[1] 本文全文译自 Java Tutorial 的 Regular Expressions，标题是译者自拟的。——译者注

[2] Unix 工具，用于文件中的字符串查找，它是最早的正则表达式工具之一。——译者注

[3] 若要退出可以使用 Ctrl + C 来中断。——译者注

[4] 图中的“索引 3”指示是译者所加，原文中并没有。——译者注

[5] 这种方式在 JDK 6.0 以前版本使用需要注意，在字符类中使用这种结构是有 bug 的，不过在 JDK 6.0 中已经修正。——译者注

[6] 若\E前没有\Q时会产生 PatternSyntaxException 异常指示语法错误。——译者注

[7] 第一次匹配时仅匹配字符串的开始部分，与\A类似。（引自 Jeffrey E.F.Friedl, Mastering Regular Expressions, 3rd ed., §3.5.3.3, O'Reilly, 2006.）——译者注

[8] \u030A，即字符 å 上半部分的小圆圈（ ? ）（该字符在 IE 浏览器上无法正确显示，在 Firefox 浏览器上可以正常地显示）。——译者注

[9] JDK 5.0 新增的方法，JDK 1.4 中不能使用。——译者注

[10] JDK 1.4 和 JDK 5.0 适用的版本在所附的源代码中。适用于 JDK 1.4 的文件名为 RegexTestHarness2V4.java，JDK 1.5 的文件名为 RegexTestHarness2V5.java。——译者注

[11] 第三版是本书的最新版本。第三版的中译本《精通正则表达式》已由电子工业出版社于 2007 年 7 月出版。——译者注

译后记返回目录

带着忐忑不安的心情完成了我的第一篇译篇，但愿这个教程能让大家对 Java 中的正则表达式有更一步的认识。

虽然这是一个关于 Java 正则表达式很好的一个入门教程，但这个教程也有其不足之处，其中仅仅涉及了最为简单的正则表达式，对介绍到的有些问题并未完全展开，比如：字符类中的转义、内嵌标志表达式具体的用法等。对有些常用的表达式，如|（选择结构）也没有涉及。对于非捕获组来说，仅仅提到了内嵌标志表达式，对于诸如(?:X)、(?=X)、(?!X)、(?<=X)、(?<!X)、(?>X)等等之类的非捕获组结构完全没有涉及。正如译者在序中提到的，这篇文章只为今后学习更高级的正则表达式技术奠定良好的基础。

本文链接

bfType	说明文件的类型.（该值必需是0x4D42，也就是字符'BM'。我们不需要判断OS/2的位图标识，这么做现在来看似乎已经没有什么意义了，而且如果要支持OS/2的位图，程序将变得很繁琐。所以，在此只建议你检察'BM'标识）
bfSize	说明文件的大小，用字节为单位
bfReserved1	保留，必须设置为0
bfReserved2	保留，必须设置为0
bfOffBits	说明从文件头开始到实际的图象数据之间的字节的偏移量。这个参数是非常有用的，因为位图信息头和调色板的长度会根据不同情况而变化，所以你可以用这个偏移值迅速的从文件中读取到位数据。

bmiHeader	说明BITMAPINFOHEADER结构，其中包含了有关位图的尺寸及位格式等信息
bmiColors	说明彩色表RGBQUAD结构的阵列，其中包含索引图像的真实RGB值。

	第二个字节的值为0：行的结束。
	第二个字节的值为1：图象结束。
	第二个字节的值为2：其后的两个字节表示下一个象素从当前开始的水平和垂直位置的偏移量。

压缩数据	扩展数据
03 04	04 04 04
05 06	06 06 06 06 06
00 03 45 56 67 00	45 56 67
02 78	78 78
00 02 05 01	从当前位置右移5个位置后向下移一行
02 78	78 78
00 00	行结束
09 1E	1E 1E 1E 1E 1E 1E 1E 1E 1E
00 01	RLE编码图象结束

rgbBlue	指定蓝色强度
rgbGreen	指定绿色强度
rgbRed	指定红色强度
rgbReserved	保留，设置为0

博客园_LIFE , NOT IF ELSE

运维工程师必会的109个Linux命令

bmp/gif/jpg图象最底层原理分析

模拟火车带你游西藏

生活百态 第三版 < 持续更新>

了解 【北京中清研信息技术研究院】 朋友进来聊聊

蔡妍性感 MV性感到你流鼻血

js 获取硬件及系统信息

PHP 将汉字转成拼音的方法

神奇3D圣诞树祝广大技术人员圣诞快乐！

Java正则表达式教程

生活百态第三版 < 持续更新>

了解【北京中清研信息技术研究院】朋友进来聊聊