fullfocus--年轻不怕失败 http://fullfocus.javaeye.com UTF-8 Copyright 2003-2008, JavaEye.com http://blogs.law.harvard.edu/tech/rss JavaEye - 做最棒的软件开发交流社区 //pku1006 源代码分析 fullfocus 作者: fullfocus  链接：http://fullfocus.javaeye.com/blog/137210  发表时间: 2007年11月01日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

java 代码
 
  1. //pku1006 源代码分析  
  2. //注释掉的是第一次写的，用的是穷举的方法，输出结//果都正确，但是time limited，想想也是哦，这么  
  3. //做，三次循环，不超时才怪啊，  
  4. //现在的代码采用逆推方法，一个循环，快多了：）  
  5. //总结：写代码，首要的是解题思路要对头，要高效，//然后有可能才考虑代码优化，性能提高的问题！！！//切记！！  
  6. package com.pku;  
  7. import java.io.*;  
  8. import java.util.*;  
  9.   
  10.   
  11. public class Pku1006 {  
  12.   
  13. /** 
  14. * @param args 
  15. */  
  16. public static void main(String[] args) {  
  17. // TODO Auto-generated method stub  
  18. Scanner cin = new Scanner(new BufferedInputStream(System.in));  
  19. int p = 0;  
  20. int e = 0;  
  21. int i = 0;  
  22. int d = 0;  
  23. int n = 0;  
  24. int t = 1;  
  25. while(cin.hasNext())  
  26. {  
  27. p = cin.nextInt();  
  28. e = cin.nextInt();  
  29. i = cin.nextInt();  
  30. d = cin.nextInt();  
  31. if(p == -1) break;  
  32. else  
  33. {  
  34. System.out.print("Case"+ ' '+ t + ": the next triple peak occurs in ");  
  35. for(n = d+1; n<=21253 + d;n++)  
  36. {  
  37. if(Math.abs(n-p)%23==0&&Math.abs(n-e)%28==0&&Math.abs(n-i)%33==0)  
  38. {  
  39. System.out.println((n-d)+ " days.");  
  40. break;  
  41. }  
  42. }  
  43. }  
  44. t++;  
  45. }  
  46. }  
  47. }  
  48.   
  49. //有的时候是思想方法不多，才使程序通不过，只有思想方法，解题方法正确以后，才考虑程序的优化问题，才有意义！  
  50. // 自已编写的可以得出正确结果，但是TIME LIMITED~:(  
  51. // int nextPeak(int p, int e, int i,int d)  
  52. // {  
  53. // int x = 0;  
  54. // for(x = 1; x < (21252+365)/23; x++)  
  55. // for(int y=1; y < (21252+365)/28; y++)  
  56. // for(int z=1; z < ((21252+365)/33); z++)  
  57. // {  
  58. // if((p+23*x) == (e + 28*y )&& (e + 28*y) == (i + 33*z))  
  59. // {  
  60. // if( p + 23*x <= d)  
  61. // return nextPeak(d + 23*x ,d + 23*x ,d + 23*x ,d);  
  62. // else return p +23*x -d;  
  63. // }  
  64. // }  
  65. // return p +23*x -d;  
  66. // }  
  67. // public static void main(String[] args) {  
  68. // // TODO Auto-generated method stub  
  69. // Scanner cin = new Scanner(new BufferedInputStream(System.in));  
  70. // Pku1006 pku1006 = new Pku1006();  
  71. // int p = 0;  
  72. // int e = 0;  
  73. // int i = 0;  
  74. // int d = 0;  
  75. // int days = 0;  
  76. // int k = 1;  
  77. // int first = 0;  
  78. // while(cin.hasNext())  
  79. // {  
  80. // if( (first = cin.nextInt())== -1)  
  81. // {  
  82. // if(cin.nextInt()== -1&&cin.nextInt()== -1&&cin.nextInt()== -1)  
  83. // {  
  84. //  
  85. // return;  
  86. // }  
  87. // }  
  88. // else{  
  89. // p = first;  
  90. // e = cin.nextInt();  
  91. // i = cin.nextInt();  
  92. // d = cin.nextInt();  
  93. // days = pku1006.nextPeak(p,e,i,d);  
  94. // System.out.println("Case "+k+": the next triple peak occurs in "+days+" days.");  
  95. // k++;  
  96. // }  
  97. // }  
  98. //  
  99. // }  

本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Thu, 01 Nov 2007 10:51:44 +0800 http://fullfocus.javaeye.com/blog/137210 http://fullfocus.javaeye.com/blog/137210 pku1005 fullfocus 作者: fullfocus  链接：http://fullfocus.javaeye.com/blog/136161  发表时间: 2007年10月28日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

//http://acm.pku.edu.cn/JudgeOnline/
java 代码
 
  1. //http://acm.pku.edu.cn/JudgeOnline/  
  2. package com.pku;  
  3. import java.io.*;  
  4. import java.util.*;  
  5. import java.lang.Math;  
  6.   
  7. public class Pku1005 {  
  8.   
  9.         /** 
  10.          * @param args 
  11.          */  
  12.         double semisquare(double x, double y)  
  13.         {  
  14.             double length = Math.sqrt(x*x + y*y);  
  15.             return Math.PI * length *length/2;  
  16.         }  
  17.         public static void main(String[] args) {  
  18.             // TODO Auto-generated method stub  
  19.             Scanner cin = new Scanner(new BufferedInputStream(System.in));  
  20.             Pku1005 pku1005 = new Pku1005();  
  21.             int n = cin.nextInt();  
  22.             double x = 0, y = 0;  
  23.             double square = 0.0;  
  24.             double temp = 0.0;  
  25.             int i = 1;      
  26.             while(i <= n)  
  27.             {  
  28.                 x = cin.nextDouble();  
  29.                 y = cin.nextDouble();  
  30.                 square = pku1005.semisquare(x, y);  
  31.                 System.out.println("Property "+ i +": This property will begin eroding in year "+ (int)(square/50+1) +".");  
  32.                 i++;                      
  33.             }  
  34.             System.out.println("END OF OUTPUT.");  
  35.         }  
  36.   
  37. }  
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Sun, 28 Oct 2007 17:25:58 +0800 http://fullfocus.javaeye.com/blog/136161 http://fullfocus.javaeye.com/blog/136161 pku1004 fullfocus 作者: fullfocus  链接：http://fullfocus.javaeye.com/blog/136148  发表时间: 2007年10月28日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

