When you try to create a bufferpool or alter a bufferpool to a
very large size and there is not enough memory in the system
, DB2 may occupies all pagespace and overrall performance of
the system become slow and may get hang at last because no
pagespace is available. Then after you connect the database
next time, DB2 will do crash recovery and still try to
allocate memory for this big bufferpool and occupy all
pagespace again. when you specify DB2_OVERRIDE_BPF parameter
to override bufferpool size, it doesn't take effect in this
situation. This is becasue DB2_OVERRIDE_BPF only applies for
bufferpools that already exist at startup, and not to
bufferpools that are created during crash recovery or roll
forward. We will fix this problem and check DB2_OVERRIDE_BPF
registry when creating bufferpools during crash recovery or
roll forward. This problem only occurs in a 64 bit instance.

		

Local fix

				You can use db2iupdt -w 32 <INSTNAME> to update the instance to
a 32 bit instance, then you can connect to the database
succefully. After that, use db2iupdt -w 64 <INSTNAME> to update
the instance to 64 bit again. Please take a backup at this
point, so we don't have to roll forward through bufferpool
creation that fails if we need restore and roll forward
database.

		

Problem summary

				Users Affected:
All users using 64 bit instance
Problem Description:
When you try to create a bufferpool or alter a bufferpool to a
very large size and there is not enough memory in the system
, DB2 may occupies all pagespace and overrall performance
of the system become slow and may get hang at last
because no pagespace is available. Then after you connect the
database at next time, DB2 will do crash recovery and still try
to allocate
memory for this big bufferpool and occupy all pagespace again.
In this situation, when you specify DB2_OVERRIDE_BPF parameter
to override bufferpool size, it doesn't take effect in this
situation. This
is becasue DB2_OVERRIDE_BPF only applies for bufferpools that
already exist at startup, and not to bufferpools that are
created during crash recovery or roll forward. We will fix
this problem and check
DB2_OVERRIDE_BPF registry when creating bufferpools during crash
recovery or roll forward. This problem only occurs in 64 bit
instance.
Problem Summary:
This problem is caused by a misoperation, when you create or alt
er a bufferpool, the size is too large to allocated from OS and
cause overrall performance of the system is very slow and seems
hang. Another problem is that DB2_OVERRIDE_BPF registry only app
lies to bufferpools that already exists, and not bufferpools wil
l be created in crash recovery or roll forward. So DB2 will try
to create this big bufferpool again when doing crash recovery or
 roll forward. We will fix this problem and check DB2_OVERRIDE_B
PF registry in our crash recovery and roll forward code.

		

Problem conclusion

Temporary fix

				You can use db2iupdt -w 32 <INSTNAME> to update the instance to
a 32 bit instance, then you can connect to the database
succefully. After that, use db2iupdt -w 64 <INSTNAME> to update
the instance to 64 bit again. Please take a backup at this
point, so we don't have to roll forward through bufferpool
creation that fails if we need restore and roll
forward database.Please also notice that be careful when creati
ng bufferpool, don't specify a too large value.

		

采用用户出口程序与DB2 UDB共同工作背后的基本思想是提供一种归档和检索数据库日志文件的方法以实现日志冗余处理并从易失性介质上转储出来。重要的，值得注意的是，根据你的特殊需求，在用户出口程序当中，除了能实现归档和检索日志之外，你还可以实现其他的操作。

如果一个数据库需要采用归档日志文件来进行恢复，在DB2 UDB中实行用户出口程序策略将不能恢复100%的事务。用户出口程序只是一种通过拷贝已经存在的日志文件到一个安全的地方来为其提供更多保护的方法。它是数据完整性策略中的一部分，而且是重要的一部分。

编译了用户出口程序之后，可执行程序db2uext2被放置在数据库管理器可以找到的目录当中。在UNIX©中，这个目录是/sqllib/adm；在Windows©中，是Program FilesIBMSQLLIBBIN。

除非数据库管理器知道用户出口程序是可用的，不然它不会调用db2uext2。让数据库管理器知道db2uext2可以被调用的唯一方法是将数据库配置参数userexit设置为on。一旦这个参数被设定好而且DB2实例被重复利用了，数据库管理器将每五分钟调用一次用户出口程序来检查那些可以被归档到程序相关的归档目录的日志文件。

如果数据库的恢复是必要的，在前滚操作期间，数据库管理器将调用db2uext2把归档日志文件拷贝回活动的日志目录当中。然后，日志文件被再次运用到重建的数据库中。

让我们看看被数据库管理器生成的到用户出口程序的调用的格式。注意，这一信息也可以在用户出口示例程序的注释部分找到。

db2uext2 -OS -RL

