经过努力终于在 引入局部统计识别高频词汇的Lucene中文分词程序 以及 基于词典的最大匹配的Lucene中文分词程序 把中文人名识别功能加入,能把大部分的中文姓名识别出来,结果喜人。

原理:

根据贝叶斯定理,分别建立中文形式库FirstName.stu,从网上搜集得到的真实姓名库Name.stu,以及以姓氏为开头但非中文姓名的词库(如“曾经是”,“关门”,“陈述”等)UnName.stu。然后先使用之前完成的基于词典的最大匹配分词算法对文本进行初步分词,然后利用Spring的AOP把人名识别器SimpleChineseNameAnalyzer编织到初步分词方法执行之后,利用姓氏驱动的方式遍历分词碎片,找到所有以姓氏开头后两个分词结果为单字或后一个分词结果为双字词的碎片(成为候选词),分别从Name.stu以及UnName.stu中获取姓氏以及各个名字成为姓名的概率,最后判断候选词前后是否存在边界词汇,若有则对其进行概率调整,最终通过与阀值的比较判断是否是一个中文姓名。

用法:

java 代码
  1. ApplicationContext context = new FileSystemXmlApplicationContext("STUSegmentConfig.xml");   
  2. STUChineseAnalyzer analyzer = (STUChineseAnalyzer) context .getBean("stuChineseAnalyzer");  

测试数据:

东方网记者靳慧、张海盈、实习生霍世杰5月20日报道:今天上午10点,同济大学建校100周年庆典大会在同济大学大礼堂隆重举行。中共中央总书记、国家主席胡锦涛发来贺信。全国人大常委会副委员长李铁映,全国人大常委会副委员长顾秀莲,国务委员陈至立,中共上海市委书记习近平,德国前总理施罗德,中央纪委副书记张惠新,教育部部长周济,建设部部长汪光焘,中共上海市委副书记、市长韩正,科技部党组书记、副部长李学勇等出席庆典大会。

  庆典大会上首先宣读胡锦涛总书记贺信,之后科技部部长、同济大学校长万钢从“大学对社会的承诺”的角度讲述百年同济的辉煌历史和未来发展。来自德国柏林工业大学的校长库茨勒、中国科学院院士吴孟超、同济大学交通运输工程学院孙立军等也将作为友好学校代表、校友代表、师生代表先后致辞。

  今天早晨8点开始,同济大学的师生、老校友们就陆续进入庆典大会会场,会场大屏幕上滚动播放着建校100周年的宣传片。庆典大会开始前举行了同济老校友互动活动,现场十分感人。

  同济大学是教育部直属重点大学,创建于1907年,早期为德国医生在上海创办的德文医学堂,取名"同济"意蕴合作共济。1912年增设工学堂,1923年被批准改名为大学,1927年正式定为国立同济大学。抗战期间曾内迁经浙、赣、滇入川,1946年回迁上海并发展为以拥有理、工、医、文、法五大学院著称海内外的综合性大学。1952年院系调整后,同济大学成为国内土木建筑领域最大、专业最全的工科大学。

  1978年经中央批准恢复对德交流,在中科院学部委员李国豪校长领导下实行“两个转变”,即由土木为主的理工科大学向理工为主的多科性大学转变,由国内普通高校向作为中外文化交流“窗口”之一的国际性大学转变,从而迅速恢复和发展成为一所以工为主、理工结合,经、管、文、法各具特色的多科性大学。