java 代码
 
  1. import java.io.*;  
  2. import java.util.*;  
  3. import java.text.*;  
  4.   
  5. public class Pku1004 {  
  6.   
  7.     /** 
  8.      * @param args 
  9.      */  
  10.     public static void main(String[] args) {  
  11.         // TODO Auto-generated method stub  
  12.         Scanner cin = new Scanner(new BufferedInputStream(System.in));  
  13.         double output = 0;  
  14.         int i = 0;  
  15.         DecimalFormat f= new DecimalFormat("#.00");  
  16.         while(cin.hasNext()&&i<12)  
  17.         {  
  18.             output += cin.nextDouble();  
  19.             i++;  
  20.         }  
  21.   
  22.         System.out.println('$'+f.format(output/i));  
  23.     }  
  24.   
  25. }  

本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Sun, 28 Oct 2007 15:00:16 +0800 http://fullfocus.javaeye.com/blog/136148 http://fullfocus.javaeye.com/blog/136148 基于英文单词的快速HASH索引算法 fullfocus 作者: fullfocus  链接：http://fullfocus.javaeye.com/blog/133223  发表时间: 2007年10月18日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

因为有项目需要，要做一个类似ispell 的软件，其中会产生大量的对单词的查找操作，于是经过一翻研究，得出以下HASH算法，经过验证比一般的查表的FNV HASH算法产生的分布曲线基本没什么两样，并且在大部分的不同字典下，本算法要比查表的FNV HASH算法表现出速度更快，分布更均匀。但是因为是实验结果，所以暂时还没得出有效的数学推论，但是从大量的不同的字典测试数据来看，此算法确实效率不 错。

由于以前没有涉及过相关的纯算法的设计，所以刚刚开始的时候，打算随便选用一种HASH，比如说用%除大质数，然后借此搭建一个比较强壮的测试环境，然后打算根据测试结果来改进HASH算法的模型。

最开始，我的HASH函数是这样的：
unsigned int hash_func(char *str, int len)
{
     register unsigned int sum = 0;
     register char *p = str;

     while(p - str < len)
          sum += *(p++);

     return sum % MAX_PRIME_LESS_THAN_HASH_LEN;
}
非常简单，但是这是绝对不可取的，通过这个函数，我选取了一个23w词的字典做为测试，当HASH SIZE=1024的时候，得到了以下的图象：


看得出震荡幅度相当大，那么如何来改进呢？首先想到可能产生的冲突的是这种情况：abcd和acbd，对于这两种单词来说，如果用上面的HASH函数，就一定会发生碰撞，为什么呢？因为每个字符少了关于它自己的位置信息，于是第一次改进版本的HASH函数就给每个字符加上了它的位置信息，将上面所描述的函数改进为：

unsigned int hash_func(char *str, int len)
{
     register unsigned int sum = 0;
     register char *p = str;

     while(p - str < len)
          sum += *(p++) * (p–str);

     return sum % MAX_PRIME_LESS_THAN_HASH_LEN;
}
得到以下图象：


某种程度上来说，比不带位置信息产生的分布图要好多了，但是仍然非常的不均匀。那么接来分析产生分布不均匀的原因，因为是用的乘法，所以仍然太过于依赖字母产生的结果了。于是改用XOR操作，选用以下函数：

unsigned int hash_func(char *str, int len)
{
     register unsigned int sum = 0;
     register char *p = str;

     while(p - str < len)
          sum += (*(p++) * (p–str)) ^ sum;

     return sum % MAX_PRIME_LESS_THAN_HASH_LEN;
}
得到以下图象：

 

上图虽然震荡幅度比较，不过做出来的regression line明显比上两张图片平得多了。但是结果仍然非常不好，从800到100的range太大。原因还是因为数据分布得不够均匀，于是思考单独的用加法来 算是不是不太好，根据其他查表类HASH算法的过程，发现其大多都用了高低位来组合成最后的结果，于是我也采用了他们的方法：

unsigned int hash_func(char *str, int len)
{
     register unsigned int sum = 0;
     register unsigned int h = 0;
     register unsigned short *p = (unsigned short *)str;
     register unsigned short *s = (unsigned short *)str;

     while(p - s < len)
     {
          register unsigned short a = *(p++) * (p-s);
          sum += sum ^ a;
          h += a;
     }
     return ((sum << 16) | h) % MAX_PRIME_LESS_THAN_HASH_LEN;
}

得到最终近似完美的图象：

 

最后得出结论，不用查表的方法，而通过字符串本身的位置对字符本身进行修正的方法也能得到结果相当满意的HASH函数，之后换了几个大小不同的字典进行测试，得出的图象都大致和上图一致，非常令人满意。对于这个项目，包括如何检查单词错误，和自动修正等等相关的内容，会随着项目的完成一一在整理成文档，希望大家支持。

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

字符串hash算法比较

1 概述
链表查找的时间效率为O(N)，二分法为log2N，B+ Tree为log2N，但Hash链表查找的时间效率为O(1)。
设计高效算法往往需要使用Hash链表，常数级的查找速度是任何别的算法无法比拟的，Hash链表的构造和冲突的不同实现方法对效率当然有一定的影响，然 而Hash函数是Hash链表最核心的部分，本文尝试分析一些经典软件中使用到的字符串Hash函数在执行效率、离散性、空间利用率等方面的性能问题。
 