-RQ -DB -NN

-LP -LN [-AP]

其中：

os=操作系统

release=DB2发行版本

request= 'ARCHIVE' 或 'RETRIEVE'

dbname=数据库名

nodenumber=节点号

logpath=日志文件目录

logname=日志文件名

logsize=日志文件大小（可选）

startingpage=以4k页为单位的起始偏移量（可选）

adsmpasswd=ADSM密码（可选）

注意：只有当logpath为裸设备时才使用logsize和startingpage。

归档或者从磁盘检索日志文件遵从以下命名规则：

归档：归档路径＋数据库名＋节点号＋日志文件名

检索：检索路径＋数据库名＋节点号＋日志文件名

比如：如果归档的路径为”c:mylogs”,

检索路径是“c:mylogs”，

数据库名是“SAMPLE”，

节点号是 NODE0000，

文件名是 S0000001.LOG，

日志文件将是：

归档到 - c:mylogsSAMPLENODE0000S0000001.LOG

检索自 - c:mylogsSAMPLENODE0000S0000001.LOG

以下描述了用户出口程序中的逻辑是如何运转的：

1)  安装信号处理程序。

2)  验证传递的参数个数。

3)  验证操作请求。

4)  开始审计跟踪（如果有此请求）。

5)  根据操作需求的不同获取以下路径中的一个：

a)  如果操作需求为归档一个文件，将日志文件从日志路径拷贝到归档路径中。

i） 如果没有找到日志文件，执行第6点。

b)  如果操作需求是检索一个文件，将日志文件从检索路径拷贝到日志路径中。

i） 如果没有找到日志文件，执行第6点。

6) 将错误记入日志（如果要求或者有需要的话）。

7)  结束审计跟踪（如果有请求）。

8)  以适当的返回码退出。

手工调用用户出口程序来归档日志文件是可以的，但最好还是使用ARCHIVE LOG命令以便在定义以上参数时不会因为你的原因导致错误。在这篇文章的末尾，可以找到关于ARCHIVE LOG命令的链接。

日志文件术语

DB2 中用户出口程序的基本功能是将日志文件拷贝到活动日志目录或反之。这里，值得指出一些术语来阐明活动的日志目录被置于何处以及数据库日志文件的状态如何。

活动日志目录：

该目录被置于你的数据库目录中。在Windows中，如果在C:中创建了一个叫做SAMPLE的单一数据库且实例名为db2inst1，则将会出现以下的目录结构：

C:DB2INST1NODE0000SQL000001SQLOGDIR

SQL00001是SAMPLE数据库的数据库目录，SQLOGDIR 是活动日志目录。

以下的图1显示了Windows操作系统上的活动日志目录：

PATH o:extrusionok="f" gradientshapeok="t" o:connecttype="rect" />SHAPE id=_x0000_i1025 style="WIDTH: 299.25pt; HEIGHT: 180.75pt" type="#_x0000_t75" />/P>

图 1活动日志目录

日志文件状态

在活动日志目录中，日志文件可以是活动日志，也可以是联机归档日志。活动日志是那些被 DB2 用于当前事务处理和崩溃恢复的日志。联机归档日志是那些 DB2 UDB 进行常规处理时不再需要，而进行数据库恢复时可能还会需要的日志。当实现用户出口程序时，这些联机归档日志将最终以归档日志目录中的副本形式出现。

既然 DB2 UDB 中用户出口程序的目的是将数据库日志拷贝到归档目录中，你将最终在活动日志目录（缺省为 SQLOGDIR）中得到重复的日志文件。你可能考虑删除这些重复的联机归档日志以释放文件系统空间。在从数据库目录中除去这些日志之前，要十分小心地确认它们是否已经将成功地被复制到归档目录中。还必须确保数据库管理器进行崩溃恢复时不再需要它们。要确定你的活动日志目录中哪些日志文件不为正常处理所需要，可用通过以下命令检查数据库配置：

     db2 "get db cfg for sample"

这条命令的数据库配置输出结果将包含第一个活动日志文件，如：

First active log file = S000009.LOG

在如上所示的输出当中，日志文件S000009.LOG是数据库当前的活动日志。任何编号比该日志文件小的日志文件都被看作联机归档日志。

这里有一个例子：

在这个场景中，活动日志目录中有日志文件 S000000.LOG - S000009.LOG，归档日志目录中有 S000000.LOG - S000008.LOG。因为 S000009.LOG 是第一个活动日志文件，所以，可以从活动日志目录中移走 S000001.LOG - S000008.LOG 以释放磁盘空间。S000009.LOG 文件必须保留在活动日志目录中，因为它仍然被当前事务使用。

