博客园_JOY 技术专题

vim 技巧集

2011-12-21T09:26:00Z

这些是我在学校的时候，为linux协会准备的一些资料。当时，把vim的文档全部看了一遍，从中挑选出自己觉得很有用的整理成了。做成handbook形式，便于查看。
vi技巧集
技巧1:关于帮助的帮助
查找帮助: 键入 ":help word", 接着键入 CTRL-D 可以看到匹配"word" 的帮助主题.
类别前缀例子
普通模式命令 (无) :help x
Visual 模式命令 v_ :help v_u
插入模式命令 i_ :help i_
命令行模式命令 : :help :quit
命令行编辑 c_ :help c_
Vim 命令参数 - :help -r
选项 ' :help 'textwidth'
技巧2:vi初学者30分钟教程
键入：vimtutor [语言]
语言参数可以是:fr it等，rh9有繁体的教程，暂时没有简体中文教程。
技巧3：确定你的位置
方法1：使用命令。此命令显示vi状态信息，包括正在编辑的文件名、是否修改过、当前行号、文件的行数以及光标之前的行占整个文件的百分比。有时你会看到一个“裂开”的列号，是由于使用了Tab字符。
方法2：设置'number'选项。
在每行的前面加上一个行号：“:set number”;
要重新关闭这个选项：“:set nonumber”。
方法3：设置'ruler'选项。这会在Vim窗口的右下角显示当前光标的位置：
:set ruler
技巧4: 中止命令
比如：输入”f“后发现应该是“F”，就可以用来中止f命令。
技巧5: 让最后一行处于屏幕的中间
当到达了最后一行的时候，光标会行处于屏幕的底部。
“zz”命令能让最后一行显示在屏幕中间；
“zt”把光标所在行移动到屏幕的顶部；
“zb”则移动到屏幕的底部。
技巧6: 显示标记
你可以用如下命令取得所有的标记的列表：“ :marks”
用这个命令后，你会发现有一下特殊的标记，包括：
' 跳转前的位置
" 最后编辑的位置
[ 最后修改的位置的开头
] 最后修改的位置的结尾
技巧7: 操作符与动作
你可以使用“dw”命令来删除一个单词，它是命令“d”+动作“w”。还可以加上数字，如“d4w”或者“4dw”来删除4个单词。
类似的常用命令有：
x 表示 dl （删除当前光标下的字符）
X 表示 dh （删除光标左边的字符）
D 表示 d$ （删除到行尾）
C 表示 c$ （修改到行尾）
s 表示 cl （修改一个字符）
S 表示 cc （修改一整行）
技巧8: 替换单个字符
“rx”命令，使用x替换当前字符，x可以是任意字符，键也可以；
“nrx”命令，可以用一个字符替换多个字符，如"4ra";
技巧9: 重复命令“.”的使用
例如，假设你在编辑一个HTML文件，你想删除所有的标记。你把光标移到第一个“”命令删除，然后你就可以移到的”）。要删除下一个标记，移动到下一个在行首输入“#include "”
$ 移到行末
a" 在行末加上双引号“"”
j 移到下一行
q 结束记录
现在，你已经完成一个修改了，你可以通过重复三次“@a”完成余下的修改。
技巧8. 寄存器的扩展技巧
记录到一个大写寄存器表示扩展命令到对应的小写寄存器。
假设已经记录了一个修改一个单词的命令到寄存器c中。它可以正常工作，现在你需要加一个搜索命令以便找到下一个单词来修改。这可以通过如下命令来完成：
qC/wordq
这种方法在宏记录，拷贝和删除命令中都有效。例如，你需要把选择一些行到一个寄存器中，可以先这样拷贝第一行：
"aY
然后移到下一个要拷贝的地方，执行：
"AY
如此类推。这样在寄存器a中就会包括所有你要拷贝的行。
技巧1.替换命令中的范围的确定
方法1. 使用行号：
例如,“n,m” --从第n行到第m行；
“n” --第n行
“-3,$+5” --从上面第三行到文末倒数第五行的范围；
方法2. 使用匹配模式：
例如，“:?^Chapter?,/^Chapter/s=grey=gray=g”，为了避免斜杠使用的混淆，在这种情况下，“=”字符用于代替斜杠。使用斜杠或使用其他字符也是可以的。
方法3. 使用标记：
例如，先用“mt”标记开头，再用“mb”标记结尾。然后就可以用标记表示一个范围（包括标记的那一行）：
:'t,'b
方法4. 使用可视模式：
先用V选定范围，再输入“:”会出现“:'”，现在，只需要输入剩下的命令；
注意：
如果使用可视模式选中行的一部分，或者用 CTRL-V 选中一个文本块，然后
执行冒号命令，命令仍作用于行范围，而不是选中的范围。这可能会在以后
的版本中修正。
技巧2. 使用全局命令
它允许你找到一个匹配点并且在上面执行一个命令。它的一般形式是：
“:[range]global/{pattern}/{command}”
例如：把“foobar”修改为“barfoo”，但只需要修改C++风格的注释中的内容。这种注释以“//”开头。所以可以使用如下命令：
“:g+//+s/foobar/barfoo/g”
注意：global中只能使用冒号命令。普通命令不能在这里使用，如果需要，可以使用normal命令。
技巧3. 改变大小写
“gu”--改为小写；“gugu”“guu”是把一行变为小写；
“gU”--改为大写；“gUgU”“gUU”是把一行变为大写；
“g~”--改变大小写；“g~g~”“g~~”是改变一行。
这三个命令都可以作用于“动作”命令，文本对象和可视模式。
技巧4. 使用外部命令的例子
例子1:对1到5行进行排序。
先把光标定位在第一行，然后执行下面的命令： “!5G”
现在光标移到了屏幕的底部，并显示一个“!”作提示符。
现在你可以输入过滤程序的名字，在本例中就是“sort”了。因此，你整个命令将是： !5Gsort
例子2:“!!date”
用“date”的输出代替当前行。这在为文件加入时间戳的时候非常有用。
技巧5. 读入一个命令的输出
要把当前目录的内容读进来，可以用如下命令：“:read !ls”；
加上一个“!”让Vim知道后面是一个命令。这些命令还可以带参数。
而且前面还可以带一个范围用于告诉Vim把这行放在什么地方：“:0read !date -u”
技巧6. 把文本输出到一个命令
要统计当前文件有多少行，可以这样：
“:write !wc”
注意不要错写成： :write! wc
这会强制把当前文件存到当前目录的“wc”中。在这里空白字符的位置是非常重要的。
技巧7. 单词统计
如果你需要计算的是整个文件的字数，先移到文件第一行开头，然后用这个命令：
“g”“CTRL-G”
可以使用可视模式，选中要计算字数的文本，然后输入“g CTRL-G”；
技巧8. 查阅man信息
把光标移到对应的单词上然后输入：“K”
如果需要在新窗口中打开Man手册，则需要使用加载man文件类型的外挂：
“:source $VIMRUNTIME/ftplugin/man.vim”
然后用“:Man”命令打开一个显示man手册的窗口。如“Man feof”“Man 3 echo”；
现在，还可以用“\K”开个新窗口显示Man手册了。
快速键入命令行命令
技巧0. 更快速的键入命令
Vim 具备若干基本功能，以简化键入命令的工作。你可以缩写，编辑和重复分号命令，
而补全功能几乎可以用于所有的场合。
当你用分号(:)命令或者用 / 或 ? 搜索一个字符串时, Vim 就会把光标置于屏幕下方，
你在那儿键入命令或者搜索模式，此处即称为命令行, 也是用来输入搜索命令的地方。
技巧1. 移动
命令行上移动光标时最常用的键:
左移一个字符
右移一个字符
或左移一个单词
或右移一个单词
CTRL-B 或命令行首位
CTRL-E 或命令行末位
注意:
并非在所有键盘上都有效。其它 Shift 和 Control组合键也有这个问题。
技巧2 删除
除了删除键，外，还可以用；
CTRL-W 删除光标前整个单词用；
CTRL-U 删除命令行上全部文字, 从而让你从头开始；
技巧3. 取消
方法1：用键删除全部字符；
方法2: 用取消；
方法3: 用CTRL+C取消；
技巧4. 命令行缩写
有些 ":" 分号命令确实很长。幸运的是所有 ":" 分号命令都可以被缩写。
比如可以把置换命令 “:substitute”缩写成":s"。
“:s”是“:substitute”的缩写，而不是“:set”的缩写，它的缩写是“:se”。
“:substitute”最简形式是 ":s",不可能更简单，但可以更复杂，即 ":su" 和 ":sub" 都有效。
最短的有效缩写形式可以在帮助文件里找到。
技巧5. 命令行补全
命令和文件都能用补全，并且能针对上下文做智能判断。
比如：键入“:e”，会出现“:edit”，再按一次，成了“:echo”，这和shell中的不一样；
假设要编辑的文件是：“foo.txt”，则键入“:edit f”，就会显示出以“f”开头的文件。
再最后一个匹配文件名上按，会出现最初键入的内容，vim会在匹配表内周而复始地循环。
：依相反方向循环匹配列表；
：显示全部匹配；
：把词补全为最长无歧义字符串；
技巧6. 命令行历史
：用在命令行上已经键入的文本去跟历史记录里的命令作比较, 只有匹配的命令才被显示出来;
：回到较晚的命令，命令能帮你消除光标前的字符以便重新输入；
“:history” ：显示":" 分号命令的历史记录；
“:history /”：显示搜索命令的历史记录；
“q:”：打开命令行窗口；
离开和回来
技巧1. 挂起和继续
方法1：用 CTRL-Z 挂起vim程序，进入shell，最后用 "fg" 命令回到 Vim ；
方法2：当 CTRL-Z 不起作用时，可以用“:suspend”;
注意：别忘了把 Vim 引导回前台,否则你会失去所有的修改!
技巧2. 执行shell命令
方法1：使用CTRL+Z 挂起Vim；
方法2：“:shell”命令重开一个终端，“exit”退出后就返回；
方法2：":!{command}"，比如：“:!ls”；
常用的“!”命令有：
:!{program} 执行 {program}
:r !{program} 执行 {program} 并读取其输出
:w !{program} 执行 {program} 传送文本至其输入
:[range]!{program} 经由 {program} 过滤文本
技巧3. 在编辑模式下执行命令
方法1：用退出编辑模式，进入命令模式；
方法2：用进入命令模式，执行完命令后返回编辑模式；
文件浏览器
技巧1. 文件浏览器怎么用？
“:edit .”：“.”表示当前路径，用其他路径也行;
编辑文件：移动到一个文件名上并按下键；
进入该目录：移动到目录上并按下键；
常用键：
"-" 键进入父目录“..”
o 开启一个新窗口
O 利用最近访问过的窗口
p 利用预览窗口, 并把光标撤回浏览器窗口
技巧2. 排序
i 显示文件大小和日期. 再执行一次 i 命令将隐藏这些信息
s 根据光标所在的字段排序, 先以 i 命令显示文件大小和日期,
然后把光标移到任一文件的一个字段上, 并按 s 键
r 逆转排列顺序 (大小或日期二者择一)
技巧3. 常用操作
c 把当前目录改成显示在窗口中的那个目录
:cd 改变当前目录
:pwd 发现哪个目录是当前目录
R 为光标下文件改名
D 删除光标下文件
技巧4. 查找文件
假设有一个 C 程序, 该程序有这样一行:
#include "inits.h"
想要查看文件 "inits.h" 里有些什么。
把光标移到该文件名上, 并键入: “gf”
Vim 就会找到并打开这个文件。
技巧5. 加密
方法1： "-x" 参数，比如“vim -x foo.txt”,读加密文件是不要加上“-x”参数;
方法2：“:set key=xxx”命令。“key”“key=”“key="xxx"”都是去掉密码的意思;
技巧：“"”“\”等有特殊意义的符号，写成“\"”“\\”；
方法3:“:X”命令，好处在于不会以明文显示密码，同时也不用输入多余的“\”符号；
技巧6. 加密的麻烦
麻烦1：Vim 采用的加密算法有弱点的,防止偷窥者是绰绰有余了, 但不足以防止一个手上有大量时间的密码专家
麻烦2:交换文件是不加密的; 所以当你在编辑文件时, 拥有超级用户权限的人是能够读取未经加密的来自这个文件的交换文件文本的，
可以使用“vim -x -n file.txt”或者“:setlocal noswapfile”来防止产生交换文件；
麻烦3:打开一个加密文件，然后输入错误密码，再对文件进行“:X”操作，这样，谁都没法看文件了。
二进制文件的一些技巧
技巧1. 打开二进制文件
打开二进制文件，要使用“-b”的参数，
这是为了不让vim对文件做任何改动，
vim是个聪明的程序，但不能用在这里；
技巧2. 用 Hex 格式来阅读字符
方法1:“:set display=uhex”命令；
方法2:“ga”命令显示光标下的字符值；
技巧3. 显示当前字节位置，和移到
“g CTRL-G”；
要移到文件中某个指定的字节，用“go”命令，
技巧4. 使用xxd外部程序
首先以二进制方式编辑这个文件：“vim -b datafile”
然后用 xxd把文件转换成十六进制：“:%!xxd”
显示效果：
0000000: 1f8b 0808 39d7 173b 0203 7474 002b 4e49 ....9..;..tt.+NI
0000010: 4b2c 8660 eb9c ecac c462 eb94 345e 2e30 K,.`.....b..4^.0
Vim 把这些信息当作普通文本来对待，
注意，修改了十六进制部分并不导致可打印字符部分的改变, 反之亦然(能理解吗？)；
最后, 记得把它转换回来:“:%!xxd -r”；
注意，只有十六进制部分的修改才会被采用，右边可打印文本部分的修改忽略不计。
技巧5. 可视模式下的重复
"gv" 命令再次选择上次选过的文本；
技巧6. 查找时忽略大小写
默认情况下, Vim 的查找是大小写敏感的；
方法1:
“:set ignorecase”关闭大小写敏感；
“:set noignorecase”重新开启；
“:set ignorecase smartcase”：
如果键入的字符串全是小写，说明忽略大小写；如果出现了大写字母，则说明是大小写敏感的；
方法2:
在模式前附加 "\c" 字符串表示忽略一个特定的模式里的大小写;
附加 "\C" 将使该模式的匹配大小写敏感;
技巧7. 折叠命令“zi”实用的操作方法:
- 创建折叠, 以获取文件的全貌
- 移动到要操作的地方
- 执行“zi”以便一边看着文本, 一边编辑
- 再执行“zi”以便移动到另一处
技巧8. 复制, 删除和粘贴折叠
可以把折叠看成一个单行来对其进行操作，比如这个实用操作：
- 把光标置于被移文本的首行
- 用“V”键开始可视模式
- 把光标置于被移文本的末行
- 用“d”键删除被选中的行
- 把光标移到新位置, 用“p” 键把文本粘贴在那儿
技巧9. “%”使用技巧
假设有这样一段代码：
#ifdef USE_POPEN
fd = popen("ls", "r")
#else
fd = fopen("tmp", "w")
#endif
在“#ifdef” 处按“ %”，Vim 会跳转到“#else”；继续按“%”会跳转到“#endif”；再次按下“%”又回到“#ifdef”；
注意，使用“%”需要光标在“#”所在行；如果光标在代码内部，可以用“[#”“]#”命令向前向后跳转；
技巧10. 键入任意编码
编码键入范围
8-bit CTRL-V 123 decimal 0-255
8-bit CTRL-V x a1 hexadecimal 00-ff
16-bit CTRL-V u 013b hexadecimal 0000-ffff
31-bit CTRL-V U 001303a4 hexadecimal 00000000-7fffffff
技巧11. 在类内部用“[m” 找到前一个方法的开始；“]m” 找到下一个方法的开始。
技巧1. “.”的使用例子
假设要把“four”修改成“five”，有好几个地方要作这种修改。
操作步骤：
/four 找到第一个“four”
cwfive 修改成“five”
n 找下一个“four”
. 重复修改操作
n 找下一个“four”
. 重复修改
如此类推……
技巧2. 分割窗口的技巧
很多编辑另一个文件的命令都有一个分割窗口的变量。
对于命令模式，这通过前置一个“s”实现。例如“:tag”跳到一个标记，“stag”分割出一个新窗口并跳到那个标记。
对于普通模式，前置一个 CTRL-W 可以完成这个功能。例如，CTRL-^ 跳到备选文件，而 CTRL-W CTRL-^ 打开一个新窗口并编辑备选文件。
技巧3. 使用.vimrc文件
这个文件放在“~/” 下；
常用设置：
set fileencodings=cp936
set encoding=cp936
source $VIMRUNTIME/ftplugin/man.vim 用“:Man”“\K”开个新窗口查看man手册
set incsearch 增量匹配
set showcmd 窗口右下角，标尺的右边显示未完成的命令
set display=uhex 以形式显示不可打印字符
set showmatch 显示匹配，如“()”“[]”
set ignorecase smartcase 智能忽略大小写，可以用“\c”“\C”指点是否忽略；

本文来自ChinaUnix博客，如果查看原文请点：http://blog.chinaunix.net/u/10599
/showart_169720.html

本文链接

Emacs 中的查找

2011-10-28T02:33:00Z

最基本的东西

C-s 开始正向查找
C-r 开始方向查找

这两个命令进入了查找模式，在 Emacs 中的术语叫做 Incremental Search ，也就是在你输入要查找的字符的时候，同时高亮显示找到的部分。

在查找模式下的一些操作

下面的操作都是先按 C-s 或者 C-r 后，进入 Incremental Search Mode 之后的操作。

C-r , C-s ，分别是向前查找和向后查找当前输入的内容。

如果当前内容是空的，也就是说你连续两次输入 C-s ，那么就是 “查找下一个 (Find next)”的操作。第一次是C-s 把你带入了 Incremental Search Mode ，第二次的 C-s 表示查找上一次查过的东西。 C-r 类似，只不过方向相反。
C-w 查找光标除所在的单词

例如，你可以输入 C-r 然后马上输入 C-w ，光标所在位置的单词就自动变成了要查找的内容。

多次输入 C-w 后面的单词就会一个一个的变成了查找内容一部分。

C-w 还可以和上面介绍的 C-s C-r 配合使用。C-s 进入 Incremental Search Mode. 然后输入 void f 然后光标会停留在一个 void f 的单词上，也许是 void far ，然后用 C-s 或者 C-r 找到某个 void f 的地方，然后 C-w 就可以把 f 后面的单词补全了。
C-y 把光标所在位置到行尾的部分作为查找内容

和 C-w 类似，只不过输入的不是一个单词，而是整整一行。
M-y 把 kill ring 中的东西输入为当前要查找的内容
M-c 切换大小写敏感。
M-r 切换是普通查找还是正则表达式查找。
M-e 编辑要查找的内容

Incremental Search 会随着用户的输入不断的改变光标的位置，有的时候很讨厌，那么就可以 M-e 编辑要查找的内容，然后按 Enter 回到 Incremetal Search 。
M-n M-p 浏览查找历史纪录

可以查找以前查找过的内容。
C-q C-j 查找多行文字。

如果你要的查找的内容是多行文字，也就是说，查找内容中含有换行字符 C-j 但是， Enter 键又作为结束查找的操作，一按 Enter 就退出了查找模式了。那么 C-q C-j 可以解决这个问题。可以查看如何输入特殊的控制字符。

用 Nonincremental Search 查找

如果不习惯 Incremetal Search 的方式，那么可以 C-s <RET> ，也就是按了 C-s 之后，马上按一个回车，就用 Nonincremental Search 的方式查找，这种查找方式和普通的编辑器几乎一样。

使用 moccur 在所有打开的文件内查找

本来 M-x occur 可以在一个 buffer 的查找某一个正则表达式。 moccur 提供更加强大的功能。安装了 moccur 之后，如果进入 incremetal 查找功能，除了上面介绍的一些功能，有多了两个新的功能。下面的操作都是先按 C-s 或者 C-r 后进入 Incremental Search Mode 之后的操作。

M-o, 小写的 o , 列出来当前 buffer 内的所有查找内容
M-O, 大写的 O , 列出来所有打开的 buffer 中出现的查找内容。
安装 moccur 的方法。下载 color-moccur.el，然后按照文件头的提示或者参考 Emacs 安装一个扩展包的方法

在多个文件中查找

find-dired

运行外部命令 find , 产生文件列表，然后进入 dired 模式。

find-grep-dired

运行外部命令 find，用 grep 过滤文件， ls 产生目录列表，然后进入 dired 模式，这样列出所有包含某些字符的文件列表。可以使用 dired-do-query-replace-regexp 在文件列表中查找并替换。可以递归所有子目录。可以用各种条件过滤文件，详细可以查看 find 命令的帮助。

grep

在当前目录中查找指定的 regexp 。

grep-find

运行 find , grep ，然后产生类似于 compile 的结果，可以查看哪些文件在什么地方包含了匹配了指定的 regexp 。用 C-x ` 浏览结果。可以递归所有子目录。，详细可以查看 find 命令的帮助。