2 经典字符串Hash函数介绍
作者阅读过大量经典软件原代码，下面分别介绍几个经典软件中出现的字符串Hash函数。
2.1 PHP中出现的字符串Hash函数
static unsigned long hashpjw(char *arKey, unsigned int nKeyLength)
{
unsigned long h = 0, g;
char *arEnd=arKey+nKeyLength;

while (arKey < arEnd) {
h = (h << 4) + *arKey++;
if ((g = (h & 0xF0000000))) {
h = h ^ (g >> 24);
h = h ^ g;
}
}
return h;
}
2.2 OpenSSL中出现的字符串Hash函数
unsigned long lh_strhash(char *str)
{
int i,l;
unsigned long ret=0;
unsigned short *s;

if (str == NULL) return(0);
l=(strlen(str)+1)/2;
s=(unsigned short *)str;
for (i=0; i
ret^=(s[i]<<(i&0x0f));
return(ret);
} */

/* The following hash seems to work very well on normal text strings
* no collisions on /usr/dict/words and it distributes on %2^n quite
* well, not as good as MD5, but still good.
*/
unsigned long lh_strhash(const char *c)
{
unsigned long ret=0;
long n;
unsigned long v;
int r;

if ((c == NULL) || (*c == '\0'))
return(ret);
/*
unsigned char b[16];
MD5(c,strlen(c),b);
return(b[0]|(b[1]<<8)|(b[2]<<16)|(b[3]<<24));
*/

n=0x100;
while (*c)
{
v=n|(*c);
n+=0x100;
r= (int)((v>>2)^v)&0x0f;
ret=(ret(32-r));
ret&=0xFFFFFFFFL;
ret^=v*v;
c++;
}
return((ret>>16)^ret);
}
在下面的测量过程中我们分别将上面的两个函数标记为OpenSSL_Hash1和OpenSSL_Hash2，至于上面的实现中使用MD5算法的实现函数我们不作测试。
2.3 MySql中出现的字符串Hash函数
#ifndef NEW_HASH_FUNCTION

/* Calc hashvalue for a key */

static uint calc_hashnr(const byte *key,uint length)
{
register uint nr=1, nr2=4;
while (length--)
{
nr^= (((nr & 63)+nr2)*((uint) (uchar) *key++))+ (nr << 8);
nr2+=3;
}
return((uint) nr);
}

/* Calc hashvalue for a key, case indepenently */

static uint calc_hashnr_caseup(const byte *key,uint length)
{
register uint nr=1, nr2=4;
while (length--)
{
nr^= (((nr & 63)+nr2)*((uint) (uchar) toupper(*key++)))+ (nr << 8);
nr2+=3;
}
return((uint) nr);
}

#else

/*
* Fowler/Noll/Vo hash
*
* The basis of the hash algorithm was taken from an idea sent by email to the
* IEEE Posix P1003.2 mailing list from Phong Vo (kpv@research.att.com) and
* Glenn Fowler (gsf@research.att.com). Landon Curt Noll (chongo@toad.com)
* later improved on their algorithm.
*
* The magic is in the interesting relationship between the special prime
* 16777619 (2^24 + 403) and 2^32 and 2^8.
*
* This hash produces the fewest collisions of any function that we've seen so
* far, and works well on both numbers and strings.
*/

uint calc_hashnr(const byte *key, uint len)
{
const byte *end=key+len;
uint hash;
for (hash = 0; key < end; key++)
{
hash *= 16777619;
hash ^= (uint) *(uchar*) key;
}
return (hash);
}

uint calc_hashnr_caseup(const byte *key, uint len)
{
const byte *end=key+len;
uint hash;
for (hash = 0; key < end; key++)
{
hash *= 16777619;
hash ^= (uint) (uchar) toupper(*key);
}
return (hash);
}

#endif
Mysql中对字符串Hash函数还区分了大小写，我们的测试中使用不区分大小写的字符串Hash函数，另外我们将上面的两个函数分别记为MYSQL_Hash1和MYSQL_Hash2。
2.4 另一个经验字符串Hash函数
unsigned int hash(char *str)
{
register unsigned int h;
register unsigned char *p;

for(h=0, p = (unsigned char *)str; *p ; p++)
h = 31 * h + *p;

return h;
}
3 测试及结果
3.1 测试说明
从上面给出的经典字符串Hash函数中可以看出，有的涉及到字符串大小敏感问题，我们的测试中只考虑字符串大小写敏感的函数，另外在上面的函数中有的函数 需要长度参数，有的不需要长度参数，这对函数本身的效率有一定的影响，我们的测试中将对函数稍微作一点修改，全部使用长度参数，并将函数内部出现的计算长 度代码删除。
我们用来作测试用的Hash链表采用经典的拉链法解决冲突，另外我们采用静态分配桶（Hash链表长度）的方法来构造Hash链表，这主要是为了简化我们的实现，并不影响我们的测试结果。
测试文本采用单词表，测试过程中从一个输入文件中读取全部不重复单词构造一个Hash表，测试内容分别是函数总调用次数、函数总调用时间、最大拉链长度、 平均拉链长度、桶利用率（使用过的桶所占的比率），其中函数总调用次数是指Hash函数被调用的总次数，为了测试出函数执行时间，该值在测试过程中作了一 定的放大，函数总调用时间是指Hash函数总的执行时间，最大拉链长度是指使用拉链法构造链表过程中出现的最大拉链长度，平均拉链长度指拉链的平均长度。
测试过程中使用的机器配置如下：
PIII600笔记本，128M内存，windows 2000 server操作系统。
3.2 测试结果
以下分别是对两个不同文本文件中的全部不重复单词构造Hash链表的测试结果，测试结果中函数调用次数放大了100倍，相应的函数调用时间也放大了100倍。

从上表可以看出，这些经典软件虽然构造字符串Hash函数的方法不同，但是它们的效率都是不错的，相互之间差距很小，读者可以参考实际情况从其中借鉴使用。

Posted by david at November 15, 2005 3:05 PM


本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Thu, 18 Oct 2007 16:21:40 +0800 http://fullfocus.javaeye.com/blog/133223 http://fullfocus.javaeye.com/blog/133223 Catalan 数--pku ACM 2084【待解决】 fullfocus 作者: fullfocus  链接：http://fullfocus.javaeye.com/blog/103543  发表时间: 2007年07月21日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

  先来看看CATALAN数是怎么定义的。（http://www.ekany.com/wdg98/zhsx/2/2_11.htm）

2.11 Catalan 数 

    这一节讨论Catalan数,其递推关系是非线性的,许多有意义的计数问题都导致这样的递推关系.本节将举出一些,后面还将见到. 

    一个凸n边形,通过不相交于n边形的对角线,把n边形拆分成若干三角形,不同拆分的数目用hn表示.例如五边形有如下五种拆分方案，故hn=5

       

        图 2-11-1 

1.递推关系 

    定理： 

       

        

    证明：

    （a）的证明： 如图2－11－1所示， 以v1vn+1作为一个边 的三角形 ， 将凸n+1边形分割 成两部分，一部分是 k边形， 另一部分是n-k+2边形，k=2,3,...,n即vk点可以是v2,v3,...,vn点中任意一点。依据加法法则有 

        

       

       

        图 2－11－3 

    (b) 的证明： 如图2－11－3所示， 从v1点向其它n-3个顶点(v3,v4,...,vn-1)可引出n-3条对角线。对角线v1vk把n边形 分割成两个部分，因此 以v1vk对角线作为拆分线的方案数为hkhn-k+2。

       

   vk可以是v3,v4,...,vn-1中任一点，对所有这些点求和得h3hn-1+h4hn-2+...+hn-2h4+hn-1h3

   以v2,v3,...,vn取代 点也有类似的结果。但考虑到对角线有两个顶点，同一对角线在两个顶点分别计算了一次，作 

       

（2－11－3）式并不就给出剖分数，无疑其中是有重复的。其重复度是由于一个凸n边形的剖分有n-3条对角线，而对其每一条边计数时该剖分都计数了一次，故重复了n-3次即（2－11－3）式给出的结果是hn的n-3倍。 

       

（2－11－1）式和（2－11－2）式都是非线性的递推关系。 

2.Catalan 数计算公式 

    由（2－11－1）式及h2=1故得 

       

由 

       

整理得 

       

       

令 

       

  


本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Sat, 21 Jul 2007 07:51:22 +0800 http://fullfocus.javaeye.com/blog/103543 http://fullfocus.javaeye.com/blog/103543 搞研究的人，打好数据基础哇 fullfocus 作者: fullfocus  链接：http://fullfocus.javaeye.com/blog/77574  发表时间: 2007年05月07日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

摘自http://qxred.yculblog.com/post.1176386.html

越搞研究，越觉得以前数学没学好，越没学好，就越搞不出什么成果，沉痛教训啊

> 1 空间解析几何
> 数学系第一学期，是最简单也是最基础的
>
> 2 数学分析
> 数学系第一、二、三学期的课程，是最基础最重要的课程，虽然学过这门课，但有时间的话还是建议重新去上一下第三学期多元微积分，这对于以后学习微分几何十分有益）
>
> 3 高等代数
> 数学系第二、三学期的课程，如果已有线性代数基础，可只听第三学期关于内积空间的课程，这门课对于我们研究有最直接的益处。
>
> 4 复变函数
> 数学系第四学期的课程，学这门课等于又将数学分析这门基础课的相关内容复习了一遍。我认为这门课是数学系学生学的最后一门比较简单的课程。
>
> 5 抽象代数
> 数学系第四学期的课程，主要是讲群、环、域方面的知识，大家在离散数学课程中应该学过这方面知识，只是数学系讲得再深入一点。
>
> 6实变函数
> 数学系第四学期的课程，我认为这门课是数学系专业学生和非数学系专业学生在数学知识差异上的分水岭，数学系的后续课程可以说是这门课的继续延伸，如拓扑学、微分几何等，就连他们的概率论也和我们学习的不大一样，他们是在实变函数的测度论基础上研究概率的。
>
> 7 概率论
> 数学系第五学期的课程，学习该课程需要实变函数中测度论的基础，学好这门课对我们的研究十分重要。我觉得我以前学的概率论太浅了，下学期我计划去再学一遍。
>
> 8 泛函分析
> 数学系第五学期的课程。
>
> 9 拓扑学
> 数学系第五学期的课程。
>
> 10 微分几何
> 数学系第六学期的课程，做流形学习研究不能不懂。
> 
> 我认为以上十门课是我们要学习的核心课程。对于1，还好比较简单，我自己买了本书看。2中的多元微积分部分和3中的多项式理论与内积空间部分，我去年到数学系学了一下。现在正和04级数学系一道上4，5，6。计划下学期上7，8，9以及再下学期上10 微分几何。学习微分几何是我的最终目的，我买了本陈省身的《微分几何讲义》来看，根本看不懂。因此，我觉得还是该花一点时间去补一下课，否则我就永远不可能看懂。
> 
> 学好这么多课要花不少时间。除了对数学分析、高等代数、概率论，我们有点基础以外，其余课程对我们来说是全新的。因此光听还不够，还要经常复习，才能保证一直能听得懂，否则听了几次就什么也听不懂了。学习这些课的时间更多的是花在复习和做习题的功夫上，听课其实倒花不了我们多少时间，数学系的课程大部分安排在早上一二节课，这可以让我们养成每天早起的好习惯。
> 
> 同时，我们不同于数学系的本科生，我们的最终目的是研究，我们的时间都很有限，因此我们要摆正学习基础数学课程和做好当前研究工作的关系。这两者是一对矛盾，是既对立又统一的。从短期看，学习课程挤占了我们看论文写程序做研究的很多时间；但从长期看，学习这些课程，使我们掌握从事研究工作的利器。我们要两手抓，要补习数学课程和做好现阶段研究两不误。


本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Mon, 07 May 2007 20:46:04 +0800 http://fullfocus.javaeye.com/blog/77574 http://fullfocus.javaeye.com/blog/77574 (转)log4j的详解 fullfocus 作者: fullfocus  链接：http://fullfocus.javaeye.com/blog/77228  发表时间: 2007年05月05日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

(摘自百度搜索结果)
log4j
在强调可重用组件开发的今天，除了自己从头到尾开发一个可重用的日志操作类外，Apache为我们提供了一个强有力的日志操作包-Log4j。

Log4j是Apache的一个开放源代码项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件、甚至是套接口服务器、NT的事件记录器、UNIX Syslog守护进程等；我们也可以控制每一条日志的输出格式；通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程。最令人感兴趣的就是，这些可以通过一个配置文件来灵活地进行配置，而不需要修改应用的代码。

此外，通过Log4j其他语言接口，您可以在C、C++、.Net、PL/SQL程序中使用Log4j，其语法和用法与在Java程序中一样，使得多语言分布式系统得到一个统一一致的日志组件模块。而且，通过使用各种第三方扩展，您可以很方便地将Log4j集成到J2EE、JINI甚至是SNMP应用中。

说明：下面分为三部分，第一部分讲解如何配置log4j，第二部分为对log4j.properties配置文件中的各个属性的讲解，第三部分为对log4j的详细讲解，如果只想配置上log4j，那么只需要看前两个部分就可以，如果想对log4j深入了解，则还需看第三部分。

一、Log4j配置

第一步：加入log4j-1.2.8.jar到lib下。

第二步：在CLASSPATH下建立log4j.properties。内容如下：

1 log4j.rootCategory=INFO, stdout , R

2

3 log4j.appender.stdout=org.apache.log4j.ConsoleAppender

4 log4j.appender.stdout.layout=org.apache.log4j.PatternLayout

5 log4j.appender.stdout.layout.ConversionPattern=[QC] %p [%t] %C.%M(%L) | %m%n

6

7 log4j.appender.R=org.apache.log4j.DailyRollingFileAppender

8 log4j.appender.R.File=D:\Tomcat 5.5\logs\qc.log

9 log4j.appender.R.layout=org.apache.log4j.PatternLayout

10 log4j.appender.R.layout.ConversionPattern=%d-[TS] %p %t %c - %m%n

11

12 log4j.logger.com.neusoft=DEBUG

13 log4j.logger.com.opensymphony.oscache=ERROR

14 log4j.logger.net.sf.navigator=ERROR

15 log4j.logger.org.apache.commons=ERROR

16 log4j.logger.org.apache.struts=WARN

17 log4j.logger.org.displaytag=ERROR

18 log4j.logger.org.springframework=DEBUG

19 log4j.logger.com.ibatis.db=WARN

20 log4j.logger.org.apache.velocity=FATAL

21

22 log4j.logger.com.canoo.webtest=WARN

23

24 log4j.logger.org.hibernate.ps.PreparedStatementCache=WARN

25 log4j.logger.org.hibernate=DEBUG

26 log4j.logger.org.logicalcobwebs=WARN

第三步：相应的修改其中属性，修改之前就必须知道这些都是干什么的，在第二部分讲解。

第四步：在要输出日志的类中加入相关语句：

定义属性：protected final Log log = LogFactory.getLog(getClass());

在相应的方法中：

if (log.isDebugEnabled())

{

log.debug(“System …..”);

}

二、Log4j说明

1 log4j.rootCategory=INFO, stdout , R

此句为将等级为INFO的日志信息输出到stdout和R这两个目的地，stdout和R的定义在下面的代码，可以任意起名。等级可分为OFF、FATAL、ERROR、WARN、INFO、DEBUG、ALL，如果配置OFF则不打出任何信息，如果配置为INFO这样只显示INFO, WARN, ERROR的log信息，而DEBUG信息不会被显示，具体讲解可参照第三部分定义配置文件中的logger。

3 log4j.appender.stdout=org.apache.log4j.ConsoleAppender

此句为定义名为stdout的输出端是哪种类型，可以是

org.apache.log4j.ConsoleAppender（控制台），

org.apache.log4j.FileAppender（文件），

org.apache.log4j.DailyRollingFileAppender（每天产生一个日志文件），

org.apache.log4j.RollingFileAppender（文件大小到达指定尺寸的时候产生一个新的文件）

org.apache.log4j.WriterAppender（将日志信息以流格式发送到任意指定的地方）

具体讲解可参照第三部分定义配置文件中的Appender。

4 log4j.appender.stdout.layout=org.apache.log4j.PatternLayout

此句为定义名为stdout的输出端的layout是哪种类型，可以是

org.apache.log4j.HTMLLayout（以HTML表格形式布局），

org.apache.log4j.PatternLayout（可以灵活地指定布局模式），

org.apache.log4j.SimpleLayout（包含日志信息的级别和信息字符串），

org.apache.log4j.TTCCLayout（包含日志产生的时间、线程、类别等等信息）

具体讲解可参照第三部分定义配置文件中的Layout。

5 log4j.appender.stdout.layout.ConversionPattern= [QC] %p [%t] %C.%M(%L) | %m%n

如果使用pattern布局就要指定的打印信息的具体格式ConversionPattern，打印参数如下：

%m 输出代码中指定的消息

%p 输出优先级，即DEBUG，INFO，WARN，ERROR，FATAL

%r 输出自应用启动到输出该log信息耗费的毫秒数

%c 输出所属的类目，通常就是所在类的全名

%t 输出产生该日志事件的线程名

%n 输出一个回车换行符，Windows平台为“rn”，Unix平台为“n”

%d 输出日志时间点的日期或时间，默认格式为ISO8601，也可以在其后指定格式，比如：%d{yyyy MMM dd HH:mm:ss,SSS}，输出类似：2002年10月18日 22：10：28，921

%l 输出日志事件的发生位置，包括类目名、发生的线程，以及在代码中的行数。

[QC]是log信息的开头，可以为任意字符，一般为项目简称。

输出的信息

[TS] DEBUG [main] AbstractBeanFactory.getBean(189) | Returning cached instance of singleton bean 'MyAutoProxy'

具体讲解可参照第三部分定义配置文件中的格式化日志信息。

7 log4j.appender.R=org.apache.log4j.DailyRollingFileAppender

此句与第3行一样。定义名为R的输出端的类型为每天产生一个日志文件。

8 log4j.appender.R.File=D:\Tomcat 5.5\logs\qc.log

此句为定义名为R的输出端的文件名为D:\Tomcat 5.5\logs\qc.log

可以自行修改。

9 log4j.appender.R.layout=org.apache.log4j.PatternLayout

与第4行相同。

10 log4j.appender.R.layout.ConversionPattern=%d-[TS] %p %t %c - %m%n

与第5行相同。

12 log4j.logger.com. neusoft =DEBUG

指定com.neusoft包下的所有类的等级为DEBUG。

可以把com.neusoft改为自己项目所用的包名。

13 log4j.logger.com.opensymphony.oscache=ERROR

14 log4j.logger.net.sf.navigator=ERROR

这两句是把这两个包下出现的错误的等级设为ERROR，如果项目中没有配置EHCache，则不需要这两句。

15 log4j.logger.org.apache.commons=ERROR

16 log4j.logger.org.apache.struts=WARN

这两句是struts的包。

17 log4j.logger.org.displaytag=ERROR

这句是displaytag的包。（QC问题列表页面所用）

18 log4j.logger.org.springframework=DEBUG

此句为Spring的包。

24 log4j.logger.org.hibernate.ps.PreparedStatementCache=WARN

25 log4j.logger.org.hibernate=DEBUG

此两句是hibernate的包。

以上这些包的设置可根据项目的实际情况而自行定制。

三、log4j详解

1、定义配置文件

Log4j支持两种配置文件格式，一种是XML格式的文件，一种是Java特性文件log4j.properties（键=值）。下面将介绍使用log4j.properties文件作为配置文件的方法:

①、配置根Logger

Logger 负责处理日志记录的大部分操作。

其语法为：

log4j.rootLogger = [ level ] , appenderName, appenderName, …

其中，level 是日志记录的优先级，分为OFF、FATAL、ERROR、WARN、INFO、DEBUG、ALL或者自定义的级别。Log4j建议只使用四个级别，优先级从高到低分别是ERROR、WARN、INFO、DEBUG。通过在这里定义的级别，您可以控制到应用程序中相应级别的日志信息的开关。比如在这里定义了INFO级别，只有等于及高于这个级别的才进行处理，则应用程序中所有DEBUG级别的日志信息将不被打印出来。ALL:打印所有的日志，OFF：关闭所有的日志输出。 appenderName就是指定日志信息输出到哪个地方。可同时指定多个输出目的地。

②、配置日志信息输出目的地 Appender

Appender 负责控制日志记录操作的输出。

其语法为：

log4j.appender.appenderName = fully.qualified.name.of.appender.class

log4j.appender.appenderName.option1 = value1

…

log4j.appender.appenderName.optionN = valueN

这里的appenderName为在①里定义的，可任意起名。

其中，Log4j提供的appender有以下几种：

org.apache.log4j.ConsoleAppender（控制台），

org.apache.log4j.FileAppender（文件），

org.apache.log4j.DailyRollingFileAppender（每天产生一个日志文件），

org.apache.log4j.RollingFileAppender（文件大小到达指定尺寸的时候产生一个新的文件），可通过log4j.appender.R.MaxFileSize=100KB设置文件大小，还可通过log4j.appender.R.MaxBackupIndex=1设置为保存一个备份文件。

org.apache.log4j.WriterAppender（将日志信息以流格式发送到任意指定的地方）

例如：log4j.appender.stdout=org.apache.log4j.ConsoleAppender

定义一个名为stdout的输出目的地，ConsoleAppender为控制台。

③、配置日志信息的格式（布局）Layout

Layout 负责格式化Appender的输出。

其语法为：

log4j.appender.appenderName.layout = fully.qualified.name.of.layout.class

log4j.appender.appenderName.layout.option1 = value1

…

log4j.appender.appenderName.layout.optionN = valueN

其中，Log4j提供的layout有以下几种：

org.apache.log4j.HTMLLayout（以HTML表格形式布局），

org.apache.log4j.PatternLayout（可以灵活地指定布局模式），

org.apache.log4j.SimpleLayout（包含日志信息的级别和信息字符串），

org.apache.log4j.TTCCLayout（包含日志产生的时间、线程、类别等等信息）

2、格式化日志信息

Log4J采用类似C语言中的printf函数的打印格式格式化日志信息，打印参数如下：

%m 输出代码中指定的消息

%p 输出优先级，即DEBUG，INFO，WARN，ERROR，FATAL

%r 输出自应用启动到输出该log信息耗费的毫秒数

%c 输出所属的类目，通常就是所在类的全名

%t 输出产生该日志事件的线程名

%n 输出一个回车换行符，Windows平台为“rn”，Unix平台为“n”

%d 输出日志时间点的日期或时间，默认格式为ISO8601，也可以在其后指定格式，比如：%d{yyyy MMM dd HH:mm:ss,SSS}，输出类似：2002年10月18日 22：10：28，921

%l 输出日志事件的发生位置，包括类目名、发生的线程，以及在代码中的行数。

3、在代码中使用Log4j

我们在需要输出日志信息的类中做如下的三个工作：

1、导入所有需的commongs-logging类：

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

2、在自己的类中定义一个org.apache.commons.logging.Log类的私有静态类成员：

private final Log log = LogFactory.getLog(getClass());

LogFactory.getLog()方法的参数使用的是当前类的class。

3、使用org.apache.commons.logging.Log类的成员方法输出日志信息：

if (log.isDebugEnabled())

{

log.debug("111");

}

if (log.isInfoEnabled())

{

log.info("222");

}

if (log.isWarnEnabled())

{

log.warn("333");

}

if (log.isErrorEnabled())

{

log.error("444");

}

if (log.isFatalEnabled())

{

log.fatal("555")

}

本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Sat, 05 May 2007 22:53:19 +0800 http://fullfocus.javaeye.com/blog/77228 http://fullfocus.javaeye.com/blog/77228 Eclipse不能编译，不能产生class文件的解决方案 fullfocus 作者: fullfocus  链接：http://fullfocus.javaeye.com/blog/75453  发表时间: 2007年04月27日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

     以前也碰到过这个问题，还以为Eclipse的问题，只是傻傻的化大时间去重装一边Eclipse，今天又碰到这个问题了， JAVA类完全正确， 引入的包也正确，设置的输出路径也正确，当我用Clean命令后，Eclipse再也不肯把java文件编译成class了，立马去网上找，都说没有开自动编译命令，但是我都开了啊。。。。不行自己研究。。

   哇，总有发现新大陆了：

   在 project-->source里面，发现提示： 1 source folder path missing....

   原来， 我直接把missing的文件给删掉了， 回到工程界面后，class文件自动跳出来了，3K GOD。。


本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Fri, 27 Apr 2007 11:53:17 +0800 http://fullfocus.javaeye.com/blog/75453 http://fullfocus.javaeye.com/blog/75453 一个搜索引擎开发者论坛 fullfocus 作者: fullfocus  链接：http://fullfocus.javaeye.com/blog/70713  发表时间: 2007年04月13日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

临近毕业，而毕设正是搜索引擎相关课题： web搜索结果聚类, 以前也研究过搜索引擎，而且很感兴趣，所以趁着这个东风，建立了一个搜索引擎开发者交流社区，根据自己的一些经验，把论坛分成了几个板块， 基础学习区，开源代码研究，开发与应用等相关模块，希望对搜索引擎感兴趣的同仁来社区一起探讨，研究，学习，进步，特别欢迎有搜索引擎开发经验的前辈来共同维护好这个社区，感谢大家的支持！
社区网址是： http://www.zhuayu.net
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Fri, 13 Apr 2007 19:06:35 +0800 http://fullfocus.javaeye.com/blog/70713 http://fullfocus.javaeye.com/blog/70713 (转)BeanShell快速入门---Java应用程序脚本引擎 fullfocus 作者: fullfocus  链接：http://fullfocus.javaeye.com/blog/67047  发表时间: 2007年04月01日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

今天研究Carrot2源代码，查看其的整个数据流程，发现他把很多变动的东西用组件的形式来实现，而通过脚本来跟应用程序建立纽带。这个脚本就是BeanShell，发现还挺好用，转载一片不错的文章。

 

BeanShell快速入门---Java应用程序脚本引擎
http://www.daima.com.cn/Info/55/Info32134/


快速入门

欢迎使用BeanShell.这是一个速成课程。我们将省去一些重要的选项和细节。要学习更多的内容请看本User's Guide的其它部分。

下载和运行BeanShell

请到http://www.beanshell.org下载最新的JAR文件。你可以用图形桌面模式和命令行模式起动BeanShell。
如果你只是要玩一玩BeanShell，你可以在BeanShell的jar文件上双击来起动BeanShell的桌面。但不管怎样，如果你要让BeanShell与你的类与应用程序一起工作就必须将BeanShell的jar文件加到classpath中。
你可以将BeanShell的jar文件拖到JAVA_HOME的ext目录也可以直接加到classpath中。

  • windows用户请将bsh.jar放在JAVA_HOME/jre/lib/ext文件夹，OSX用户可以放在/Library/Java/Extensions.
    或者增加BeanShell到你的classpath目录，如：
    unix: export CLASSPATH=$CLASSPATH:bsh-xx.jar
    windows:set classpath %classpath%;bsh-xx.jar

然后你就可以运行BeanShell在GUI或命令行模式：

  •  java bsh.Console       // run the graphical desktop
    or
         java bsh.Interpreter   // run as text-only on the command line
    or
         java bsh.Interpreter filename [ args ] // run script file

可以在你的应用程序内部来运行,也可以作为debug及servlet的远程服务器模式,或一个Applet内部来运行BeanShell。请参考"BeanShell Modes of Operation"获得更多详情。

BeanShell GUI

用GUI模式启动BeanShell后，将打开一个桌面视窗。用鼠标右击在桌面的背景上，你可以打开另一个控制台视窗及其它的工具如一个简单的类游览器。
每一个控制台视窗运行一个独立的BeanShell解释器。这个图形化的控制台支持基本的历史命令，行编辑，剪切和粘贴，甚至类和变量名的自动完成功能。从控制台你能开启一个简单的编辑视窗。在它里面，你可以编写脚本和使用‘eval’选项求表达式的值。

Java语句和表达式

BeanShell能理解标准的JAVA语句，表达式，和方法宣告。语句和表达式的内容可以是：变量，宣告，赋值，方法调用，循环，条件等。
在Java程序中你必须严格的使用它们，但在BeanShell中，你可以用“宽松类型”(loosely typed)的方式来使用它们。也就是说，你可以在写脚本时偷懒，不进行变量类型的宣告(在原始数据类型和对象都可以)。如果你试着用错变量类型，BeanShell将会给出一个错误。
这里有一些例子：

  • foo = "Foo";   
    four = (2 + 2)*2/2;
    print( foo + " = " + four );  // print() is a BeanShell command
    // Do a loop
    for (i=0; i<5; i++)
        print(i);  
    // Pop up a frame with a button in it
    button = new JButton( "My Button" );
    frame = new JFrame( "My Frame" );
    frame.getContentPane().add( button, "Center" );
    frame.pack();
    frame.setVisible(true);

有用的BeanShell命令

在刚才那个例子中我们用了一个内建在BeanShell中的一个方便的命令print(),来显示变量的值。print()跟ava的System.out.println()非常的相像，除非它能保证输出总是命令行。print()也可以显示一些对象的类型(如数组)，但比Java的更详细。另一个相关的命令是show(),用来开启与关闭显示你输入的每一行的结果。
这儿是一些其它的BeanShell的命令：
source(), run() - 将一个bsh脚本读到解释器或运行在另一个解释器。
frame() - 显示一个Frame或JFrame的GUI组件.
load(), save() - 载入和保存一个序列化的对象到一个文件.
cd(), cat(), dir(), pwd(), etc. - 类unix的shell命令。
exec() - 运行一个本地的程序。
javap() - 打印一个对象的方法和字段，类似于Java的javap命令。
setAccessibility() - 开启无限制的存取private 和protected的组件。
要获得更多的信息请查看BeanShell命令的详细清单。

提示:
BeanShell命令并不是真的"内建"其中的，而是作为脚本方法自动从classpath载入的. 你可以扩展基本命令集并加到classpath中作为自订义的脚本来使用。

脚本方法

你可以在bsh中宣告和使用方法，就像在java的类中一样。

  • int addTwoNumbers( int a, int b ) {
        return a + b;
    }
    sum = addTwoNumbers( 5, 7 );  // 12

bsh的方法可以有动态的(宽松的)参数和返回类型。

  • add( a, b ) {
        return a + b;
    }
    foo = add(1, 2);            // 3
    foo = add("Oh", " baby");   // "Oh baby"

实现Interface

注意：如果要BeanShell能实现任意的Interface，必须有jdk1.3及以上支持。
你可以在脚本中用标准的Java内部类的语法来实现Interface.例如：

  • ActionListener scriptedListener = new ActionListener() {
        actionPerformed( event ) { ... }
    }

你可以不用实现Interface的所有方法，而只用实现你需要的方法。如果代码中调用了未被实现的方法，将丢出异常。如果你想重载大量的方法的行为--例如为日志生成一个"哑"适配器--你可以在脚本对象中实现一个特殊的方法:invoke(name,args)。invoke()方法用来处理任何未被定义的方法的调用:

  • ml = new MouseListener() {
        mousePressed( event ) { ... }
        // handle the rest
        invoke( name, args ) { print("Method: "+name+" invoked!");
    }

脚本对象

在BeanShell中，和在JavaScript与Perl中一样，脚本对象是用封闭的方法体一构成的。通过在方法未尾返回一个特殊值"this"，你就可以像使用方法一样调用这个对象了。在这个方法调用时，你可以给与它任何的值。通常对象内部需要包括方法，所以BeanShell的脚本方法在一定程度上可再包含一些方法以构成脚本对象。例如：

  • foo() {
        print("foo");
        x=5;
        bar() {
            print("bar");
        }
        return this;
    }
    myfoo = foo();    // prints "foo"
    print( myfoo.x ); // prints "5"
    myfoo.bar();      // prints "bar"

如果这些代码对你来说很陌生，别急，请用户手册可得到更透彻的解释。

在你的脚本中，BeanShell脚本对象(也就是先前例子中的"this"参照)能自动实现任何JAVA介面类型。当JAVA代码调用相应与之通讯的脚本方法内的方法。当你试着将脚本对象作为参数传给Java方法时，BeanShell会自动将它造型(cast)为相应的类型。如要传递BeanShell外部的对象时，你可以在需要时显式的进行造型(cast).请看用户手册中的详细内容。

从你的应用程序调用BeanShell

通过建立一个BeanShell解释器，使用eval()或source()命令，你可以在你的应用程序中求文本表达式的值和运行脚本。如果你希望在你的脚本内部使用一个对象，可以用set()方法传递对象的变量参照给BeanShell,并通过get()方法取得结果。

  • import bsh.Interpreter;
    Interpreter i = new Interpreter();  // Construct an interpreter
    i.set("foo", 5);                    // Set variables
    i.set("date", new Date() );
    Date date = (Date)i.get("date");    // retrieve a variable
    // Eval a statement and get the result
    i.eval("bar = foo*10");            
    System.out.println( i.get("bar") );
    // Source an external script file
    i.source("somefile.bsh");

本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Sun, 01 Apr 2007 11:00:32 +0800 http://fullfocus.javaeye.com/blog/67047 http://fullfocus.javaeye.com/blog/67047 (转)中文搜索引擎技术揭密:中文分词 fullfocus 作者: fullfocus  链接：http://fullfocus.javaeye.com/blog/66508  发表时间: 2007年03月30日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

中文搜索引擎技术揭密:中文分词
http://FullSearch.Com 中文全文检索网 2005-1-13 8:35:56 winter
关键词：中文搜索引擎技术揭密


    信息的飞速增长，使搜索引擎成为人们查找信息的首选工具，Google、百度、中国搜索等大型搜索引擎一直是人们讨论的话题。随着搜索市场价值的不断增加，越来越多的公司开发出自己的搜索引擎，阿里巴巴的商机搜索、8848的购物搜索等也陆续面世，自然，搜索引擎技术也成为技术人员关注的热点。


    搜索引擎技术的研究，国外比中国要早近十年，从最早的Archie，到后来的Excite，以及altvista、overture、google等搜索引擎面世，搜索引擎发展至今，已经有十几年的历史，而国内开始研究搜索引擎是在上世纪末本世纪初。在许多领域，都是国外的产品和技术一统天下，特别是当某种技术在国外研究多年而国内才开始的情况下。例如操作系统、字处理软件、浏览器等等，但搜索引擎却是个例外。虽然在国外搜索引擎技术早就开始研究，但在国内还是陆续涌现出优秀的搜索引擎，像百度（http://www.baidu.com）、中搜（http://www.zhongsou.com）等。目前在中文搜索引擎领域，国内的搜索引擎已经和国外的搜索引擎效果上相差不远。之所以能形成这样的局面，有一个重要的原因就在于中文和英文两种语言自身的书写方式不同，这其中对于计算机涉及的技术就是中文分词。


    什么是中文分词


    众所周知，英文是以词为单位的，词和词之间是靠空格隔开，而中文是以字为单位，句子中所有的字连起来才能描述一个意思。例如，英文句子I am a student，用中文则为：“我是一个学生”。计算机可以很简单通过空格知道student是一个单词，但是不能很容易明白“学”、“生”两个字合起来才表示一个词。把中文的汉字序列切分成有意义的词，就是中文分词，有些人也称为切词。我是一个学生，分词的结果是：我 是 一个 学生。


    中文分词和搜索引擎


    中文分词到底对搜索引擎有多大影响？对于搜索引擎来说，最重要的并不是找到所有结果，因为在上百亿的网页中找到所有结果没有太多的意义，没有人能看得完，最重要的是把最相关的结果排在最前面，这也称为相关度排序。中文分词的准确与否，常常直接影响到对搜索结果的相关度排序。笔者最近替朋友找一些关于日本和服的资料，在搜索引擎上输入“和服”，得到的结果就发现了很多问题。下面就以这个例子来说明分词对搜索结果的影响，在现有三个中文搜索引擎上做测试，测试方法是直接在Google（http://www.google.com）、百度（http://www.baidu.com）、中搜（http://www.zhongsou.com）上以“和服”为关键词进行搜索：


    在Google上输入“和服”搜索所有中文简体网页，总共结果507,000条，前20条结果中有14条与和服一点关系都没有。在第一页就有以下错误：


    “通信信息报：瑞星以技术和服务开拓网络安全市场”


    “使用纯HTML的通用数据管理和服务- 开发者- ZDNet ...”


    “陈慧琳《心口不一》化妆和服装自己包办”


    “::外交部：中国境外领事保护和服务指南(2003年版) ...”


    “产品和服务”


    等等。第一页只有三篇是真正在讲“和服”的结果。


    在百度上输入“和服”搜索网页，总共结果为287,000条，前20条结果中有6条与和服一点关系都没有。在第一页有以下错误：


    “福建省晋江市恒和服装有限公司系独资企业”


    “关于商品和服务实行明码标价的规定”


    “青岛东和服装设备”


    在中搜上输入“和服”搜索网页，总共结果为26,917条，前20条结果都是与和服相关的网页。


    这次搜索引擎结果中的错误，就是由于分词的不准确所造成的。通过笔者的了解，Google的中文分词技术采用的是美国一家名叫Basis Technology（http://www.basistech.com）的公司提供的中文分词技术，百度使用的是自己公司开发的分词技术，中搜使用的是国内海量科技（http://www.hylanda.com）提供的分词技术。由此可见，中文分词的准确度，对搜索引擎结果相关性和准确性有相当大的关系。


    中文分词技术


    中文分词技术属于自然语言处理技术范畴，对于一句话，人可以通过自己的知识来明白哪些是词，哪些不是词，但如何让计算机也能理解？其处理过程就是分词算法。


    现有的分词算法可分为三大类：基于字符串匹配的分词方法、基于理解的分词方法和基于统计的分词方法。


    1、基于字符串匹配的分词方法


    这种方法又叫做机械分词方法，它是按照一定的策略将待分析的汉字串与一个“充分大的”机器词典中的词条进行配，若在词典中找到某个字符串，则匹配成功（识别出一个词）。按照扫描方向的不同，串匹配分词方法可以分为正向匹配和逆向匹配；按照不同长度优先匹配的情况，可以分为最大（最长）匹配和最小（最短）匹配；按照是否与词性标注过程相结合，又可以分为单纯分词方法和分词与标注相结合的一体化方法。常用的几种机械分词方法如下：


    1）正向最大匹配法（由左到右的方向）；


    2）逆向最大匹配法（由右到左的方向）；


    3）最少切分（使每一句中切出的词数最小）。


    还可以将上述各种方法相互组合，例如，可以将正向最大匹配方法和逆向最大匹配方法结合起来构成双向匹配法。由于汉语单字成词的特点，正向最小匹配和逆向最小匹配一般很少使用。一般说来，逆向匹配的切分精度略高于正向匹配，遇到的歧义现象也较少。统计结果表明，单纯使用正向最大匹配的错误率为1/169，单纯使用逆向最大匹配的错误率为1/245。但这种精度还远远不能满足实际的需要。实际使用的分词系统，都是把机械分词作为一种初分手段，还需通过利用各种其它的语言信息来进一步提高切分的准确率。


    一种方法是改进扫描方式，