同样可以通过检查数据库历史文件来查看活动日志目录中哪些日志文件不再有用。以下命令将列出数据库备份信息：

     db2 "list history backup all for database sample"

以下是该命令的输出结果的一个例子：

List History File for sample

Number of matching file entries = 4

Op Obj Timestamp+Sequence Type Dev Earliest Log Current  Log

-- --- ------------------ ---- --- ------------------------

B D 20030416162026001 F D S0000010.LOGS0000014.LOG

------------------------------------------------------------

Contains 2 tablespace(s):

00001 SYSCATSPACE

00002 USERSPACE1

------------------------------------------------------------

在上面的输出中，最早的日志将表示，需要 S0000010.LOG 及其之后的任何日志。 S00000010.LOG 之前的任何日志可以被安全的删除。再次提醒，在从活动日志目录中删除日志文件之前，验证在活动日志目录中存在这些日志文件的拷贝是十分重要的。

虽然可以手动的从活动日志目录中删除日志文件，删除联机归档日志文件的安全方法是通过prune logfile命令。该命令可以用来删除活动归档目录中的日志文件。在下面的示例中，以下命令将删除日志文件 S000000.LOG - S000008.LOG：

     db2 "prune logfile prior to S000009.LOG"

注意：根据您的恢复策略，可能会出现之前的前滚操作在数据库上执行的场景。归档目录中的老日志文件可能被同名的新日志文件所覆盖，从而阻止你使用旧日志文件对数据库进行时间点恢复。对用户出口程序的设计程序员来说，考虑类似这样的情况是很重要的。

设置用户出口

在本文中，我们将采用DB2提供的db2uext2.cdisk样例c程序，它位于你的c目录当中。在UNIX中，c目录位于/sqllib/samples。Windows中，这目录位于Program Files/IBM//samples。

在Windows中设置用户出口

修改和编译用户出口程序

1.  创建名为C:mylogs的目录

2.  将C:Program filesIBMSQLLIBsamplescdb2uext2.cdisk拷贝到一个工作目录当中

3.  对于本示例，用户出口程序的以下部分应该得以验证以反映路径 c:\mylogs\

#define ARCHIVE_PATH "c:\mylogs\"

#define RETRIEVE_PATH "c:\mylogs\"

#define AUDIT_ACTIVE 1 /* enable audit trail logging */

#define ERROR_ACTIVE 1 /* enable error trail logging */

#define AUDIT_ERROR_PATH "c:\mylogs\"

                 /* path must end with a slash */

#define AUDIT_ERROR_ATTR "a" /* append to text file */

#define BUFFER_SIZE 32

    /* # of 4K pages for output buffer */

4.  确定在你的系统中安装了被支持的C编译器（比如，Microsoft Visual Studio）而且环境中有该编译器的路径。

5.  通过命令行，将db2uext2.cdisk更名为db2uext2.c并构建：

cl db2uext2.c

一旦程序被编译，将创建db2uext2.exe和db2uext2.obj文件。

6.  将可执行文件db2uext2.exe放到/SQLLIB/BIN目录当中从而使数据库管理器能够定位并执行它用以归档和检索日志。

为用户出口创建并准备数据库

7.  在 DB2 命令窗口中用 db2sampl 命令创建 SAMPLE 数据库。这将使你对下面的示例使用样本表。

db2sampl

8.  更新数据库配置文件以便为数据库打开用户出口。请注意：只能为一个数据库分配用户出口程序，因为 bin 目录被所有 DB2 实例共享。

db2 "update db cfg for sample using userexit on"

db2stop force

<span lang="EN-US" style="FONT-SIZE: 10pt; COLOR: black; FONT-FAMILY: 宋体; mso-hansi-font-family: 'Times New Roman'; mso-bidi-font-family: 宋体; mso-

（请注意：键入该命令时必须使其成为一行。此处用多行来显示，主要是为了可读性。）如下图：


该命令将在  C  盘的 “mykeystore” 目录中创建名为 “weblogic.jks” 的密钥仓库，并赋予它口令 “ 123456 ” 。它将为实体生成公钥 / 私钥对，该实体的 “ 特征名 ” 为：常用名 “hyq” 、组织 “eagle” 和两个字母的国家代码 “cn” 。“ -keyalg ”指定它使用的是那种密钥生成算法来创建密钥，缺省的是 “DSA” 密钥生成算法（会使用缺省的 “ 带  DSA  的  SHA1” 签名算法），两个密钥（公钥与私钥）的长度是 512 位，由 -keysize 来指定，默认的是 1024  位。   该证书包括公钥和特征名信息。该证书的有效期为 365 天，由 -validity 来指定，且与别名 “business” 所代表的密钥仓库项关联。私钥被赋予口令 “ 123456 ” 。