测试结果:

  1. (东方,0,2)   
  2. (网,2,3)   
  3. (记者,3,5)   
  4. (靳慧,5,7)   
  5. (张海盈,8,11)   
  6. (实习生,12,15)   
  7. (霍世杰,15,18)   
  8. (5,18,19)   
  9. (月,19,20)   
  10. (20,20,22)   
  11. (日报,22,24)   
  12. (道,24,25)   
  13. (今天,26,28)   
  14. (上午,28,30)   
  15. (10,30,32)   
  16. (点,32,33)   
  17. (同济大学,34,38)   
  18. (建校,38,40)   
  19. (100,40,43)   
  20. (周年,43,45)   
  21. (庆典,45,47)   
  22. (大会,47,49)   
  23. (在,49,50)   
  24. (同济大学,50,54)   
  25. (大礼堂,54,57)   
  26. (隆重举行,57,61)   
  27. (中共中央总书记,62,69)   
  28. (国家主席,70,74)   
  29. (胡锦涛,74,77)   
  30. (发来,77,79)   
  31. (贺信,79,81)   
  32. (全国人大常委会,82,89)   
  33. (副委员长,89,93)   
  34. (李铁映,93,96)   
  35. (全国人大常委会,97,104)   
  36. (副委员长,104,108)   
  37. (顾秀莲,108,111)   
  38. (国务委员,112,116)   
  39. (陈至立,116,119)   
  40. (中共,120,122)   
  41. (上海市,122,125)   
  42. (委,125,126)   
  43. (书记,126,128)   
  44. (习近平,128,131)   
  45. (德国,132,134)   
  46. (前总理,134,137)   
  47. (施,137,138)   
  48. (罗德,138,140)   
  49. (中央纪委,141,145)   
  50. (副书记,145,148)   
  51. (张惠新,148,151)   
  52. (教育部,152,155)   
  53. (部长,155,157)   
  54. (周济,157,159)   
  55. (建设部,160,163)   
  56. (部长,163,165)   
  57. (汪光焘,165,168)   
  58. (中共,169,171)   
  59. (上海市,171,174)   
  60. (委,174,175)   
  61. (副书记,175,178)   
  62. (市长,179,181)   
  63. (韩正,181,183)   
  64. (科技部,184,187)   
  65. (党组书记,187,191)   
  66. (副部长,192,195)   
  67. (李学勇,195,198)   
  68. (等,198,199)   
  69. (出席,199,201)   
  70. (庆典,201,203)   
  71. (大会,203,205)   
  72. (庆典,210,212)   
  73. (大会,212,214)   
  74. (上首,214,216)   
  75. (先,216,217)   
  76. (宣读,217,219)   
  77. (胡锦涛,219,222)   
  78. (总书记,222,225)   
  79. (贺信,225,227)   
  80. (之后,228,230)   
  81. (科技部,230,233)   
  82. (部长,233,235)   
  83. (同济大学,236,240)   
  84. (校长,240,242)   
  85. (万,242,243)   
  86. (钢,243,244)   
  87. (从,244,245)   
  88. (大学,246,248)   
  89. (对,248,249)   
  90. (社会,249,251)   
  91. (的,251,252)   
  92. (承诺,252,254)   
  93. (的,255,256)   
  94. (角度,256,258)   
  95. (讲述,258,260)   
  96. (百年,260,262)   
  97. (同济,262,264)   
  98. (的,264,265)   
  99. (辉煌,265,267)   
  100. (历史,267,269)   
  101. (和,269,270)   
  102. (未来,270,272)   
  103. (发展,272,274)   
  104. (来自,275,277)   
  105. (德国,277,279)   
  106. (柏林,279,281)   
  107. (工业大学,281,285)   
  108. (的,285,286)   
  109. (校长,286,288)   
  110. (库,288,289)   
  111. (茨,289,290)   
  112. (勒,290,291)   
  113. (中国科学院,292,297)   
  114. (院士,297,299)   
  115. (吴孟超,299,302)   
  116. (同济大学,303,307)   
  117. (交通运输,307,311)   
  118. (工程学院,311,315)   
  119. (孙立军,315,318)   
  120. (等,318,319)   
  121. (也将,319,321)   
  122. (作为,321,323)   
  123. (友好,323,325)   
  124. (学校,325,327)   
  125. (代表,327,329)   
  126. (校友,330,332)   
  127. (代表,332,334)   
  128. (师生,335,337)   
  129. (代表,337,339)   
  130. (先后,339,341)   
  131. (致辞,341,343)   
  132. (今天,348,350)   
  133. (早晨,350,352)   
  134. (8,352,353)   
  135. (点开,353,355)   
  136. (始,355,356)   
  137. (同济大学,357,361)   
  138. (的,361,362)   
  139. (师生,362,364)   
  140. (老,365,366)   
  141. (校友,366,368)   
  142. (们,368,369)   
  143. (就,369,370)   
  144. (陆续,370,372)   
  145. (进入,372,374)   
  146. (庆典,374,376)   
  147. (大会,376,378)   
  148. (会场,378,380)   
  149. (会场,381,383)   
  150. (大屏幕,383,386)   
  151. (上,386,387)   
  152. (滚动,387,389)   
  153. (播放,389,391)   
  154. (着,391,392)   
  155. (建校,392,394)   
  156. (100,394,397)   
  157. (周年,397,399)   
  158. (的,399,400)   
  159. (宣传片,400,403)   
  160. (庆典,404,406)   
  161. (大会,406,408)   
  162. (开始,408,410)   
  163. (前,410,411)   
  164. (举行,411,413)   
  165. (了,413,414)   
  166. (同济,414,416)   
  167. (老,416,417)   
  168. (校友,417,419)   
  169. (互动,419,421)   
  170. (活动,421,423)   
  171. (现场,424,426)   
  172. (十分,426,428)   
  173. (感人,428,430)   
  174. (同济大学,435,439)   
  175. (是,439,440)   
  176. (教育部,440,443)   
  177. (直属,443,445)   
  178. (重点,445,447)   
  179. (大学,447,449)   
  180. (创建,450,452)   
  181. (于,452,453)   
  182. (1907,453,457)   
  183. (年,457,458)   
  184. (早期,459,461)   
  185. (为,461,462)   
  186. (德国,462,464)   
  187. (医生,464,466)   
  188. (在上,466,468)   
  189. (海,468,469)   
  190. (创办,469,471)   
  191. (的,471,472)   
  192. (德文,472,474)   
  193. (医学,474,476)   
  194. (堂,476,477)   
  195. (取名,478,480)   
  196. (同济,481,483)   
  197. (意蕴,484,486)   
  198. (合作,486,488)   
  199. (共,488,489)   
  200. (济,489,490)   
  201. (1912,491,495)   
  202. (年,495,496)   
  203. (增设,496,498)   
  204. (工学,498,500)   
  205. (堂,500,501)   
  206. (1923,502,506)   
  207. (年,506,507)   
  208. (被,507,508)   
  209. (批准,508,510)   
  210. (改名,510,512)   
  211. (为大,512,514)   
  212. (学,514,515)   
  213. (1927,516,520)   
  214. (年,520,521)   
  215. (正式,521,523)   
  216. (定为,523,525)   
  217. (国立,525,527)   
  218. (同济大学,527,531)   
  219. (抗战,532,534)   
  220. (期间,534,536)   
  221. (曾,536,537)   
  222. (内迁,537,539)   
  223. (经,539,540)   
  224. (浙,540,541)   
  225. (赣,542,543)   
  226. (滇,544,545)   
  227. (入,545,546)   
  228. (川,546,547)   
  229. (1946,548,552)   
  230. (年,552,553)   
  231. (回迁,553,555)   
  232. (上海,555,557)   
  233. (并发,557,559)   
  234. (展,559,560)   
  235. (为,560,561)   
  236. (以,561,562)   
  237. (拥有,562,564)   
  238. (理,564,565)   
  239. (工,566,567)   
  240. (医,568,569)   
  241. (文,570,571)   
  242. (法,572,573)   
  243. (五大,573,575)   
  244. (学院,575,577)   
  245. (著称,577,579)   
  246. (海内外,579,582)   
  247. (的,582,583)   
  248. (综合性,583,586)   
  249. (大学,586,588)   
  250. (1952,589,593)   
  251. (年,593,594)   
  252. (院系,594,596)   
  253. (调整,596,598)   
  254. (后,598,599)   
  255. (同济大学,600,604)   
  256. (成为,604,606)   
  257. (国内,606,608)   
  258. (土木,608,610)   
  259. (建筑,610,612)   
  260. (领域,612,614)   
  261. (最大,614,616)   
  262. (专业,617,619)   
  263. (最全,619,621)   
  264. (的,621,622)   
  265. (工科大学,622,626)   
  266. (1978,631,635)   
  267. (年,635,636)   
  268. (经,636,637)   
  269. (中央,637,639)   
  270. (批准,639,641)   
  271. (恢复,641,643)   
  272. (对,643,644)   
  273. (德,644,645)   
  274. (交流,645,647)   
  275. (在,648,649)   
  276. (中科院,649,652)   
  277. (学部委员,652,656)   
  278. (李国豪,656,659)   
  279. (校长,659,661)   
  280. (领导,661,663)   
  281. (下,663,664)   
  282. (实行,664,666)   
  283. (两个转变,667,671)   
  284. (即,673,674)   
  285. (由,674,675)   
  286. (土木,675,677)   
  287. (为主,677,679)   
  288. (的,679,680)   
  289. (理工科,680,683)   
  290. (大学,683,685)   
  291. (向,685,686)   
  292. (理工,686,688)   
  293. (为主,688,690)   
  294. (的,690,691)   
  295. (多科,691,693)   
  296. (性,693,694)   
  297. (大学,694,696)   
  298. (转变,696,698)   
  299. (由,699,700)   
  300. (国内,700,702)   
  301. (普通,702,704)   
  302. (高校,704,706)   
  303. (向,706,707)   
  304. (作为,707,709)   
  305. (中外文,709,712)   
  306. (化,712,713)   
  307. (交流,713,715)   
  308. (窗口,716,718)   
  309. (之一,719,721)   
  310. (的,721,722)   
  311. (国际性,722,725)   
  312. (大学,725,727)   
  313. (转变,727,729)   
  314. (从而,730,732)   
  315. (迅速,732,734)   
  316. (恢复,734,736)   
  317. (和,736,737)   
  318. (发展,737,739)   
  319. (成为,739,741)   
  320. (一所,741,743)   
  321. (以,743,744)   
  322. (工,744,745)   
  323. (为主,745,747)   
  324. (理工,748,750)   
  325. (结合,750,752)   
  326. (经,753,754)   
  327. (管,755,756)   
  328. (文,757,758)   
  329. (法,759,760)   
  330. (各具特色,760,764)   
  331. (的,764,765)   
  332. (多科,765,767)   
  333. (性,767,768)   
  334. (大学,768,770)  
  • Dic.rar (847.9 KB)
  • 描述: 词典
  • 下载次数: 202