dired-do-query-replace-regexp

在任何 dired 模式下，对于所有带有标记的文件进行查找替换。

替换

在 transient mode 下，如果 region 是激活状态下，那么就调用 query-replace-selection , 这个函数和 query-replace 几乎完全一样，不同的是， query-replace-selection 用当前选择的 region 作为被替换的部分，而不是等用户输入。

(defun query-replace-selection (to-string &optional delimited start end)
  "query reqlace the current selection in transient mark mode."
  (interactive (list
                (read-from-minibuffer (format "Query replace %s with: "
                                              (buffer-substring (point) (mark)))
                                      nil nil nil
                                      query-replace-to-history-variable
                                      (buffer-substring (point) (mark))
                                      t)
                nil nil nil
                ))
  (perform-replace (buffer-substring (point) (mark)) to-string t nil delimited nil nil start end))
(wcy-define-2bind-transient-mode
 wcy-query-replace-or-query-replace-selection
 'query-replace-selection
 'query-replace)
(global-set-key (kbd "M-%") 'wcy-query-replace-or-query-replace-selection)

wcy-define-2bind-transient-mode 的定义参见其他编辑技巧中的 C-w 部分。

;; 在 C-s 进入 incremental search 的时候， 按 M-i ， 替换当前查找内容
(define-key isearch-mode-map (kbd "M-i") 'isearch-query-replace-current)
(defun isearch-query-replace-current ()
  "replace current searching string."
  (interactive)
  (let ((case-fold-search isearch-case-fold-search)
        (from-string isearch-string))
    (if (not isearch-success)
        (message "search string not found")
      (progn
       (isearch-exit)
       (goto-char (min (point) isearch-other-end)))
      ;;(isearch-abort)
      (perform-replace
       from-string
       (read-from-minibuffer (format "Query replace %s with: "
                                     from-string)
                             from-string nil nil
                             query-replace-to-history-variable
                             from-string
                             t)
       t ; query flag
       isearch-regexp
       nil))))

;; 进入 incremental search mode 之后，有些命令可以根据光标所在位置补全要查找内容，
;; 例如 C-w 可以补全一个词。但是如果按多了 C-w 就不能回退了，而且不能精确定位，
;; 下面的键绑定重新定义了一些常用的光标移动命令，根据光标移动，自动补齐查找内容，
;; 例如 C-f 自动补齐光标处的一个字符。
(define-key isearch-mode-map (kbd "C-e") 'isearch-move-point)
(define-key isearch-mode-map (kbd "C-a") 'isearch-move-point)
(define-key isearch-mode-map (kbd "M-e") 'isearch-move-point)
(define-key isearch-mode-map (kbd "M-a") 'isearch-move-point)
(define-key isearch-mode-map (kbd "C-M-e") 'isearch-move-point)
(define-key isearch-mode-map (kbd "C-M-a") 'isearch-move-point)
(define-key isearch-mode-map (kbd "C-f") 'isearch-move-point)
(define-key isearch-mode-map (kbd "C-b") 'isearch-move-point)
(define-key isearch-mode-map (kbd "M-f") 'isearch-move-point)
(define-key isearch-mode-map (kbd "M-b") 'isearch-move-point)
(define-key isearch-mode-map (kbd "C-M-f") 'isearch-move-point)
(define-key isearch-mode-map (kbd "C-M-b") 'isearch-move-point)
(defun isearch-move-point ()
  (interactive)
  (when isearch-success
    (save-excursion
      (let ((overriding-terminal-local-map nil)
            (old-point (or isearch-other-end (point))))
        (call-interactively (key-binding (this-command-keys)))
        (setq isearch-string (buffer-substring-no-properties  old-point
                                                              (point))
              isearch-message
              (mapconcat 'isearch-text-char-description
                         isearch-string "")
              ;; Don't move cursor in reverse search.
              isearch-forward (cond
                               ((< old-point (point)) t)
                               ((> old-point (point)) nil)
                               ((= old-point (point)) isearch-forward))
              )))
    (isearch-search-and-update)))

本文链接

JAVA中的反射机制

2011-07-28T05:45:00Z

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
Java反射机制主要提供了以下功能：在运行时分析类的能力，判断任意对象所属类，类中有哪些方法，有哪些成员变量；在运行时控查对象，比如，只写一个toString()方法供所有的类使用；实现通用数组操作代码的功能。

1. 得到某个对象的属性
1 public Object getProperty(Object owner, String fieldName) throws Exception {
2      Class ownerClass = owner.getClass();
3
4      Field field = ownerClass.getField(fieldName);
5
6      Object property = field.get(owner);
7
8      return property;
9 }
Class ownerClass = owner.getClass()：得到该对象的Class。
Field field = ownerClass.getField(fieldName)：通过Class得到类声明的属性。
Object property = field.get(owner)：通过对象得到该属性的实例，如果这个属性是非公有的，这里会报IllegalAccessException。
2. 得到某个类的静态属性
1 public Object getStaticProperty(String className, String fieldName)
2              throws Exception {
3      Class ownerClass = Class.forName(className);
4
5      Field field = ownerClass.getField(fieldName);
6
7      Object property = field.get(ownerClass);
8
9      return property;
10 }
Class ownerClass = Class.forName(className) ：首先得到这个类的Class。
Field field = ownerClass.getField(fieldName)：和上面一样，通过Class得到类声明的属性。
Object property = field.get(ownerClass) ：这里和上面有些不同，因为该属性是静态的，所以直接从类的Class里取。
3. 执行某对象的方法
1 public Object invokeMethod(Object owner, String methodName, Object[] args) throws Exception {
2
3      Class ownerClass = owner.getClass();
4
5      Class[] argsClass = new Class[args.length];
6
7      for (int i = 0, j = args.length; i < j; i++) {
8          argsClass[i] = args[i].getClass();
9      }
10
11      Method method = ownerClass.getMethod(methodName, argsClass);
12
13      return method.invoke(owner, args);
14 }
Class owner_class = owner.getClass() ：首先还是必须得到这个对象的Class。
5～9行：配置参数的Class数组，作为寻找Method的条件。
Method method = ownerClass.getMethod(methodName, argsClass)：通过Method名和参数的Class数组得到要执行的Method。
method.invoke(owner, args)：执行该Method，invoke方法的参数是执行这个方法的对象，和参数数组。返回值是Object，也既是该方法的返回值。
4. 执行某个类的静态方法
1 public Object invokeStaticMethod(String className, String methodName,
2              Object[] args) throws Exception {
3      Class ownerClass = Class.forName(className);
4
5      Class[] argsClass = new Class[args.length];
6
7      for (int i = 0, j = args.length; i < j; i++) {
8          argsClass[i] = args[i].getClass();
9      }
10
11      Method method = ownerClass.getMethod(methodName, argsClass);
12
13      return method.invoke(null, args);
14 }
基本的原理和实例3相同，不同点是最后一行，invoke的一个参数是null，因为这是静态方法，不需要借助实例运行。
5. 新建实例
1
2 public Object newInstance(String className, Object[] args) throws Exception {
3      Class newoneClass = Class.forName(className);
4
5      Class[] argsClass = new Class[args.length];
6
7      for (int i = 0, j = args.length; i < j; i++) {
8          argsClass[i] = args[i].getClass();
9      }
10
11      Constructor cons = newoneClass.getConstructor(argsClass);
12
13      return cons.newInstance(args);
14
15 }
这里说的方法是执行带参数的构造函数来新建实例的方法。如果不需要参数，可以直接使用newoneClass.newInstance()来实现。
Class newoneClass = Class.forName(className)：第一步，得到要构造的实例的Class。
第5～第9行：得到参数的Class数组。
Constructor cons = newoneClass.getConstructor(argsClass)：得到构造子。
cons.newInstance(args)：新建实例。
6. 判断是否为某个类的实例
1 public boolean isInstance(Object obj, Class cls) {
2      return cls.isInstance(obj);
3 }
7. 得到数组中的某个元素
1 public Object getByArray(Object array, int index) {
2      return Array.get(array,index);
3 }
其中，反射机制最重要的部分是允许你检查类的结构。java.lang.reflect包中的三个类Field,Method,Constructor类分别描述类的字段，方法和构造器，它们都有一个getName方法，用来返回相应条目的名称。

本文链接

java中读取配置文件信息的六种方法

2011-07-28T05:34:00Z

1。使用Java.util.Properties类的load()方法
示例： InputStream in = lnew BufferedInputStream(new FileInputStream(name));
Properties p = new Properties();
p.load(in);

2。使用java.util.ResourceBundle类的getBundle()方法
示例： ResourceBundle rb = ResourceBundle.getBundle(name, Locale.getDefault());

3。使用java.util.PropertyResourceBundle类的构造函数
示例： InputStream in = new BufferedInputStream(new FileInputStream(name));
ResourceBundle rb = new PropertyResourceBundle(in);

4。使用class变量的getResourceAsStream()方法
示例： InputStream in = JProperties.class.getResourceAsStream(name);
Properties p = new Properties();
p.load(in);

5。使用class.getClassLoader()所得到的java.lang.ClassLoader的getResourceAsStream()方法
示例： InputStream in = JProperties.class.getClassLoader().getResourceAsStream(name);
Properties p = new Properties();
p.load(in);

6。使用java.lang.ClassLoader类的getSystemResourceAsStream()静态方法

本文链接

JAVA深入探索－参数传递

2011-07-28T05:31:00Z

按值传参
JAVA中的参数传递只存在传值方式一种，但也有传引用的概念。
这是java参数传递的核心说明。java不像C/C＋＋那样可以通过指针符或地址符来区分传值还是传引用，因为它只有一种参数传递的方式，那就是传值方式。这对初学java的人来说很难理解，通过下面的例子可以看出真正的传值在java中是如何实现的。
public static void swap(int a,int b){//交换两个变量的值
       int temp = a;
       a = b;
       b = temp;
       System.out.println("swap:"+a+","+b);
}
......
    int a = 3;
int b = 5;
   swap(a,b);
       System.out.println(a +" "+b);//3 5
......
程序打印结果：
swap:5,3
3   5
由程序的结果可以看到，事实上，经过交换的方法swap()之后，主程序中的变量a,b的值并没有被改变。
分析过程如下：在调用swap()方法的时候，程序把a、b的副本送到swap()方法中的变量a、b中去，而主程序中的变量a、b中的内容并没有被改变。所以就会出现上面的结果。
其实，不仅是简单的数据类型如此，如果传递的参数是一个对象，也会出现这样的结果，这与简单数据类型的情况类似，都可以划为按值传参一类中。我们看下面的程序及其分析过程：
public class User{
static void swap(User user1,User user2){
       User user = user1;
       user1 = user2;
       user2 = user;
}
public static void main(String[]args){
       User user3 = new User("ding", 20);
       User user4 = new User("zhao", 18);
       swap(user3, user4);
   /*进行函数swap(user1,user2)的调用，但是并不会真正把user3和user4所指向的内存空间
      *进行交换，只是在调用的时候，会把user3中存放的内存地址复制一份传给user1,把user4中存放的
      *内存地址复制一份传给user2，相当于只是给user1和user2了一个副本，而真正的对象
      *user3和user4并没有在swap()函数中被触及。所以函数处理的结果是使user1和user2所指向的内存空间
      *进行交换，而user3和user4中的存放内容仍是原来的内容。*/
       System.out.println(user3.username + "   " +user3.age);//ding   20
       System.out.println(user4.username + "   " +user4.age);//zhao   18
｝
程序的运行结果：
ding   20
zhao   18

传递引用
既然说java中的参数传递只有by value一种，为什么还要说传递引用呢？实际上，java与C＋＋一样，同样存在对一个对象的引用进行传递的问题，但java中的引用传递机制是，把原来变量中保存的内存地址传递作为一个参数进行传递，而不是直接把引用传过去。所以在java中仍把它称做按值传参。
同样采用例子的方式来解释java中的引用传递的问题:
.......
public static   void changAge(User user){
       User temp = user;//这时，temp中存放了和原对象相同的内存地址
       temp.age = temp.age + 20;//对user的年龄进行增加的操作，
       /*是对temp所指向的内存空间中的值直接进行操作，所以会对原对象的值造成影响。就相当于是传递了原对象的引用*/
}
......
       User user = new User("li",25);//仍采用上例中的User
       changAge(user);//改变user的年龄
       System.out.println(user.age);//45
.......
有了上面例子的说明，我们可能就会想到，如果我们的程序中私有变量是一个对象类型的变量时，在主程序中有了这个私有变量的拷贝，是不是就有可能在修改这个拷贝时不小心把原来的私有变量的值也给改变了呢？
我们来看下面的例子：
class Test{
private Date date=new Date();
public Date getDate(){
return date;
}
public static void main(String[] args){
Test tt=new Test();
Date myDate=tt.getDate();//返回了一个私有变量的拷贝
System.out.println(myDate);
myDate.setTime(new Date().getTime()-(long)(10*365.25*24*3600*1000));//对新产生的拷贝进行修改
System.out.println(tt.getDate());
System.out.println(myDate);
}
}
先来猜一下运行的结果,是前两句输出一样呢还是后两句输出一样(最后一句输出比第一句输出的日期早十年)?很多人都会说是前两句输出一样.实际上,你会惊奇地发现，输出结果显示后两者输出一样，私有变量在程序外部被改变了，程序的封装性遭到了破坏。
出错的原因很微妙.因为myDate和tt指向了同一个对象，对myDate的引用更改方法自动地改变了这个类的私有方法状态。经过测试可以知道，如果myDate被重新赋值（比如myDate=new Date())，就不会出现上面的结果。但是现在的这个程序，私有变量还是在程序外部被改变了。
如果需要返回一个指向可变对象的引用，我们就需要克隆它，这样就不会导致上面的私有变量被更改。
上面程序就应更改为：return (Date)date.clone();就可以防止私有变量被修改的麻烦了。
再来执行上面的程序，就会出现不一样的结果。

本文链接

使用JNI技术实现JAVA程序调用dll

2011-07-28T04:37:00Z

JAVA的跨平台的特性深受java程序员们的喜爱,但正是由于它为了实现跨平台的目的,使得它和本地机器的各种内部联系变得很少,大大约束了它的功能,比如与一些硬件设备通信,往往要花费很大的精力去设计流程编写代码去管理设备端口,而且有一些设备厂商提供的硬件接口已经经过一定的封装和处理,不能直接使用java程序通过端口和设备通信,这种情况下就得考虑使用java程序去调用比较擅长同系统打交道的第三方程序,从1.1版本开始的JDK提供了解决这个问题的技术标准:JNI技术.
       JNI是Java Native Interface(Java本地接口)的缩写,本地是相对于java程序来说的,指直接运行在操作系统之上,与操作系统直接交互的程序.从1.1版本的JDK开始,JNI就作为标准平台的一部分发行.在JNI出现的初期是为了Java程序与本地已编译语言,尤其是C和C++的互操作而设计的,后来经过扩展也可以与c和c++之外的语言编写的程序交互,例如Delphi程序.
       使用JNI技术固然增强了java程序的性能和功能,但是它也破坏了java的跨平台的优点,影响程序的可移植性和安全性,例如由于其他语言(如C/C++)可能能够随意地分配对象/占用内存,Java的指针安全性得不到保证.但在有些情况下,使用JNI是可以接受的,甚至是必须的,例如上面提到的使用java程序调用硬件厂商提供的类库同设备通信等,目前市场上的许多读卡器设备就是这种情况.在这必须使用JNI的情况下,尽量把所有本地方法都封装在单个类中,这个类调用单个的本地库文件,并保证对于每种目标操作系统,都可以用特定于适当平台的版本替换这个文件,这样使用JNI得到的要比失去的多很多.
       现在开始讨论上面提到的问题,一般设备商会提供两种类型的类库文件,windows系统的会包含.dll/.h/.lib文件,而linux系统的会包含.so/.a文件,这里只讨论windows系统下的c/c++编译的dll文件调用方法.
       我把设备商提供的dll文件称之为第三方dll文件,之所以说第三方,是因为JNI直接调用的是按它的标准使用c/c++语言编译的dll文件,这个文件是客户程序员按照设备商提供的.h文件中的列出的方法编写的dll文件,我称之为第二方dll文件,真正调用设备商提供的dll文件的其实就是这个第二方dll文件.到这里,解决问题的思路已经产生了,大慨分可以分为三步:
       1>编写一个java类,这个类包含的方法是按照设备商提供的.h文件经过变形/转换处理过的,并且必须使用native定义.这个地方需要注意的问题是java程序中定义的方法不必追求和厂商提供的头文件列出的方法清单中的方法具有相同的名字/返回值/参数,因为一些参数类型如指针等在java中没法模拟,只要能保证这个方法能实现原dll文件中的方法提供的功能就行了;
       2>按JNI的规则使用c/c++语言编写一个dll程序;
       3>按dll调用dll的规则在自己编写的dll程序里面调用厂商提供的dll程序中定义的方法.

我之前为了给一个java项目添加IC卡读写功能,曾经查了很多资料发现查到的资料都是只说到第二步,所以剩下的就只好自己动手研究了.下面结合具体的代码来按这三个步骤分析.

     1>假设厂商提供的.h文件中定义了一个我们需要的方法:
      __int16 __stdcall readData( HANDLE icdev, __int16 offset, __int16 len, unsigned char *data_buffer );
      a.__int16定义了一个不依赖于具体的硬件和软件环境,在任何环境下都占16 bit的整型数据(java中的int类型是32 bit),这个数据类型是vc++中特定的数据类型,所以我自己做的dll也是用的vc++来编译.
     b.__stdcall表示这个函数可以被其它程序调用,vc++编译的DLL欲被其他语言编写的程序调用,应将函数的调用方式声明为__stdcall方式,WINAPI都采用这种方式.c/c++语言默认的调用方式是__cdecl,所以在自己做可被java程序调用的dll时一定要加上__stdcall的声明,否则在java程序执行时会报类型不匹配的错误.
     c.HANDLE icdev是windows操作系统中的一个概念,属于win32的一种数据类型,代表一个核心对象在某一个进程中的唯一索引,不是指针,在知道这个索引代表的对象类型时可以强制转换成此类型的数据.
    这些知识都属于win32编程的范围,更为详细的win32资料可以查阅相关的文档.
    这个方法的原始含义是通过设备初始时产生的设备标志号icdev,读取从某字符串在内存空间中的相对超始位置offset开始的共len个字符,并存放到data_buffer指向的无符号字符类型的内存空间中,并返回一个16 bit的整型值来标志这次的读设备是否成功,这里真正需要的是unsigned char *这个指针指向的地址存放的数据,而java中没有指针类型,所以可以考虑定义一个返回字符串类型的java方法,原方法中返回的整型值也可以按经过一定的规则处理按字符串类型传出,由于HANDLE是一个类型于java中的Ojbect类型的数据,可以把它当作int类型处理,这样java程序中的方法定义就已经形成了:
    String readData( int icdev, int offset, int len );
    声明这个方法的时候要加上native关键字,表明这是一个与本地方法通信的java方法,同时为了安全起见,此文方法要对其它类隐藏,使用private声明,再另外写一个public方法去调用它,同时要在这个类中把本地文件加载进来,最终的代码如下:

package test;

public class LinkDll
{
    //从指定地址读数据
    private native String readData( int icdev, int offset, int len );
    public String readData( int icdev, int offset, int len )
    {
        return this.readDataTemp( icdev, offset, len );
    }

    static
    {
        System.loadLibrary( "TestDll" );//如果执行环境是linux这里加载的是SO文件,如果是windows环境这里加载的是dll文件
    }
}

2>使用JDK的javah命令为这个类生成一个包含类中的方法定义的.h文件,可进入到class文件包的根目录下(只要是在classpath参数中的路径即可),使用javah命令的时候要加上包名javah test.LinkDll,命令成功后生成一个名为test_LinkDll.h的头文件.
文件内容如下:

/* DO NOT EDIT THIS FILE - it is machine generated*/
#include <jni.h>

/* Header for class test_LinkDll */
#ifndef _Included_test_LinkDll #define

Included_test_LinkDll
#ifdef __cplusplus extern "C" { #endif
/*
* Class: test_LinkDll
* Method: readDataTemp
* Signature: (III)Ljava/lang/String;
*/
JNIEXPORT jstring JNICALL Java_test_LinkDll_readDataTemp(JNIEnv *, jobject, jint, jint, jint);
#ifdef __cplusplus } #endif
#endif

    可以看出,JNI为了实现和dll文件的通信,已经按它的标准对方法名/参数类型/参数数目作了一定的处理,其中的JNIEnv*/jobjtct这两个参数是每个JNI方法固有的参数,javah命令负责按JNI标准为每个java方法加上这两个参数.JNIEnv是指向类型为JNIEnv_的一个特殊JNI数据结构的指针,当由C++编译器编译时JNIEnv_结构其实被定义为一个类,这个类中定义了很多内嵌函数,通过使用"->"符号,可以很方便使用这些函数,如:
    (env)->NewString( jchar* c, jint len )
    可以从指针c指向的地址开始读取len个字符封装成一个JString类型的数据.
    其中的jchar对应于c/c++中的char,jint对应于c/c++中的len,JString对应于java中的String,通过查看jni.h可以看到这些数据类型其实都是根据java和c/c++中的数据类型对应关系使用typedef关键字重新定义的基本数据类型或结构体.
    具体的对应关系如下:
Java类型     本地类型             描述
boolean       jboolean             C/C++8位整型
byte             jbyte                   C/C++带符号的8位整型
char             jchar                   C/C++无符号的16位整型
short            jshort                  C/C++带符号的16位整型
int                 jint                      C/C++带符号的32位整型
long             jlong                   C/C++带符号的64位整型e
float             jfloat                   C/C++32位浮点型
double        jdouble               C/C++64位浮点型
Object          jobject                 任何Java对象,或者没有对应java类型的对象
Class         jclass                  Class对象
String          jstring                  字符串对象
Object[]      jobjectArray         任何对象的数组
boolean[]    jbooleanArray     布尔型数组
byte[]          jbyteArray           比特型数组
char[]           jcharArray            字符型数组
short[]          jshortArray           短整型数组
int[]             jintArray                整型数组
long[]          jlongArray             长整型数组
float[]         jfloatArray              浮点型数组
double[]     jdoubleArray        双浮点型数组
    更为详细的资料可以查阅JNI文档.
    需要注意的问题:test_LinkDll.h文件包含了jni.h文件;

3>使用vc++ 6.0编写TestDll.dll文件,这个文件名是和java类中loadLibrary的名称一致.
a>使用vc++6.0 新建一个Win32 Dynamic-Link Library的工程文件,工程名指定为TestDll
b>把源代码文件和头文件使用"Add Fiels to Project"菜单加载到工程中,若使用c来编码,源码文件后缀名为.c,若使用c++来编码,源码文件扩展名为.cpp,这个一定要搞清楚,因为对于不同的语言,使用JNIEnv指针的方式是不同的.
c>在这个文件里调用设备商提供的dll文件,设备商一般提供三种文件:dll/lib/h,这里假设分别为A.dll/A.lib/A.h.
这个地方的调用分为动态调用和静态调用静态调用即是只要把被调用的dll文件放到path路径下,然后加载lib链接文件和.h头文件即可直接调用A.dll中的方法:
把设备商提供的A.h文件使用"Add Fiels to Project"菜单加载到这个工程中,同时在源代码文件中要把这个A.h文件使用include包含进来;
然后依次点击"Project->settings"菜单,打开link选项卡,把A.lib添加到"Object/library modules"选项中.
具体的代码如下:
//读出数据,需要注意的是如果是c程序在调用JNI函数时必须在JNIEnv的变量名前加*,如(*env)->xxx,如果是c++程序,则直接使用(env)->xxx

#include<WINDOWS.H>
#include<MALLOC.H>
#include<STDIO.H>
#include<jni.h>
#include "test_LinkDll.h"
#include "A.h"

JNIEXPORT jstring JNICALL Java_test_LinkDll_readDataTemp( JNIEnv *env, jobject jo, jint ji_icdev, jint ji_len )
{
    //*************************基本数据声明与定义******************************
     HANDLE H_icdev = (HANDLE)ji_icdev;//设备标志符
    __int16 i16_len = (__int16)ji_len;//读出的数据长度,值为3,即3个HEX形式的字符
    __int16 i16_result;//函数返回值
    __int16 i16_coverResult;//字符转换函数的返回值
        int i_temp;//用于循环的中间变量
      jchar jca_result[3] = { 'e', 'r', 'r' };//当读数据错误时返回此字符串

    //无符号字符指针,指向的内存空间用于存放读出的HEX形式的数据字符串
    unsigned char* uncp_hex_passward = (unsigned char*)malloc( i16_len );
    //无符号字符指针,指向的内存空间存放从HEX形式转换为ASC形式的数据字符串
    unsigned char* uncp_asc_passward = (unsigned char*)malloc( i16_len * 2 );
    //java char指针,指向的内存空间存放从存放ASC形式数据字符串空间读出的数据字符串
    jchar *jcp_data = (jchar*)malloc(i16_len*2+1);
    //java String,存放从java char数组生成的String字符串,并返回给调用者
    jstring js_data = 0;

//*********读出3个HEX形式的数据字符到uncp_hex_data指定的内存空间**********
i16_result = readData( H_icdev, 6, uncp_hex_data );//这里直接调用的是设备商提供的原型方法.

    if ( i16_result != 0 )
    {
        printf( "读卡错误......\n" );
        //这个地方调用JNI定义的方法NewString(jchar*,jint),把jchar字符串转换为JString类型数据,返回到java程序中即是String
        return (env)->NewString( jca_result, 3 );
    }

printf( "读数据成功......\n" );

    //**************HEX形式的数据字符串转换为ASC形式的数据字符串**************
    i16_coverResult = hex_asc( uncp_hex_data, uncp_asc_data, 3 );
    if ( i16_coverResult != 0 )
    {
        printf( "字符转换错误！\n" );
        return (env)->NewString( jca_result, 3 );
    }

    //**********ASC char形式的数据字符串转换为jchar形式的数据字符串***********
    for ( i_temp = 0; i_temp < i16_len; i_temp++ )
        jcp_data[i_temp] = uncp_hex_data[i_temp];
    //******************jchar形式的数据字符串转换为java String****************
    js_data = (env)->NewString(jcp_data,i16_len);
    return js_data;
}

动态调用,不需要lib文件,直接加载A.dll文件,并把其中的文件再次声明,代码如下:
#include<STDIO.H>
#include<WINDOWS.H>
#include "test_LinkDll.h"

//首先声明一个临时方法,这个方法名可以随意定义,但参数同设备商提供的原型方法的参数保持一致.
typedef int ( *readDataTemp )( int, int, int, unsigned char * );//从指定地址读数据

//从指定地址读数据
JNIEXPORT jstring JNICALL Java_readDataTemp( JNIEnv *env, jobject jo, jint ji_icdev, jint ji_offset, jint ji_len )
{
    int i_temp;
    int i_result;
    int i_icdev = (int)ji_icdev;
    int i_offset = (int)ji_offset;
    int i_len = (int)ji_len;
    jchar jca_result[5] = { 'e', 'r', 'r' };
    unsigned char *uncp_data = (unsigned char*)malloc(i_len);
    jchar *jcp_data = (jchar *)malloc(i_len);
    jstring js_data = 0;
    //HINSTANCE是win32中同HANDLE类似的一种数据类型,意为Handle to an instance,常用来标记App实例,在这个地方首先把A.dll加载到内存空间,以一个App的形式存放,然后取

得它的instance交给dllhandle,以备其它资源使用.
    HINSTANCE dllhandle;
    dllhandle = LoadLibrary( "A.dll" );
    //这个地方首先定义一个已声明过的临时方法,此临时方法相当于一个结构体,它和设备商提供的原型方法具有相同的参数结构,可互相转换
    readDataTemp readData;

    //使用win32的GetProcAddress方法取得A.dll中定义的名为readData的方法,并把这个方法转换为已被定义好的同结构的临时方法,
    //然后在下面的程序中,就可以使用这个临时方法了,使用这个临时方法在这时等同于使用A.dll中的原型方法.
    readData = (readDataTemp) GetProcAddress( dllhandle, "readData" );

i_result = (*readData)( i_icdev, i_offset, i_len, uncp_data );

    if ( i_result != 0 )
    {
        printf( "读数据失败......\n" );
        return (env)->NewString( jca_result, 3 );
    }

    for ( i_temp = 0; i_temp < i_len; i_temp++ )
    {
        jcp_data[i_temp] = uncp_data[i_temp];
    }

js_data = (env)->NewString( jcp_data, i_len );

return js_data;
}

4>以上即是一个java程序调用第三方dll文件的完整过程,当然,在整个过程的工作全部完成以后,就可以使用java类LinkDll中的public String radData( int, int, int )方法了,效果同直接使用c/c++调用这个设备商提供的A.dll文件中的readData方法几乎一样.

总结:JNI技术确实是提高了java程序的执行效率,并且扩展了java程序的功能,但它也确确实实破坏了java程序的最重要的优点:平台无关性,所以除非必须(不得不)使用JNI技术,一般还是提倡写100%纯java的程序.根据自己的经验及查阅的一些资料,把可以使用JNI技术的情况罗列如下:
    1>需要直接操作物理设备,而没有相关的驱动程序,这时候我们可能需要用C甚至汇编语言来编写该设备的驱动,然后通过JNI调用;
    2>涉及大量数学运算的部分,用java会带来些效率上的损失;
    3>用java会产生系统难以支付的开销,如需要大量网络链接的场合;
    4>存在大量可重用的c/c++代码,通过JNI可以减少开发工作量,避免重复开发.
另外,在利用JNI技术的时候要注意以下几点:
    1>由于Java安全机制的限制,不要试图通过Jar文件的方式发布包含本地化方法的Applet到客户端;
    2>注意内存管理问题,虽然在本地方法返回Java后将自动释放局部引用,但过多的局部引用将使虚拟机在执行本地方法时耗尽内存;
    3>JNI技术不仅可以让java程序调用c/c++代码,也可以让c/c++代码调用java代码.

注:有一个名叫Jawin开源项目实现了直接读取第三方dll文件,不用自己辛苦去手写一个起传值转换作用的dll文件,有兴趣的可以研究一下.但是我用的时候不太顺手,有很多规则限制,像自己写程序时可以随意定义返回值,随意转换类型,用这个包的话这些都是不可能的了,所以我的项目还没开始就把它抛弃了.

本文链接

J2EE 13种技术规范

2011-07-28T04:34:00Z

J2EE平台由一整套服务（Services）、应用程序接口（APIs）和协议构成，它对开发基于Web的多层应用提供了功能支持，下面对J2EE中的13种技术规范进行简单的描述(限于篇幅，这里只能进行简单的描述):
1.JDBC(Java Database Connectivity):
JDBC API为访问不同的数据库提供了一种统一的途径，象ODBC一样，JDBC对开发者屏蔽了一些细节问题，另外，JDCB对数据库的访问也具有平台无关性。
2.JNDI(Java Name and Directory Interface):
JNDI API被用于执行名字和目录服务。它提供了一致的模型来存取和操作企业级的资源如DNS和LDAP，本地文件系统，或应用服务器中的对象。
3.EJB(Enterprise JavaBean):
J2EE技术之所以赢得某体广泛重视的原因之一就是EJB。它们提供了一个框架来开发和实施分布式商务逻辑，由此很显著地简化了具有可伸缩性和高度复杂的企业级应用的开发。EJB规范定义了EJB组件在何时如何与它们的容器进行交互作用。容器负责提供公用的服务，例如目录服务、事务管理、安全性、资源缓冲池以及容错性。但这里值得注意的是，EJB并不是实现J2EE的唯一途径。正是由于J2EE的开放性，使得有的厂商能够以一种和EJB平行的方式来达到同样的目的。
4.RMI(Remote Method Invoke):
正如其名字所表示的那样，RMI协议调用远程对象上方法。它使用了序列化方式在客户端和服务器端传递数据。RMI是一种被EJB使用的更底层的协议。
5.Java IDL/CORBA:
在Java IDL的支持下，开发人员可以将Java和CORBA集成在一起。他们可以创建Java对象并使之可在CORBA ORB中展开, 或者他们还可以创建Java类并作为和其它ORB一起展开的CORBA对象的客户。后一种方法提供了另外一种途径，通过它Java可以被用于将你的新的应用和旧的系统相集成。
6.JSP(Java Server Pages):
JSP页面由HTML代码和嵌入其中的Java代码所组成。服务器在页面被客户端所请求以后对这些Java代码进行处理，然后将生成的HTML页面返回给客户端的浏览器。
7.Java Servlet:
Servlet是一种小型的Java程序，它扩展了Web服务器的功能。作为一种服务器端的应用，当被请求时开始执行，这和CGI Perl脚本很相似。Servlet提供的功能大多与JSP类似，不过实现的方式不同。JSP通常是大多数HTML代码中嵌入少量的Java代码，而servlets全部由Java写成并且生成HTML。
8.XML(Extensible Markup Language):
XML是一种可以用来定义其它标记语言的语言。它被用来在不同的商务过程中共享数据。XML的发展和Java是相互独立的，但是，它和Java具有的相同目标正是平台独立性。通过将Java和XML的组合，您可以得到一个完美的具有平台独立性的解决方案。
9.JMS(Java Message Service):
MS是用于和面向消息的中间件相互通信的应用程序接口(API)。它既支持点对点的域，有支持发布/订阅(publish/subscribe)类型的域，并且提供对下列类型的支持：经认可的消息传递,事务型消息的传递，一致性消息和具有持久性的订阅者支持。JMS还提供了另一种方式来对您的应用与旧的后台系统相集成。
10.JTA(Java Transaction Architecture):
JTA定义了一种标准的API，应用系统由此可以访问各种事务监控。
11.JTS(Java Transaction Service):
JTS是CORBA OTS事务监控的基本的实现。JTS规定了事务管理器的实现方式。该事务管理器是在高层支持Java Transaction API (JTA)规范，并且在较底层实现OMG OTS specification的Java映像。JTS事务管理器为应用服务器、资源管理器、独立的应用以及通信资源管理器提供了事务服务。
12.JavaMail:
JavaMail是用于存取邮件服务器的API，它提供了一套邮件服务器的抽象类。不仅支持SMTP服务器，也支持IMAP服务器。
13.JAF(JavaBeans Activation Framework):
JavaMail利用JAF来处理MIME编码的邮件附件。MIME的字节流可以被转换成Java对象，或者转换自Java对象。大多数应用都可以不需要直接使用JAF。

转自:http://hi.baidu.com/dinguangx/blog/item/c6f5003ddcd688c19e3d6279.html

本文链接

pl/sql中添加 shortcuts插件

2011-07-28T01:05:00Z

在pl/sql中添加快捷键的支持只需要把一个文本类型的文件plugin.txt放入到pl/sql安装目录下的plugins文件夹中。

其中plugin.txt 文件中的内容为（自定义的内容，可以根据自己的习惯设置）：

s = select * from
sc* = select count(*) from
w = where
ss = select /*+parallel(a,6)*/ * from

打开pl/sql developer进入[首选项]->[用户界面]->[编辑器]->[autoreplace]，选中enabled复选框，再查找 plugin.txt所在的路径，点击[应用]即完成插件的安装。

重启pl/sql developer，打开sql编辑窗口，输入s，再按空格，就可以出现select * from，这样就可以不必每次都输入这段经常使用而又经常打错的语句了。

本文链接

关于正则表达式

2011-05-24T00:53:00Z

关于正则表达式：正则表达式简介（微软篇）之一正则表达式

如果原来没有使用过正则表达式，那么可能对这个术语和概念会不太熟悉。不过，它们并不是您想象的那么新奇。

请回想一下在硬盘上是如何查找文件的。您肯定会使用? 和* 字符来帮助查找您正寻找的文件。? 字符匹配文件名中的单个字符，而* 则匹配一个或多个字符。一个如'data?.dat' 的模式可以找到下述文件：

data1.dat

data2.dat

datax.dat

dataN.dat

如果使用* 字符代替? 字符，则将扩大找到的文件数量。'data*.dat' 可以匹配下述所有文件名：

data.dat

data1.dat

data2.dat

data12.dat

datax.dat

dataXYZ.dat

尽管这种搜索文件的方法肯定很有用，但也十分有限。? 和* 通配符的有限能力可以使你对正则表达式能做什么有一个概念，不过正则表达式的功能更强大，也更灵活

正则表达式的早期起源：正则表达式简介（微软篇）之二

正则表达式的早期起源正则表达式的"祖先"可以一直上溯至对人类神经系统如何工作的早期研究。Warren McCulloch 和Walter Pitts 这两位神经生理学家研究出一种数学方式来描述这些神经网络。

1956 年, 一位叫Stephen Kleene 的美国数学家在McCulloch 和Pitts 早期工作的基础上，发表了一篇标题为"神经网事件的表示法"的论文，引入了正则表达式的概念。正则表达式就是用来描述他称为"正则集的代数"的表达式，因此采用"正则表达式"这个术语。

随后，发现可以将这一工作应用于使用Ken Thompson 的计算搜索算法的一些早期研究，Ken Thompson是Unix 的主要发明人。正则表达式的第一个实用应用程序就是Unix 中的qed 编辑器。

如他们所说，剩下的就是众所周知的历史了。从那时起直至现在正则表达式都是基于文本的编辑器和搜索工具中的一个重要部分。

使用正则表达式：正则表达式简介（微软篇）之三使用正则表达式

在典型的搜索和替换操作中，必须提供要查找的确切文字。这种技术对于静态文本中的简单搜索和替换任务可能足够了，但是由于它缺乏灵活性，因此在搜索动态文本时就有困难了，甚至是不可能的。

使用正则表达式，就可以：

1.测试字符串的某个模式。例如，可以对一个输入字符串进行测试，看在该字符串是否存在一个电话号码模式或一个信用卡号码模式。这称为数据有效性验证。

2.替换文本。可以在文档中使用一个正则表达式来标识特定文字，然后可以全部将其删除，或者替换为别的文字。

3.根据模式匹配从字符串中提取一个子字符串。可以用来在文本或输入字段中查找特定文字。

例如，如果需要搜索整个web 站点来删除某些过时的材料并替换某些HTML 格式化标记，则可以使用正则表达式对每个文件进行测试，看在该文件中是否存在所要查找的材料或HTML 格式化标记。用这个方法，就可以将受影响的文件范围缩小到包含要删除或更改的材料的那些文件。然后可以使用正则表达式来删除过时的材料，最后，可以再次使用正则表达式来查找并替换那些需要替换的标记。

另一个说明正则表达式非常有用的示例是一种其字符串处理能力还不为人所知的语言。VBScript 是Visual Basic 的一个子集，具有丰富的字符串处理功能。与C 类似的Visual Basic Scripting Edition 则没有这一能力。正则表达式给Visual Basic Scripting Edition 的字符串处理能力带来了明显改善。不过，可能还是在VBScript 中使用正则表达式的效率更高，它允许在单个表达式中执行多个字符串操作。

正则表达式语法：正则表达式简介（微软篇）之四正则表达式语法

一个正则表达式就是由普通字符（例如字符a 到z）以及特殊字符（称为元字符）组成的文字模式。该模式描述在查找文字主体时待匹配的一个或多个字符串。正则表达式作为一个模板，将某个字符模式与所搜索的字符串进行匹配。

这里有一些可能会遇到的正则表达式示例：

Visual Basic VBScript 匹配
Scripting Edition

/^\[ \t]*$/ "^\[ \t]*$" 匹配一个空白行。

/\d{2}-\d{5}/ "\d{2}-\d{5}" 验证一个ID号码是否由一个2位字，一个连字符以及一个5位数字组成。

/<(.*)>.*<\/\1>/ "<(.*)>.*<\/\1>" 匹配一个HTML 标记。

下表是元字符及其在正则表达式上下文中的行为的一个完整列表：

字符描述

\ 将下一个字符标记为一个特殊字符、或一个原义字符、或一个后向引用、或一个八进制转义符。例如，'n' 匹配字符"n"。'\n' 匹配一个换行符。序列'\\' 匹配"\" 而"\(" 则匹配"("。

^ 匹配输入字符串的开始位置。如果设置了RegExp 对象的Multiline 属性，^ 也匹配'\n' 或'\r' 之后的位置。

$ 匹配输入字符串的结束位置。如果设置了RegExp 对象的Multiline 属性，$ 也匹配'\n' 或'\r' 之前的位置。

* 匹配前面的子表达式零次或多次。例如，zo* 能匹配"z" 以及"zoo"。* 等价于{0,}。

+ 匹配前面的子表达式一次或多次。例如，'zo+' 能匹配"zo" 以及"zoo"，但不能匹配"z"。+ 等价于{1,}。

? 匹配前面的子表达式零次或一次。例如，"do(es)?" 可以匹配"do" 或"does" 中的"do" 。? 等价于{0,1}。

{n} n 是一个非负整数。匹配确定的n 次。例如，'o{2}' 不能匹配"Bob" 中的'o'，但是能匹配"food" 中的两个o。

{n,} n 是一个非负整数。至少匹配n 次。例如，'o{2,}' 不能匹配"Bob" 中的'o'，但能匹配"foooood" 中的所有o。'o{1,}'
等价于'o+'。'o{0,}' 则等价于'o*'。

{n,m} m 和n 均为非负整数，其中n <= m。最少匹配n 次且最多匹配m 次。刘，"o{1,3}" 将匹配"fooooood" 中的前三个o。
'o{0,1}'等价于'o?'。请注意在逗号和两个数之间不能有空格

? 当该字符紧跟在任何一个其他限制符(*, +, ?, {n}, {n,},{n,m}) 后面时，匹配模式是非贪婪的。非贪婪模式尽可能少的
匹配所搜索的字符串，而默认的贪婪模式则尽可能多的匹配所搜索的字符串。例如，对于字符串"oooo"，'o+?' 将匹配单个"o"，而'o+' 将匹配所有'o'。

. 匹配除"\n" 之外的任何单个字符。要匹配包括'\n' 在内的任何字符，请使用象'[.\n]' 的模式。

(pattern) 匹配pattern 并获取这一匹配。所获取的匹配可以从产生的Matches 集合得到，在VBScript 中使用SubMatches 集合，在
Visual Basic Scripting Edition 中则使用$0…$9 属性。要匹配圆括号字符，请使用'$' 或'$'。

(?:pattern) 匹配pattern 但不获取匹配结果，也就是说这是一个非获取匹配，不进行存储供以后使用。这在使用"或" 字符(　) 来组合
一个模式的各个部分是很有用。例如，'industr(?:y　ies) 就是一个比'industry　industries' 更简略的表达式。

(?=pattern) 正向预查，在任何匹配pattern 的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后
使用。例如，'Windows (?=95　98　NT　2000)' 能匹配"Windows 2000"中的"Windows"，但不能匹配"Windows3 .1"中"Windows"。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。

(?!pattern) 负向预查，在任何不匹配Negative lookahead matches the search string at any point where a string not matching pattern 的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如'Windows(?!95　98　NT　2000)' 能匹配"Windows 3.1" 中的"Windows"，但不能匹配"Windows 2000" 中的"Windows"。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始x　y 匹配x 或y。例如，'z　food' 能匹配"z" 或"food"。'(z　f)
ood' 则匹配"zood" 或"food"。

[xyz] 字符集合。匹配所包含的任意一个字符。例如，'[abc]' 可以匹配"plain" 中的'a'。

[^xyz] 负值字符集合。匹配未包含的任意字符。例如，'[^abc]' 可以匹配"plain" 中的'p'。

[a-z] 字符范围。匹配指定范围内的任意字符。例如，'[a-z]' 可以匹配'a' 到'z' 范围内的任意小写字母字符。

[^a-z] 负值字符范围。匹配任何不在指定范围内的任意字符。例如，'[^a-z]' 可以匹配任何不在'a' 到'z' 范围内的任意字符。

\b 匹配一个单词边界，也就是指单词和空格间的位置。例如，'er\b' 可以匹配"never" 中的'er'，但不能匹配"verb" 中的'er'。

\B 匹配非单词边界。'er\B' 能匹配"verb" 中的'er'，但不能匹配"never" 中的'er'。

\cx 匹配由x指明的控制字符。例如，\cM 匹配一个Control-M 或回车符。x 的值必须为A-Z 或a-z 之一。否则，将c 视为一个原义的'c' 字符。

\d 匹配一个数字字符。等价于[0-9]。

\D 匹配一个非数字字符。等价于[^0-9]。

\f 匹配一个换页符。等价于\x0c 和\cL。

\n 匹配一个换行符。等价于\x0a 和\cJ。

\r 匹配一个回车符。等价于\x0d 和\cM。

\s 匹配任何空白字符，包括空格、制表符、换页符等等。等价于[ \f\n\r\t\v]。

\S 匹配任何非空白字符。等价于[^ \f\n\r\t\v]。

\t 匹配一个制表符。等价于\x09 和\cI。

\v 匹配一个垂直制表符。等价于\x0b 和\cK。

\w 匹配包括下划线的任何单词字符。等价于'[A-Za-z0-9_]'。

\W 匹配任何非单词字符。等价于'[^A-Za-z0-9_]'。

\xn 匹配n，其中n 为十六进制转义值。十六进制转义值必须为确定的两个数字长。例如，'\x41' 匹配"A"。'\x041' 则等价于'\x04' & "1"。正则表达式中可以使用ASCII 编码。.

\num 匹配num，其中num是一个正整数。对所获取的匹配的引用。例如，'(.)\1' 匹配两个连续的相同字符。

\n 标识一个八进制转义值或一个后向引用。如果\n 之前至少n 个获取的子表达式，则n 为后向引用。否则，如果n 为八进制数字(0-7)，则n 为一个八进制转义值。

\nm 标识一个八进制转义值或一个后向引用。如果\nm 之前至少有is preceded by at least nm 个获取得子表达式，则nm 为后向引用。如果\nm 之前至少有n 个获取，则n 为一个后跟文字m 的后向引用。如果前面的条件都不满足，若n 和m 均为八进制数字(0-7)，则\nm 将匹配八进制转义值nm。

\nml 如果n 为八进制数字(0-3)，且m 和l 均为八进制数字(0-7)，则匹配八进制转义值nml。

\un 匹配n，其中n 是一个用四个十六进制数字表示的Unicode字符。例如，\u00A9 匹配版权符号(?)。

建立正则表达式：正则表达式简介（微软篇）之五建立正则表达式

构造正则表达式的方法和创建数学表达式的方法一样。也就是用多种元字符与操作符将小的表达式结合在一起来创建更大的表达式。

可以通过在一对分隔符之间放入表达式模式的各种组件来构造一个正则表达式。对Visual Basic Scripting Edition 而言，分隔符为一对正斜杠(/) 字符。例如：

/expression/

对VBScript 而言，则采用一对引号("") 来确定正则表达式的边界。例如：

"expression"

在上面所示的两个示例中，正则表达式模式(expression) 均存储在RegExp 对象的Pattern 属性中。

正则表达式的组件可以是单个的字符、字符集合、字符范围、字符间的选择或者所有这些组件的任意组合。

优先权顺序：正则表达式简介（微软篇）之六优先权顺序

在构造正则表达式之后，就可以象数学表达式一样来求值，也就是说，可以从左至右并按照一个优先权顺序来求值。

下表从最高优先级到最低优先级列出各种正则表达式操作符的优先权顺序：

操作符描述

\ 转义符

(), (?:), (?=), [] 圆括号和方括号

*, +, ?, {n}, {n,}, {n,m} 限定符

^, $, \anymetacharacter 位置和顺序

普通字符：正则表达式简介（微软篇）之七普通字符

普通字符由所有那些未显式指定为元字符的打印和非打印字符组成。这包括所有的大写和小写字母字符，所有数字，所有标点符号以及一些符号。

最简单的正则表达式是一个单独的普通字符，可以匹配所搜索字符串中的该字符本身。例如，单字符模式'A' 可以匹配所搜索字符串中任何位置出现的字母'A'。这里有一些单字符正则表达式模式的示例：

/a/
/7/
/M/

等价的VBScript 单字符正则表达式为：

"a"
"7"
"M"

可以将多个单字符组合在一起得到一个较大的表达式。例如，下面的Visual Basic Scripting Edition 正则表达式不是别的，就是通过组合单字符表达式'a'、'7'以及'M' 所创建出来的一个表达式。

/a7M/

等价的VBScript 表达式为：

"a7M"

特殊字符：正则表达式简介（微软篇）之八特殊字符

有不少元字符在试图对其进行匹配时需要进行特殊的处理。要匹配这些特殊字符，必须首先将这些字符转义，也就是在前面使用一个反斜杠(\)。下表给出了这些特殊字符及其含义：

特殊字符说明

$ 匹配输入字符串的结尾位置。如果设置了RegExp 对象的Multiline
属性，则$ 也匹配'\n' 或'\r'。要匹配$ 字符本身，请使用\$。

( ) 标记一个子表达式的开始和结束位置。子表达式可以获取供以后使用。
要匹配这些字符，请使用$ 和$。

* 匹配前面的子表达式零次或多次。要匹配* 字符，请使用\*。

+ 匹配前面的子表达式一次或多次。要匹配+ 字符，请使用\+。

. 匹配除换行符\n之外的任何单字符。要匹配.，请使用\。

标记一个中括号表达式的开始。要匹配[，请使用\[。

? 匹配前面的子表达式零次或一次，或指明一个非贪婪限定符。要匹配?
字符，请使用\?。

\ 将下一个字符标记为或特殊字符、或原义字符、或后向引用、或八进制
转义符。例如，'n' 匹配字符'n'。'\n' 匹配换行符。序列'\\' 匹
配"\"，而'\(' 则匹配"("。

^ 匹配输入字符串的开始位置，除非在方括号表达式中使用，此时它表示
不接受该字符集合。要匹配^ 字符本身，请使用\^。

{ 标记限定符表达式的开始。要匹配{，请使用\{。

非打印字符：正则表达式简介（微软篇）之九非打印字符

有不少很有用的非打印字符，偶尔必须使用。下表显示了用来表示这些非打印字符的转义序列：

字符含义

\cx 匹配由x指明的控制字符。例如，\cM 匹配一个Control-M 或回车符。
x 的值必须为A-Z 或a-z 之一。否则，将c 视为一个原义的'c' 字
符。

\f 匹配一个换页符。等价于\x0c 和\cL。

\n 匹配一个换行符。等价于\x0a 和\cJ。

\r 匹配一个回车符。等价于\x0d 和\cM。

\s 匹配任何空白字符，包括空格、制表符、换页符等等。等价于
[\f\n\r\t\v]。

\S 匹配任何非空白字符。等价于[^ \f\n\r\t\v]。

\t 匹配一个制表符。等价于\x09 和\cI。

\v 匹配一个垂直制表符。等价于\x0b 和\cK。

限定符：正则表达式简介（微软篇）之十一限定符

有时候不知道要匹配多少字符。为了能适应这种不确定性，正则表达式支持限定符的概念。这些限定符可以指定正则表达式的一个给定组件必须要出现多少次才能满足匹配。

下表给出了各种限定符及其含义的说明：

字符描述

* 匹配前面的子表达式零次或多次。例如，zo* 能匹配"z" 以及"zoo"。
* 等价于{0,}。

+ 匹配前面的子表达式一次或多次。例如，'zo+' 能匹配"zo" 以
及"zoo"，但不能匹配"z"。+ 等价于{1,}。

? 匹配前面的子表达式零次或一次。例如，"do(es)?" 可以匹配"do"
或"does" 中的"do" 。? 等价于{0,1}。

{n} n 是一个非负整数。匹配确定的n 次。例如，'o{2}' 不能匹配"Bob"
中的'o'，但是能匹配"food" 中的两个o。

{n,} n 是一个非负整数。至少匹配n 次。例如，'o{2,}' 不能匹配"Bob" 中
的'o'，但能匹配"foooood" 中的所有o。'o{1,}' 等价于'o+'。'o
{0,}' 则等价于'o*'。

{n,m} m 和n 均为非负整数，其中n <= m。最少匹配n 次且最多匹配m 次。
刘，"o{1,3}" 将匹配"fooooood" 中的前三个o。'o{0,1}' 等价
于'o?'。请注意在逗号和两个数之间不能有空格。

对一个很大的输入文档而言，章节数很轻易就超过九章，因此需要有一种方法来处理两位数或者三位数的章节号。限定符就提供了这个功能。下面的Visual Basic Scripting Edition 正则表达式可以匹配具有任何位数的章节标题：

/Chapter [1-9][0-9]*/

下面的 VBScript 正则表达式执行同样的匹配：

"Chapter [1-9][0-9]*"

请注意限定符出现在范围表达式之后。因此，它将应用于所包含的整个范围表达式，在本例中，只指定了从 0 到 9 的数字。

这里没有使用 '+' 限定符，因为第二位或后续位置上并不一定需要一个数字。同样也没有使用 '?' 字符，因为这将把章节数限制为只有两位数字。在 'Chapter' 和空格字符之后至少要匹配一个数字。

如果已知章节数限制只有99 章，则可以使用下面的 Visual Basic Scripting Edition 表达式来指定至少有一位数字，但不超过两个数字。

/Chapter [0-9]{1,2}/

对 VBScript 可以使用下述正则表达式：

"Chapter [0-9]{1,2}"

上述表达式的缺点是如果有一个章节号大于 99，它仍只会匹配前两位数字。另一个缺点是某些人可以创建一个 Chapter 0，而且仍能匹配。一个更好的用来匹配两位数的 Visual Basic Scripting Edition 表达式如下：

/Chapter [1-9][0-9]?/

或者

/Chapter [1-9][0-9]{0,1}/

对 VBScript 而言，下述表达式与上面等价：

"Chapter [1-9][0-9]?"

或者

"Chapter [1-9][0-9]{0,1}"

'*'、 '+'和 '?' 限定符都称之为贪婪的，也就是说，他们尽可能多地匹配文字。有时这根本就不是所希望发生的情况。有时则正好希望最小匹配。

例如，你可能要搜索一个 HTML 文档来查找一处包含在 H1 标记中的章节标题。在文档中该文字可能具有如下形式：

Chapter 1 - Introduction to Regular Expressions

下面的表达式匹配从开始的小于号 (<) 到 H1 标记结束处的大于号之间的所有内容。

/<.*>/

VBScript 的正则表达式为：

"<.*>"

如果所要匹配的就是开始的H1 标记，则下述非贪婪地表达式就只匹配
。

/<.*?>/

或者

"<.*?>"

通过在'*'、'+' 或'?' 限定符后放置'?'，该表达式就从贪婪匹配转为了非贪婪或最小匹配。

选择与编组：正则表达式简介（微软篇）之十三选择与编组

选择允许使用'　' 字符来在两个或多个候选项中进行选择。通过扩展章节标题的正则表达式，可以将其扩充为不仅仅适用于章节标题的表达式。不过，这可没有想象的那么直接。在使用选择时，将匹配'　' 字符每边最可能的表达式。你可能认为下面的Visual Basic Scripting Edition 和VBScript 表达式将匹配位于一行的开始和结束位置且后跟一个或两个数字的'Chapter' 或'Section'：

/^Chapter　Section [1-9][0-9]{0,1}$/
"^Chapter　Section [1-9][0-9]{0,1}$"

不幸的是，真正的情况是上面所示的正则表达式要么匹配位于一行开始处的单词'Chapter'，要么匹配一行结束处的后跟任何数字的'Section'。如果输入字符串为'Chapter 22'，上面的表达式将只匹配单词'Chapter'。如果输入字符串为'Section 22'，则该表达式将匹配'Section 22'。但这种结果不是我们此处的目的，因此必须有一种办法来使正则表达式对于所要做的更易于响应，而且确实也有这种方法。

可以使用圆括号来限制选择的范围，也就是说明确该选择只适用于这两个单词'Chapter' 和'Section'。不过，圆括号同样也是难处理的，因为它们也用来创建子表达式，有些内容将在后面关于子表达式的部分介绍。通过采用上面所示的正则表达式并在适当位置添加圆括号，就可以使该正则表达式既可以匹配'Chapter 1'，也可以匹配'Section 3'。

下面的正则表达式使用圆括号将'Chapter' 和'Section' 组成一组，所以该表达式才能正确工作。对Visual Basic Scripting Edition 为：

/^(Chapter　Section) [1-9][0-9]{0,1}$/

对VBScript 为：

"^(Chapter　Section) [1-9][0-9]{0,1}$"

这些表达式工作正确，只是产生了一个有趣的副产品。在'Chapter　Section' 两边放置圆括号建立了适当的编组，但也导致两个待匹配单词之一都被捕获供今后使用。由于在上面所示的表达式中只有一组圆括号，因此只能有一个捕获的submatch。可以使用VBScript 的Submatches 集合或者Visual Basic Scripting Edition 中RegExp 对象的$1-$9 属性来引用这个子匹配。

有时捕获一个子匹配是所希望的，有时则是不希望的。在说明所示的示例中，真正想做的就是使用圆括号对单词'Chapter' 或'Section' 之间的选择编组。并不希望在后面再引用该匹配。实际上，除非真的是需要捕获子匹配，否则请不要使用。由于不需要花时间和内存来存储那些子匹配，这种正则表达式的效率将更高。

可以在正则表达式模式圆括号内部的前面使用'?:'来防止存储该匹配供今后使用。对上面所示正则表达式的下述修改提供了免除子匹配存储的相同功能。对Visual Basic Scripting Edition：

/^(?:Chapter　Section) [1-9][0-9]{0,1}$/

对VBScript：

"^(?:Chapter　Section) [1-9][0-9]{0,1}$"

除了'?:' 元字符，还有两个非捕获元字符用于称之为预查的匹配。一个为正向预查，用?= 表示，在任何开始匹配圆括号内的正则表达式模式的位置来匹配搜索字符串。一个为负向预查，用'?!' 表示，在任何开始不匹配该正则表达式模式的位置来匹配搜索字符串。

例如，假定有一个包含引用有Windows 3.1、Windows 95、Windows 98 以及Windows NT 的文档。进一步假设需要更新该文档，方法是查找所有对Windows 95、Windows 98 以及Windows NT 的引用，并将这些引用更改为Windows 2000。可以使用下面的Visual Basic Scripting Edition 正则表达式，这是一个正向预查，来匹配Windows 95、Windows 98 以及Windows NT：

/Windows(?=95 　98 　NT )/

在VBScript 要进行同样的匹配可以使用下述表达式：

"Windows(?=95 　98 　NT )"

找到一个匹配后，紧接匹配到的文字（而不包括预查中使用的字符）就开始对下一次匹配的搜索。例如，如果上面所示的表达式匹配到'Windows 98'，则将从'Windows' 而不是'98' 之后继续查找。

后向引用：正则表达式简介（微软篇）之十四后向引用

正则表达式一个最重要的特性就是将匹配成功的模式的某部分进行存储供以后使用这一能力。请回想一下，对一个正则表达式模式或部分模式两边添加圆括号将导致这部分表达式存储到一个临时缓冲区中。可以使用非捕获元字符'?:', '?=', or '?!' 来忽略对这部分正则表达式的保存。

所捕获的每个子匹配都按照在正则表达式模式中从左至右所遇到的内容存储。存储子匹配的缓冲区编号从1 开始，连续编号直至最大99 个子表达式。每个缓冲区都可以使用'\n' 访问，其中n 为一个标识特定缓冲区的一位或两位十进制数。

后向引用一个最简单，最有用的应用是提供了确定文字中连续出现两个相同单词的位置的能力。请看下面的句子：

Is is the cost of of gasoline going up up?

根据所写内容，上面的句子明显存在单词多次重复的问题。如果能有一种方法无需查找每个单词的重复现象就能修改该句子就好了。下面的Visual Basic Scripting Edition 正则表达式使用一个子表达式就可以实现这一功能。

/\b([a-z]+) \1\b/gi

等价的VBScript 表达式为：

"\b([a-z]+) \1\b"

在这个示例中，子表达式就是圆括号之间的每一项。所捕获的表达式包括一个或多个字母字符，即由'[a-z]+' 所指定的。该正则表达式的第二部分是对前面所捕获的子匹配的引用，也就是由附加表达式所匹配的第二次出现的单词。'\1'用来指定第一个子匹配。单词边界元字符确保只检测单独的单词。如果不这样，则诸如"is issued" 或"this is" 这样的短语都会被该表达式不正确地识别。

在Visual Basic Scripting Edition 表达式中，正则表达式后面的全局标志('g') 表示该表达式将用来在输入字符串中查找尽可能多的匹配。大小写敏感性由表达式结束处的大小写敏感性标记('i') 指定。多行标记指定可能出现在换行符的两端的潜在匹配。对VBScript 而言，在表达式中不能设置各种标记，但必须使用RegExp 对象的属性来显式设置。

使用上面所示的正则表达式，下面的Visual Basic Scripting Edition 代码可以使用子匹配信息，在一个文字字符串中将连续出现两次的相同单词替换为一个相同的单词：

var ss = "Is is the cost of of gasoline going up up?.\n";
var re = /\b([a-z]+) \1\b/gim; //创建正则表达式样式.
var rv = ss.replace(re,"$1"); //用一个单词替代两个单词.

最接近的等价VBScript 代码如下：

Dim ss, re, rv
ss = "Is is the cost of of gasoline going up up?." & vbNewLine
Set re = New RegExp
re.Pattern = "\b([a-z]+) \1\b"
re.Global = True
re.IgnoreCase = True
re.MultiLine = True
rv = re.Replace(ss,"$1")

请注意在VBScript 代码中，全局、大小写敏感性以及多行标记都是使用RegExp 对象的适当属性来设置的。

在replace 方法中使用$1 来引用所保存的第一个子匹配。如果有多个子匹配，则可以用$2, $3 等继续引用。

后向引用的另一个用途是将一个通用资源指示符(URI) 分解为组件部分。假定希望将下述的URI 分解为协议(ftp, http, etc)，域名地址以及页面/路径：

http://msdn.microsoft.com:80/scripting/default.htm

下面的正则表达式可以提供这个功能。对Visual Basic Scripting Edition，为：

/(\w+):\/\/([^/:]+)(:\d*)?([^# ]*)/

对VBScript 为：

"(\w+):\/\/([^/:]+)(:\d*)?([^# ]*)"

第一个附加子表达式是用来捕获该web 地址的协议部分。该子表达式匹配位于一个冒号和两个正斜杠之前的任何单词。第二个附加子表达式捕获该地址的域名地址。该子表达式匹配不包括'^'、'/' 或':' 字符的任何字符序列。第三个附加子表达式捕获网站端口号码，如果指定了该端口号。该子表达式匹配后跟一个冒号的零或多个数字。最后，第四个附加子表达式捕获由该web 地址指定的路径以及\或者页面信息。该子表达式匹配一个和多个除'#' 或空格之外的字符。

将该正则表达式应用于上面所示的URI 后，子匹配包含下述内容：

RegExp.$1 包含"http"

RegExp.$2 包含"msdn.microsoft.com"

RegExp.$3 包含":80"

转自:http://blog.csdn.net/sheismylife/archive/2006/09/14/1221426.aspx

Technorati : 微软正则表达式, 正则表达式

本文链接

firefox 变慢解决方法,firefox 加速解决方法,Firefox启动慢等问题解决办法

2011-05-15T05:44:00Z

firefox 变慢解决方法,firefox 加速解决方法,Firefox启动慢等问题解决办法

firefox优化

总共四个步骤，另加一项（第五步，可选）

第一步如何加快浏览速度
首先在浏览器地址栏里输入“about:config”，等系统调用完毕之后按照下列步骤：
（1）更改　"network.http.pipelining"　为　ture
（2）更改　"network.http.proxy.pipelining" ture
（3）更改　"network.http.pipelining.maxrequests"为8，意思是同时可以接受8条申请

第二步如何减少Firefox(火狐)的内存占用量

输入about:config --〉点击右键，new-integer（整数） --〉输入 browser.cache.memory.capacity ---〉ok --〉输入数值，推荐16000。

第三步如何加速Firefox的启动速度

做法简单，右键点击你的桌面上firefox快捷方式，“属性”—>“快捷方式”—>“目标”，加参数“ /Prefetch:1”。即："D:\Program Files\Mozilla Ffox\firefox.exe" /Prefetch:1”（注意：“/”前有空格。这个D：是笔者Firefox的安装位置，请你根据自己的安装位置来，不要傻呼呼的连这也要问我呀。）

第四步设置信息反应

最后一步就是在Firefox再次输入“about:config”，在页面任何一个地方点右键，选择“New”—“Integer”在弹出的对话框中输入 “nglayout.initialpaint.delay”并将其值改为“0”，表示当浏览器收到网站回复的信息后能够快速的反应。

第五步另外

装了那个tabs插件以后 firefox启动慢了很多,要好几秒钟，让人难以忍受，其实firefox自身的简单设置其实完全可以摆脱TAB插件，实现完全在同一个firefox 窗口中浏览了。

（1）在firefox地址栏里输入"about:config"打开设置
（2）找到"browser.tabs.showsinglewindowmodeprefs" 双击修改其值为"True"
（3）打开firefox的Options(选项) 高级选项卡，找到标签页浏览设置，启用“强制打开新窗口的链接在下面打开”，选择子项中的“新标签页”。

*此外 browser.tabs.loaddivertedinbackground 选项可以改变新tab的载入方式，前台或者后台
True=在后台打开连接； False=在前台打开连接
*还可以鼠标中键(滚轮)关闭标签页，前提是middlemouse.contentLoadURL 值改"false" （默认）

问题：如何卸载、重装扩展

有的时候用ff卸载扩展时，“工具”－>“扩展”中老是出现该扩展将在重启后卸载字样，重启后依然。解决方法是：
（1）找到扩展位置
C:\Documents and Settings\用户名\Application Data\Mozilla\Firefox\Profiles\huktwibl.default\extensions
或者C:\Documents and Settings\Administrator\Application Data\Mozilla\Firefox\Profiles\imtf0pke.default\extensions
（2）删掉extensions中所有内容，除 Extensions.rdf外
（3）重启ff，进入“工具”－>“扩展”，不管它，再卸载一次
（4）退出重启后就好了，可以挑选自己需要的扩展安装

本文链接