命令行里 DName 信息注解

如果采用选项的缺省值，可以大大缩短该命令。实际上，这些选项并不是必需的；对于有缺省值的选项，未指定时将使用缺省值，对于任何被要求的值，您将会得到要求输入它的提示。例如：输入命令 keytool -genkey -keystore "C:/tone.jks" -storepass 123456 -keyalg RSA ，就会有如下提示：

注意：这里的 密钥仓库路径一定要存在，如果不存在的话，它就会抛如下的异常

第二步 : 产生证书请求certreq.pem 文件

使用如下命令：

keytool -certreq -alias weblogic -sigalg "MD5withRSA" -file C:/mykeystore/certreq.pem -keypass 123456 -keystore C:/mykeystore/weblogic.jks -storepass 123456

这样在 C:/mykeystore/ 目录下 就会产生一个 certreq.pem 文件，内容如下：

-----BEGIN NEW CERTIFICATE REQUEST-----

MIHlMIGQAgEAMCsxCzAJBgNVBAYTAmNuMQ4wDAYDVQQKEwVlYWdsZTEMMAoGA1UEAxMDaHlxMFww

DQYJKoZIhvcNAQEBBQADSwAwSAJBAMhaIG2Ki7+RwZUP4gPBdTbnY38bisW16u1XUyysPxdNwSie

aSd6E3Hm277E7NjHoz56ZoaYdPPDmdiTkMrS9rcCAwEAAaAAMA0GCSqGSIb3DQEBBAUAA0EAYRNl

l5dyGgV9hhu++ypcJNQTrDIwjx1QT4fgVubrtIaHU0fzHamD5QG6PYddw9TL51XQHvu6tOS0NUc/

ItNKJw==

-----END NEW CERTIFICATE REQUEST-----

第三步：这就相对来说简单多了，就是向CA提交证书请求。
    你可以随便从网上找一家免费的CA认证适用机构（很多的），然后按照上面的提示进行操作就可以了，这一步就要用到前面生成的certreq.pem 文件了。（注意：一定要下载根证书）
    将生成的证书和下载的根证书放至你比较容易找到的位置，我一般将它们和生成的jks文件放到一起。

第四步：导入证书
    通过命令：keytool -import -alias RootCA -trustcacerts -file C:/mykeystore/RootCADemo.cer -keystore C:/mykeystore/weblogic.jks -storepass 123456将根证书导入第一步生成的weblogic.jks中，接着将所有其它的证书按照此命令全部导入。（注意证书的别名不能重复，同时一定注意要用上 -trustcacerts，否则，你在以后使用时，它将会认为你导入的这些证书是不可信任的 ，就会导致你在配置SSL时不能正常的工作。）
    这就全部完成了密钥仓库的创建。然后就可以在支持这些证书格式的服务器上使用了。下一篇将会写一下在weblogic上如何配置双向SSL

锁：

DB2 UDB中， 锁的主要作用对象是表和行， 其他如表空间和索引也是锁的对象， 但是因为其多为系统控制， 管理员和用户使用较少，在这里就不涉及了。

对于行级锁和表级锁， 它们的区别不言而喻， 主要是锁的对象不同。 当然锁对象的不同连带也会影响DB2的并发能力。

DB2中的表级锁主要有以下几种：

1． IS锁： 此锁作用于整个表，表示拥有此锁的应用连接要读取表中的某些数据， 但是在此应用连接读取具体的数据时， 还必须获得该行的行级锁；

2． IX锁： 此锁作用于整个表，表示拥有此锁的应用连接需要独占使用表中的某些数据， 但是在此应用连接独占使用具体的数据时， 还必须获得该行上相应的行级锁；

3． SIX锁： 此锁是锁转换的产物，表示应用连接拥有S和IX锁的特性；

4． S锁： 此锁作用于整个表， 拥有此锁的应用连接可以读取表中的任何纪录；

5． U锁： 此锁作用于整个表， 拥有此锁的应用连接可以读取表中的任何纪录，也可以更新表中的纪录， 但是更新时需要再获得X锁； 此锁主要在“select … with update”语句建立的可更新游标中起作用， 其他的应用可以读取表中的纪录， 但是不能更新它；

6． X锁： 此锁作用于整个表， 拥有此锁的应用连接独占的使用表中的任何纪录；可以进行更新或其他操作；

7． Z锁： 此锁作用于整个表， 也称超级独占锁，主要是在象修改表的定义、 删除表这一类的语句中会使用。 拥有此锁的应用连接对该表有完全的控制权。 其他的任何应用不能读取或更新表中的任何纪录。