评论
billgmh 2007-06-08   回复
caocao 写道
这些算法是不错,我本来也要做这方面的分词,后来因为分词是给搜索引擎用的,必须确保分词结果在任何情况下保持一致,所以依靠概率、权值之类的算法不太适合使用,结果就没有用。
请问你的分词用在什么场合?如果也是给搜索引擎用,我建议你还不如不去分这些人名,搞一个现成的人名库比较合适,主要是为了保证分词结果一致性。
我相当赞同你的对分词后的碎片进行权值计算,我也是这么设想的 :)
我的分词算法是用于网络小说搜索引擎的,我原本打算用于识别获得的小说主角人名,然后提供小说主角搜索的,但是听到你的分析后,可得重新考虑了
caocao 2007-06-08   回复
这些算法是不错,我本来也要做这方面的分词,后来因为分词是给搜索引擎用的,必须确保分词结果在任何情况下保持一致,所以依靠概率、权值之类的算法不太适合使用,结果就没有用。
请问你的分词用在什么场合?如果也是给搜索引擎用,我建议你还不如不去分这些人名,搞一个现成的人名库比较合适,主要是为了保证分词结果一致性。
我相当赞同你的对分词后的碎片进行权值计算,我也是这么设想的
billgmh 2007-06-08   回复
caocao 写道
billgmh 写道
大家使用后感觉如何呢?能帮忙提一些建议吗?谢谢
还没用过,相信是很不错的,谢谢你贴出代码与大家分享。
问个问题,如果建索引的时候用这个方法来分词,对于人名是否能确保该人名无论出现在任何文章里都能分出来?用户搜索的时候如果仅输入该人名或该人名前后接几个字,是否还能准确分出人名来?这个对于搜索来说至关重要,如果分词结果是不确定的,那么就存在无法搜到结果的可能。
同样,高频词分词也存在着这个问题,我相信,这个问题更严重,用户仅仅输入该高频词将导致分词结果不确定,也就是可能无法找到用户想要的结果。
1、首先我的人名识别有一个人工干预学习的过程,也就是说当对某篇文章进行分词、人名识别后,我会把识别获得的人名放入到临时词表中,当下一次文章中再次出现类似于这个人名的字符串时,我会对进行权值计算进行修正,提高它的权值,是它更容易被识别出来。