在这里我们主要要看一下 IS/IX/SIX这三个锁。 在这三个锁中IS/IX本身并不具备使得应用连接可以读取或更新纪录的能力，应用连接要读取和更新纪录时， 需要再得到相应的行级锁； 反之亦然， 任何应用要获得行级锁操作数据记录之前， 也必须获得某个相应的表级锁。 SIX锁也是类似的情况。这就是为什麽在很多情况下我们使用的是行级锁， 但是用快照（SNAPSHOT）等工具却能够看到有表级锁存在的原因。

那麽DB2中又有哪些行级锁呢？ 让我们来看下面的这张图：

此图中列出了DB2中包含的行级锁。 表中的第三列指出， 要获得此行级锁之前， 需要预先获得的表级锁， 这里列出的是最低要求。

这六个行级锁的主要功能如下：

1． S锁：此行级锁的拥有者可以读取该行的信息；

2． U锁：此行级锁的拥有者可以读取该行的信息，如果要更新该行，则仍然需要一个行级的X锁；其他的应用只能读取该行的信息；此锁主要是用于FOR UPDATE的游标。

3． X锁：此行级锁的拥有者可以更新该行的纪录，其他的应用不能连接此行的信息；

4． W锁：此锁和X锁类似，不同之处是此锁和NW锁兼容；

5． NS锁：类似于S锁，用于Next Key；

6． NW锁：类似于W锁，用于Next Key；

在DB2数据库中， 是通过行级锁和表级锁协调作用来提供较好的并发性， 同时保证数据库中数据的安全。 在DB2中缺省情况下使用行级锁（当然需要IS/IX锁配合），只有当出现锁资源不足， 或者是用命令指定使用表级锁的情况下， 才会在应用连接中使用表级锁。 对锁资源分配有兴趣的读者可以参考DB2的管理手册， 查找其中关于locklist和maxlocks参数的论述。对于用命令指定表级锁的情况， 可以参考DB2的命令手册中的lock table命令， 此命令用于直接锁表。

隔离级别：

下面让我们来看一下隔离级别。 隔离级别主要用于控制在DB2根据应用提交的SQL语句向DB2数据库中的相应对象加锁时， 会锁住哪些纪录， 也就是锁定的范围。 隔离级别的不同， 锁定的纪录的范围可能会有很大的差别。

隔离级别分为RR/RS/CS/UR这四个级别。 下面让我们来逐一论述：

1． RR隔离级别： 在此隔离级别下， DB2会锁住所有相关的纪录。 在一个SQL语句执行期间， 所有执行此语句扫描过的纪录都会被加上相应的锁。 具体的锁的类型还是由操作的类型来决定， 如果是读取，则加共享锁； 如果是更新， 则加独占锁。 由于会锁定所有为获得SQL语句的结果而扫描的纪录， 所以锁的数量可能会很庞大， 这个时候， 索引的增加可能会对SQL语句的执行有很大的影响，因为索引会影响SQL语句扫描的纪录数量。

2． RS隔离级别： 此隔离级别的要求比RR隔离级别稍弱，此隔离级别下会锁定所有符合条件的纪录。 不论是读取， 还是更新， 如果SQL语句中包含查询条件， 则会对所有符合条件的纪录加相应的锁。 如果没有条件语句， 也就是对表中的所有记录进行处理，则会对所有的纪录加锁。

3． CS隔离级别： 此隔离级别仅锁住当前处理的纪录。

4． UR隔离级别：此隔离级别下，如果是读取操作，不会出现任何的行级锁。对于非只读的操作，它的锁处理和CS相同。

在这四种隔离级别中， CS是缺省值。 这四种隔离级别均可以保证DB2数据库在并发的环境下不会有数据丢失的情况发生。 要注意的是如果对纪录进行了修改，需要在相应的纪录上加独占类型的锁， 这些独占类型的锁直到交易结束时才会被释放， 这一点在四种隔离级别下都是相同的。

REORG TABLE 语句压缩与指定的表相关联的数据。

调用

此语句可以在使用 DB2 CLI 函数的应用程序中使用，也可以通过 CLP 发出。

语法

>>-REORG TABLE--table-name--+------------+---------------------><
                            '-int1--int2-'
 
 

描述

REORG TABLE table-name

标识重组操作的表。名称必须标识现有的表。

int1

需要恢复的字节的可选最小百分比。

int2

需要为将要执行的表压缩恢复的最小字节数。

规则

• 可选的值 int1 和 int2 必须一起使用，或全都不用。
• 可选的值 int1 必须是非负数。
• 可选的值 int1 必须介于 0 与 100 之间。

注意事项

• DB2 Everyplace 可以以内部方式调用表重组。
• 第一个可选参数是表必须包含的不可用的字节的百分比（即百分之十（10）意味“至少百分之十的空间不可用”。）第二个可选参数是表必须包含的不可用的字节数（即 1000 将意味“至少 1000 个字节必须是不可用的空间”。）必须符合两个条件，才可以进行表的实际重组。
• 如果没有指定参数，DB2 Everyplace 对这此选项使用缺省值。缺省百分比是 30 且缺省字节是 6144。因此，“reorg table t1”与“reorg table t1 30 6144”相同。
• 如果重组方式设置为已启用，则 DB2 Everyplace 将自动重组表。如果在 DELETE 或 UPDATE 上启用了重组，则在执行语句之后，会对目标表执行“reorg table table_name 50 30270”。如果在 DROP TABLE 上启用了重组，则在删除表处理结束时执行“reorg table DB2eSYSTABLES 30 10240”（对于 DB2eSYSCOLUMNS 和 DB2eSYSRELS 也是如此）。
• 在 C/C++ 程序中，通过使用具有属性 SQL_ATTR_REORG_MODE 的 CLI/ODBC 函数 SQLSetStmtAttr 设置重组方式。在 JAVA 程序中，通过 DB2eStatement 接口 enableReorg 方法设置重组方式。缺省值是启用重组。
• 重组表时，通过物理上回收删除和更新创建的不可用空间来压缩包含表的数据文件。然后将表的索引更新为指向行的新物理位置。
• 可以重组“DB2 Everyplace 系统目录”基本表。
• 在执行 REORG TABLE 语句时，数据库中不应发生任何其它活动。

示例

使用缺省值压缩 VNNURSE 表。

REORG TABLE VNNURSE 

J***A正则表达式

//: c12:TestRegularExpression.java// Allows you to easly try out regular expressions.// {Args: abcabcabcdefabc "abc+" "(abc)+" "(abc){2,}" }import java.util.regex.*;
publicclass TestRegularExpression {
  publicstaticvoid main(String[] args) {
    if(args.length < 2) {
      System.out.println("Usage:\n" +
        "java TestRegularExpression " +
        "characterSequence regularExpression+");
      System.exit(0);
    }
    System.out.println("Input: \"" + args[0] + "\"");
    for(int i = 1; i < args.length; i++) {
      System.out.println(
        "Regular expression: \"" + args[i] + "\"");
      Pattern p = Pattern.compile(args[i]);
      Matcher m = p.matcher(args[0]);
      while(m.find()) {
        System.out.println("Match \"" + m.group() +
          "\" at positions " +
          m.start() + "-" + (m.end() - 1));
      }
    }
  }
} ///:~

//: c12:FindDemo.javaimport java.util.regex.*;
import com.bruceeckel.simpletest.*;
import java.util.*;
publicclass FindDemo {
  privatestatic Test monitor = new Test();
  publicstaticvoid main(String[] args) {
    Matcher m = Pattern.compile("\\w+")
      .matcher("Evening is full of the linnet's wings");
    while(m.find())
      System.out.println(m.group());
    int i = 0;
    while(m.find(i)) {
      System.out.print(m.group() + " ");
      i++;
    }
    monitor.expect(new String[] {
      "Evening",
      "is",
      "full",
      "of",
      "the",
      "linnet",
      "s",
      "wings",
      "Evening vening ening ning ing ng g is is s full " +
      "full ull ll l of of f the the he e linnet linnet " +
      "innet nnet net et t s s wings wings ings ngs gs s "
    });
  }
} ///:~

//: c12:Groups.javaimport java.util.regex.*;
import com.bruceeckel.simpletest.*;
publicclass Groups {
  privatestatic Test monitor = new Test();
  staticpublicfinal String poem =
    "Twas brillig, and the slithy toves\n" +
    "Did gyre and gimble in the wabe.\n" +
    "All mimsy were the borogoves,\n" +
    "And the mome raths outgrabe.\n\n" +
    "Beware the Jabberwock, my son,\n" +
    "The jaws that bite, the claws that catch.\n" +
    "Beware the Jubjub bird, and shun\n" +
    "The frumious Bandersnatch.";
  publicstaticvoid main(String[] args) {
    Matcher m =
      Pattern.compile("(?m)(\\S+)\\s+((\\S+)\\s+(\\S+))$")
        .matcher(poem);
    while(m.find()) {
      for(int j = 0; j <= m.groupCount(); j++)
        System.out.print("[" + m.group(j) + "]");
      System.out.println();
    }
    monitor.expect(new String[]{
      "[the slithy toves]" +
      "[the][slithy toves][slithy][toves]",
      "[in the wabe.][in][the wabe.][the][wabe.]",
      "[were the borogoves,]" +
      "[were][the borogoves,][the][borogoves,]",
      "[mome raths outgrabe.]" +
      "[mome][raths outgrabe.][raths][outgrabe.]",
      "[Jabberwock, my son,]" +
      "[Jabberwock,][my son,][my][son,]",
      "[claws that catch.]" +
      "[claws][that catch.][that][catch.]",
      "[bird, and shun][bird,][and shun][and][shun]",
      "[The frumious Bandersnatch.][The]" +
      "[frumious Bandersnatch.][frumious][Bandersnatch.]"
    });
  }
} ///:~