2、对于楼上提到第二种情况对输入用于检索的带人名的字符串时,也还是会对分词后的碎片进行权值计算,假如该人名在前后是一些显著的边界词汇,那将更能把人名提取出来。

不过目前我的人名识别对一些比较稀有的姓氏的人名识别能力不足,会错误识别,可能是人名库与非人名库的数量不够庞大而导致的。
caocao 2007-06-08   回复
billgmh 写道
大家使用后感觉如何呢?能帮忙提一些建议吗?谢谢
还没用过,相信是很不错的,谢谢你贴出代码与大家分享。
问个问题,如果建索引的时候用这个方法来分词,对于人名是否能确保该人名无论出现在任何文章里都能分出来?用户搜索的时候如果仅输入该人名或该人名前后接几个字,是否还能准确分出人名来?这个对于搜索来说至关重要,如果分词结果是不确定的,那么就存在无法搜到结果的可能。
同样,高频词分词也存在着这个问题,我相信,这个问题更严重,用户仅仅输入该高频词将导致分词结果不确定,也就是可能无法找到用户想要的结果。
billgmh 2007-06-07   回复
大家使用后感觉如何呢?能帮忙提一些建议吗?谢谢
billgmh 2007-05-24   回复

Part 3

java 代码
  1.                     // 情况1:单双名竞争   
  2.                     double singleValue = this.getFirstNameValue(srcList   
  3.                             .get(startPos))   
  4.                             * this.getGivenNameValue(fch);   
  5.                     double doubleValue = this.getFirstNameValue(srcList   
  6.                             .get(startPos))   
  7.                             * Math.sqrt(this.getGivenNameValue(fch)   
  8.                                     * this.getGivenNameValue(sch));   
  9.   
  10.                     // 对startPos-1处为左边界的价值进行递增   
  11.                     if (startPos > 0  
  12.                             && ((this.leftVergeDic != null && this.leftVergeDic   
  13.                                     .match(srcList.get(startPos - 1))) || srcList   
  14.                                     .get(startPos - 1).equals("\n")))   
  15.                     {   
  16.                         singleValue *= M;   
  17.                         doubleValue *= M;   
  18.                     }   
  19.                     // 对endPos+1处为右边界词的价值进行递增   
  20.                     if (endPos + 1 < srcList.size()   
  21.                             && this.rightVergeDic != null  
  22.                             && this.rightVergeDic.match(srcList   
  23.                                     .get(endPos + 1)))   
  24.                         doubleValue *= M;   
  25.                     // 如果临时数据库中有这个姓名则价值递增   
  26.                     if (this.tempNameDic != null  
  27.                             && this.tempNameDic.containsKey(srcList   
  28.                                     .get(startPos)   
  29.                                     + fch))   
  30.                         singleValue *= M;   
  31.                     if (this.tempNameDic != null  
  32.                             && this.tempNameDic.containsKey(tempName))   
  33.                         doubleValue *= M;   
  34.   
  35.                     // // hades print   
  36.                     // System.out.println(tempName + "\tSingle:" +   
  37.                     // singleValue   
  38.                     // + "\tDouble:" + doubleValue);   
  39.   
  40.                     // 标示是否已进行合并操作   
  41.                     boolean finish = false;   
  42.                     // 当fch也为姓氏是激发情况2   
  43.                     if (srcList.get(startPos).length() == 1  
  44.                             && firstNameDic.match(fch))   
  45.                     {   
  46.                         // 情况2:姓氏竞争   
  47.                         double nameValue = this.getFirstNameValue(fch)   
  48.                                 * this.getGivenNameValue(sch);   
  49.   
  50.                         // 对endPos+1处为右边界词的价值进行递增   
  51.                         if (endPos + 1 < srcList.size()   
  52.                                 && this.rightVergeDic != null  
  53.                                 && this.rightVergeDic.match(srcList   
  54.                                         .get(endPos + 1)))   
  55.                             nameValue *= M;   
  56.                         // 如果临时数据库中有这个姓名则价值递增   
  57.                         if (this.tempNameDic != null  
  58.                                 && this.tempNameDic.containsKey(fch + sch))   
  59.                             nameValue *= M;   
  60.   
  61.                         // // hades print   
  62.                         // System.out   
  63.                         // .println(tempName + "\tLast:" + nameValue);   
  64.                         // System.out.println();   
  65.   
  66.                         // 当最后两字成为名字的概率最大且大于阀值时   
  67.                         if (nameValue > this.setpoint   
  68.                                 && nameValue > singleValue   
  69.                                 && nameValue > doubleValue)   
  70.                         {   
  71.                             // 判断fch与sch是否已组合为词   
  72.                             if (endPos - startPos == 1)   
  73.                             {   
  74.                                 startPos = endPos + 1;   
  75.                                 finish = true;   
  76.                             }   
  77.                             else  
  78.                             {   
  79.                                 // hades 姓名识别   
  80.                                 srcList.set(endPos - 1, fch + sch);   
  81.                                 // 放入临时数据库   
  82.                                 if (this.tempNameDic != null)   
  83.                                 {   
  84.                                     this.tempNameDic.put(srcList   
  85.                                             .get(endPos - 1), tempName);   
  86.                                 }   
  87.                                 srcList.remove(endPos);   
  88.                                 // 若果fch也是姓氏则以它为startPos多计算一次   
  89.                                 if (firstNameDic.match(fch))   
  90.                                     startPos = endPos - 1;   
  91.                                 else  
  92.                                     startPos = endPos;   
  93.                                 finish = true;   
  94.                             }   
  95.                             // end of if(endPos-startPos==1)   
  96.                         }   
  97.                     }   
  98.                     // end of   
  99.                     // if(srcList.get(startPos).length()==1&&firstNameDic.match(fch))   
  100.                     if (!finish)   
  101.                     {   
  102.                         // 单字姓名胜出   
  103.                         if (singleValue > this.setpoint   
  104.                                 && singleValue > doubleValue)   
  105.                         {   
  106.                             // hades 姓名识别   
  107.                             srcList.set(startPos, srcList.get(startPos)   
  108.                                     + fch);   
  109.                             // 放入临时数据库   
  110.                             if (this.tempNameDic != null)   
  111.                                 this.tempNameDic.put(srcList.get(startPos),   
  112.                                         tempName);   
  113.                             srcList.set(startPos + 1, sch);   
  114.                             // 双单字情况   
  115.                             if (endPos - startPos == 2)   
  116.                             {   
  117.                                 srcList.remove(endPos);   
  118.                             }   
  119.                             startPos += 2;   
  120.                         }   
  121.                         // 双字姓名胜出   
  122.                         else if (doubleValue > this.setpoint   
  123.                                 && doubleValue >= singleValue)   
  124.                         {   
  125.                             // hades 姓名识别   
  126.                             srcList.set(startPos, tempName);   
  127.                             // 放入临时数据库   
  128.                             if (this.tempNameDic != null)   
  129.                                 this.tempNameDic.put(tempName, tempName);   
  130.                             for (int i = startPos; i < endPos; i++)   
  131.                                 srcList.remove(startPos + 1);   
  132.                             startPos++;   
  133.                         }   
  134.                         else  
  135.                         {   
  136.                             startPos = endPos + 1;   
  137.                         }   
  138.                         // end of if(singleValue>doubleValue)   
  139.                     }   
  140.                     // end of if(!finish);   
  141.                 }   
  142.                 else  
  143.                 {   
  144.                     // 单字姓名处理   
  145.                     double nameValue = this.getFirstNameValue(srcList   
  146.                             .get(startPos))   
  147.                             * this.getGivenNameValue(srcList.get(endPos));   
  148.                     // 对startPos-1处为左边界词的价值进行递增   
  149.                     if (startPos > 0  
  150.                             && ((this.leftVergeDic != null && this.leftVergeDic   
  151.                                     .match(srcList.get(startPos - 1))) || srcList   
  152.                                     .get(startPos - 1).equals("\n")))   
  153.                         nameValue *= M;   
  154.   
  155.                     // 对endPos+1处为右边界的价值进行递增   
  156.                     if (endPos + 1 < srcList.size()   
  157.                             && this.rightVergeDic != null  
  158.                             && this.rightVergeDic.match(srcList   
  159.                                     .get(endPos + 1)))   
  160.                         nameValue *= M;   
  161.                     // 如果临时数据库中有这个姓名则价值递增   
  162.                     if (this.tempNameDic != null  
  163.                             && this.tempNameDic.containsKey(tempName))   
  164.                         nameValue *= M;   
  165.   
  166.                     if (nameValue > this.setpoint)   
  167.                     {   
  168.                         // hades 姓名识别   
  169.                         // 合并字符串   
  170.                         srcList.set(startPos, tempName);   
  171.                         // 放入临时数据库   
  172.                         if (this.tempNameDic != null)   
  173.                             this.tempNameDic.put(tempName, tempName);   
  174.                         for (int i = startPos; i < endPos; i++)   
  175.                             srcList.remove(startPos + 1);   
  176.                         startPos++;   
  177.                     }   
  178.                     else  
  179.                     {   
  180.                         startPos = endPos + 1;   
  181.                     }   
  182.                     // end of if(nameValue>this.setpoint)   
  183.                 }   
  184.                 // end of if(doubleOrNot)   
  185.             }   
  186.             // end of if(this.nameDic.match(tempName))   
  187.   
  188.         }   
  189.         // end of if(srcList.get(endPos).length()>2)   
  190.     }   
  191.     return srcList;   
  192. }   
  193.   
  194. /**  
  195.  * 设置阀值  
  196.  *   
  197.  * @param setpoint  
  198.  *            要设置的 setpoint。  
  199.  */  
  200. public void setSetpoint(double setpoint)   
  201. {   
  202.     this.setpoint = setpoint;   
  203. }   