//: c12:StartEnd.javaimport java.util.regex.*;
import com.bruceeckel.simpletest.*;
publicclass StartEnd {
  privatestatic Test monitor = new Test();
  publicstaticvoid main(String[] args) {
    String[] input = new String[] {
      "Java has regular expressions in 1.4",
      "regular expressions now expressing in Java",
      "Java represses oracular expressions"
    };
    Pattern
      p1 = Pattern.compile("re\\w*"),
      p2 = Pattern.compile("Java.*");
    for(int i = 0; i < input.length; i++) {
      System.out.println("input " + i + ": " + input[i]);
      Matcher
        m1 = p1.matcher(input[i]),
        m2 = p2.matcher(input[i]);
      while(m1.find())
        System.out.println("m1.find() '" + m1.group() +
          "' start = "+ m1.start() + " end = " + m1.end());
      while(m2.find())
        System.out.println("m2.find() '" + m2.group() +
          "' start = "+ m2.start() + " end = " + m2.end());
      if(m1.lookingAt()) // No reset() necessary
        System.out.println("m1.lookingAt() start = "
          + m1.start() + " end = " + m1.end());
      if(m2.lookingAt())
        System.out.println("m2.lookingAt() start = "
          + m2.start() + " end = " + m2.end());
      if(m1.matches()) // No reset() necessary
        System.out.println("m1.matches() start = "
          + m1.start() + " end = " + m1.end());
      if(m2.matches())
        System.out.println("m2.matches() start = "
          + m2.start() + " end = " + m2.end());
    }
    monitor.expect(new String[] {
      "input 0: Java has regular expressions in 1.4",
      "m1.find() 'regular' start = 9 end = 16",
      "m1.find() 'ressions' start = 20 end = 28",
      "m2.find() 'Java has regular expressions in 1.4'" +
      " start = 0 end = 35",
      "m2.lookingAt() start = 0 end = 35",
      "m2.matches() start = 0 end = 35",
      "input 1: regular expressions now " +
      "expressing in Java",
      "m1.find() 'regular' start = 0 end = 7",
      "m1.find() 'ressions' start = 11 end = 19",
      "m1.find() 'ressing' start = 27 end = 34",
      "m2.find() 'Java' start = 38 end = 42",
      "m1.lookingAt() start = 0 end = 7",
      "input 2: Java represses oracular expressions",
      "m1.find() 'represses' start = 5 end = 14",
      "m1.find() 'ressions' start = 27 end = 35",
      "m2.find() 'Java represses oracular expressions' " +
      "start = 0 end = 35",
      "m2.lookingAt() start = 0 end = 35",
      "m2.matches() start = 0 end = 35"
    });
  }
} ///:~

//: c12:ReFlags.javaimport java.util.regex.*;
import com.bruceeckel.simpletest.*;
publicclass ReFlags {
  privatestatic Test monitor = new Test();
  publicstaticvoid main(String[] args) {
    Pattern p =  Pattern.compile("^java",
      Pattern.CASE_INSENSITIVE | Pattern.MULTILINE);
    Matcher m = p.matcher(
      "java has regex\nJava has regex\n" +
      "J***A has pretty good regular expressions\n" +
      "Regular expressions are in Java");
    while(m.find())
      System.out.println(m.group());
    monitor.expect(new String[] {
      "java",
      "Java",
      "J***A"
    });
  }
} ///:~

//: c12:SplitDemo.javaimport java.util.regex.*;
import com.bruceeckel.simpletest.*;
import java.util.*;
publicclass SplitDemo {
  privatestatic Test monitor = new Test();
  publicstaticvoid main(String[] args) {
    String input =
      "This!!unusual use!!of exclamation!!points";
    System.out.println(Arrays.asList(
      Pattern.compile("!!").split(input)));
    // Only do the first three:
    System.out.println(Arrays.asList(
      Pattern.compile("!!").split(input, 3)));
    System.out.println(Arrays.asList(
      "Aha! String has a split() built in!".split(" ")));
    monitor.expect(new String[] {
      "[This, unusual use, of exclamation, points]",
      "[This, unusual use, of exclamation!!points]",
      "[Aha!, String, has, a, split(), built, in!]"
    });
  }
} ///:~