billgmh 2007-05-24   回复

Part 2

java 代码
  1. /**  
  2.  * 对输入的原分词结果srcList进行中文人名识别  
  3.  *   
  4.  * @param srcList  
  5.  *            原分词结果  
  6.  * @return 中文人名识别处理后的分词结果  
  7.  */  
  8. @Override  
  9. public List<String> identify(List<String> srcList)   
  10. {   
  11.     // 获取姓氏词典   
  12.     ChineseFirstNameDictionary firstNameDic = nameDic.getFirstNameDic();   
  13.     // 初始化区间位移   
  14.     int startPos = 0, endPos = 0;   
  15.     // 循环   
  16.     while (startPos < srcList.size())   
  17.     {   
  18.         // 表示startPos位置不是姓氏的情况   
  19.         boolean isNotFirstName = startPos < srcList.size()   
  20.                 && (srcList.get(startPos).length() != 1 || srcList.get(   
  21.                         startPos).length() != 2)   
  22.                 && !firstNameDic.match(srcList.get(startPos));   
  23.         // 表示startPos位置是以姓氏开头且词长为2的情况   
  24.         boolean isBeginWithFirstName = startPos < srcList.size()   
  25.                 && srcList.get(startPos).length() == 2  
  26.                 && firstNameDic   
  27.                         .match(srcList.get(startPos).substring(01))   
  28.                 && this.getFirstNameValue(srcList.get(startPos).substring(   
  29.                         01)) > 0.5 && this.leftVergeDic != null  
  30.                 && startPos > 0 && startPos + 1 < srcList.size()   
  31.                 && this.leftVergeDic.match(srcList.get(startPos - 1))   
  32.                 && this.seperator.indexOf(srcList.get(startPos + 1)) < 0;   
  33.   
  34.         // 寻找分词结果中姓氏的位置   
  35.         while (isNotFirstName && !isBeginWithFirstName)   
  36.         {   
  37.             startPos++;   
  38.             // 表示startPos位置不是姓氏的情况   
  39.             isNotFirstName = startPos < srcList.size()   
  40.                     && (srcList.get(startPos).length() != 1 || srcList.get(   
  41.                             startPos).length() != 2)   
  42.                     && !firstNameDic.match(srcList.get(startPos));   
  43.             // 表示startPos位置是以姓氏开头且词长为2的情况   
  44.             isBeginWithFirstName = startPos < srcList.size()   
  45.                     && srcList.get(startPos).length() == 2  
  46.                     && firstNameDic.match(srcList.get(startPos).substring(   
  47.                             01))   
  48.                     && this.getFirstNameValue(srcList.get(startPos)   
  49.                             .substring(01)) > 0.5  
  50.                     && this.leftVergeDic != null  
  51.                     && startPos > 0  
  52.                     && startPos + 1 < srcList.size()   
  53.                     && this.leftVergeDic.match(srcList.get(startPos - 1))   
  54.                     && this.seperator.indexOf(srcList.get(startPos + 1)) < 0;   
  55.         }   
  56.         // 如果startPos位置是以姓氏以姓氏开头且词长为2   
  57.         if (isBeginWithFirstName)   
  58.         {   
  59.             String f = srcList.get(startPos).substring(01);   
  60.             String s = srcList.get(startPos).substring(1);   
  61.             srcList.se