//: c12:TheReplacements.javaimport java.util.regex.*;
import java.io.*;
import com.bruceeckel.util.*;
import com.bruceeckel.simpletest.*;
/*! Here's a block of text to use as input to
    the regular expression matcher. Note that we'll
    first extract the block of text by looking for
    the special delimiters, then process the
    extracted block. !*/publicclass TheReplacements {
  privatestatic Test monitor = new Test();
  publicstaticvoid main(String[] args) throws Exception {
    String s = TextFile.read("TheReplacements.java");
    // Match the specially-commented block of text above:
    Matcher mInput =
      Pattern.compile("/\\*!(.*)!\\*/", Pattern.DOTALL)
        .matcher(s);
    if(mInput.find())
      s = mInput.group(1); // Captured by parentheses// Replace two or more spaces with a single space:
    s = s.replaceAll(" {2,}", " ");
    // Replace one or more spaces at the beginning of each// line with no spaces. Must enable MULTILINE mode:
    s = s.replaceAll("(?m)^ +", "");
    System.out.println(s);
    s = s.replaceFirst("[aeiou]", "(VOWEL1)");
    StringBuffer sbuf = new StringBuffer();
    Pattern p = Pattern.compile("[aeiou]");
    Matcher m = p.matcher(s);
    // Process the find information as you// perform the replacements:while(m.find())
      m.appendReplacement(sbuf, m.group().toUpperCase());
    // Put in the remainder of the text:
    m.appendTail(sbuf);
    System.out.println(sbuf);
    monitor.expect(new String[]{
      "Here's a block of text to use as input to",
      "the regular expression matcher. Note that we'll",
      "first extract the block of text by looking for",
      "the special delimiters, then process the",
      "extracted block. ",
      "H(VOWEL1)rE's A blOck Of tExt tO UsE As InpUt tO",
      "thE rEgUlAr ExprEssIOn mAtchEr. NOtE thAt wE'll",
      "fIrst ExtrAct thE blOck Of tExt by lOOkIng fOr",
      "thE spEcIAl dElImItErs, thEn prOcEss thE",
      "ExtrActEd blOck. "
    });
  }
} ///:~

//: c12:Resetting.javaimport java.util.regex.*;
import java.io.*;
import com.bruceeckel.simpletest.*;
publicclass Resetting {
  privatestatic Test monitor = new Test();
  publicstaticvoid main(String[] args) throws Exception {
    Matcher m = Pattern.compile("[frb][aiu][gx]")
      .matcher("fix the rug with bags");
    while(m.find())
      System.out.println(m.group());
    m.reset("fix the rig with rags");
    while(m.find())
      System.out.println(m.group());
    monitor.expect(new String[]{
      "fix",
      "rug",
      "bag",
      "fix",
      "rig",
      "rag"
    });
  }
} ///:~

//: c12:JGrep.java// A very simple version of the "grep" program.// {Args: JGrep.java "\\b[Ssct]\\w+"}import java.io.*;
import java.util.regex.*;
import java.util.*;
import com.bruceeckel.util.*;
publicclass JGrep {
  publicstaticvoid main(String[] args) throws Exception {
    if(args.length < 2) {
      System.out.println("Usage: java JGrep file regex");
      System.exit(0);
    }
    Pattern p = Pattern.compile(args[1]);
    // Iterate through the lines of the input file:
    ListIterator it = new TextFile(args[0]).listIterator();
    while(it.hasNext()) {
      Matcher m = p.matcher((String)it.next());
      while(m.find())
        System.out.println(it.nextIndex() + ": " +
          m.group() + ": " + m.start());
    }
  }
} ///:~

//: c12:ReplacingStringTokenizer.javaimport java.util.regex.*;
import com.bruceeckel.simpletest.*;
import java.util.*;
publicclass ReplacingStringTokenizer {
  privatestatic Test monitor = new Test();
  publicstaticvoid main(String[] args) {
    String input = "But I'm not dead yet! I feel happy!";
    StringTokenizer stoke = new StringTokenizer(input);
    while(stoke.hasMoreElements())
      System.out.println(stoke.nextToken());
    System.out.println(Arrays.asList(input.split(" ")));
    monitor.expect(new String[] {
      "But",
      "I'm",
      "not",
      "dead",
      "yet!",
      "I",
      "feel",
      "happy!",
      "[But, I'm, not, dead, yet!, I, feel, happy!]"
    });
  }
} ///:~