public class DataMangAction extends ActionSupport implements ServletRequestAware, ModelDriven<DataMangForm>
{
   private String str;
   private HttpServletRequest request;
   private int pageSize = 2;
   private DataMangForm model = new DataMangForm();
  
  public String execute() throws Exception
  {
   System.out.println("ok");
   str="execute";
   return str;
  }
  public String init() throws Exception
  {
   DataMangForm dataMangForm = getModel();
         ArrayList baseInfoList;
         // 获取当前页码
         int pageNum = dataMangForm.getPageNum();
         DataMangOpertion dataMangOpertion=new DataMangOpertion();
         baseInfoList = dataMangOpertion.getAllBaseInfo(pageSize, pageNum);
         if (baseInfoList != null)
         {
          dataMangForm.setBaseInfoList(baseInfoList);
             Pagination pagination = dataMangOpertion.getPageInAction();
            
          pagination.setShowCurrentState(true);
          pagination.setShowPageNumber("dataMangAction!init.action", "", 10, 5);
          dataMangForm.setPagination(pagination);
          request.setAttribute("pagination", pagination);
         }
 
   str="init";
   return str;
  }
  public String toAdd() throws Exception
  {
   str="toAdd";
   return str;
  }
     public DataMangForm getModel()
  {
   return model;
  }

     public void setServletRequest(HttpServletRequest request)
     {
     this.request = request;
     }
}
2.pagination

public class Pagination
{

  /*
  ** pageSize      每页记录数
  ** recordCount   总记录数
  ** pageNum       当前页
  ** pageCount     总页数
  */
  private int pageSize;
  private int recordCount;
  private int pageNum;
  private int pageCount;
  private String showPageNumber="";
  private String showCurrentState;

  public Pagination()
  {
  }
  public Pagination(int pageNum,int pageSize,int recordCount,int pageCount)
  {
    this.setPageNum(pageNum);
    this.setPageSize(pageSize);
    this.setRecordCount(recordCount);
    this.setPageCount(pageCount);
  }
  public void setPageSize(int pageSize)
  {
    this.pageSize=pageSize;
  }
  public int getPageSize()
  {
    return pageSize;
  }
  public void setRecordCount(int recordCount)
  {
    this.recordCount=recordCount;
  }
  public int getRecordCount()
  {
    return recordCount;
  }
  public void setPageNum(int pageNum)
  {
    this.pageNum=pageNum;
  }
  public int getPageNum()
  {
    return pageNum;
  }
  public void setPageCount(int pageCount)
  {
    this.pageCount=pageCount;
  }
  public int getPageCount()
  {
    return pageCount;
  }
  //显示分页的当前状态信息
  public void setShowCurrentState(boolean bool)
  {
    if(bool)
    {
      this.showCurrentState = "共有" + recordCount + "条记录数,每页" + pageSize + "条,第<font color=\"red\">"+ pageNum + "</font>页,"+"共" +pageCount + "页." ;
    }
    else
    {
      this.showCurrentState="";
    }
  }
  public String getShowCurrentState()
  {
    return showCurrentState;
  }
  //显示分页码
  public void setShowPageNumber(String path,String parameters,String first,String previous,String next,String last)
  {
    if(pageNum>1)
    {
     showPageNumber="<a href=\"" +path+ "?pageNum=1" +parameters+ "\">" +first+ "</a>&nbsp;";
     showPageNumber=showPageNumber+"<a href=\"" +path+ "?pageNum=" +(pageNum-1)+parameters+ "\">" +previous+ "</a>&nbsp;";
   }
   if(pageNum<pageCount)
   {
     showPageNumber=showPageNumber+"<a href=\"" +path+ "?pageNum=" +(pageNum+1)+parameters+ "\">" +next+ "</a>&nbsp;";
     showPageNumber=showPageNumber+"<a href=\"" +path+ "?pageNum=" +pageCount+parameters+ "\">" +last+ "</a>&nbsp;";
   }
  }
  public void setShowPageNumber(String path,String parameters,int middleSize,int kipSize)
  {
    int start=(pageNum/kipSize)*kipSize+1;
    int end=start-1+middleSize;
    if(end>=pageCount)
    {
      end=pageCount;
    }
    if(start>kipSize)
    {
      showPageNumber="<a href=" +path+ "?pageNum=" +(start-2)+parameters+ ">" +"<<<"+ "</a>&nbsp;";
    }
    while(start<=end)
    {
      showPageNumber=showPageNumber+"<a href=" +path+ "?pageNum=" +start+parameters+ ">[" +start+ "]</a>&nbsp;";
      start++;
    }
    if(end<pageCount)
    {
      showPageNumber=showPageNumber+"<a href=" +path+ "?pageNum=" +(end+1)+parameters+ ">" +">>>"+ "</a>&nbsp;";
    }
  }
  public String getShowPageNumber()
  {
    return showPageNumber;
  }
}

背景简介：KMP算法用来处理字符串匹配的。给你A,B两个字符串，检查B串是否是A串的子串，类似于Java的String.indexOf("")。之所以叫做KMP，是因为这个算法是由Knuth、Morris、Pratt三个提出来的，取了这三个人的名字的头一个字母。

原理介绍：找到匹配失败时的最合适的回退位置，而不是简单的回退到子串的第一个字符（常规的枚举查找方式，是简单的回退到子串的第一个字符，接下来准备写一篇KMP算法的性能分析Java实现实例），即可提高查找的效率。因此为了找到这个合适的位置，先对子串预处理，从而得到一个回退位置的数组。过多的理论就不介绍了。

总体而言比较简单，KMP算一个经典的算法例子，很多笔试、面试也会问起。现总结一下，放在这里供大家参考、交流，希望对大家有所帮助，下面直接给出实现例子，测试与分析也包含其中。

一、一个文件源代码

KMP.java

源代码为：

package algorithm.kmp;

/**
* KMP算法的Java实现例子与测试、分析
* @author 崔卫兵
* @date 2009-3-25
*/
public class KMP {
/**
* 对子串加以预处理，从而找到匹配失败时子串回退的位置
* 找到匹配失败时的最合适的回退位置，而不是回退到子串的第一个字符，即可提高查找的效率
* 因此为了找到这个合适的位置，先对子串预处理，从而得到一个回退位置的数组
* @param B，待查找子串的char数组
* @return
*/
public static int[] preProcess(char [] B) {
int size = B.length;
int[] P = new int[size];
P[0]=0;
int j=0;
//每循环一次，就会找到一个回退位置
for(int i=1;i
//当找到第一个匹配的字符时，即j>0时才会执行这个循环
//或者说p2中的j++会在p1之前执行（限于第一次执行的条件下）
//p1
while(j>0 %26amp;%26amp; B[j]!=B[i]){
j=P[j];
}
//p2，由此可以看出，只有当子串中含有重复字符时，回退的位置才会被优化
if(B[j]==B[i]){
j++;
}
//找到一个回退位置j，把其放入P[i]中
P[i]=j;
}
return P;
}

/**
* KMP实现
* @param parStr
* @param subStr
* @return
*/
public static void kmp(String parStr, String subStr) {
int subSize = subStr.length();
int parSize = parStr.length();
char[] B = subStr.toCharArray();
char[] A = parStr.toCharArray();
int[] P = preProcess(B);
int j=0;
int k =0;
for(int i=0;i
//当找到第一个匹配的字符时，即j>0时才会执行这个循环
//或者说p2中的j++会在p1之前执行（限于第一次执行的条件下）
//p1
while(j>0 %26amp;%26amp; B[j]!=A[i]){
//找到合适的回退位置
j=P[j-1];
}
//p2 找到一个匹配的字符
if(B[j]==A[i]){
j++;
}
//输出匹配结果，并且让比较继续下去
if(j==subSize){
j=P[j-1];
k++;
System.out.printf("Find subString '%s' at %d\n",subStr,i-subSize+1);
}
}
System.out.printf("Totally found %d times for '%s'.\n\n",k,subStr);
}

public static void main(String[] args) {
//回退位置数组为P[0, 0, 0, 0, 0, 0]
kmp("abcdeg, abcdeh, abcdef!这个会匹配1次","abcdef");
//回退位置数组为P[0, 0, 1, 2, 3, 4]
kmp("Test ititi ititit! Test ititit!这个会匹配2次","ititit");
//回退位置数组为P[0, 0, 0]
kmp("测试汉字的匹配，崔卫兵。这个会匹配1次","崔卫兵");
//回退位置数组为P[0, 0, 0, 1, 2, 3, 4, 5, 6]
kmp("这个会匹配0次","it1it1it1");
}
}

二、输出结果

Find subString 'abcdef' at 16
Totally found 1 times for 'abcdef'.

Find subString 'ititit' at 11
Find subString 'ititit' at 24
Totally found 2 times for 'ititit'.

Find subString '崔卫兵' at 8
Totally found 1 times for '崔卫兵'.

Totally found 0 times for 'it1it1it1'.

三、总结

总体而言，KMP算法通过找到合适的回退位置从而可以提高匹配效率，但是如果匹配位置都是第一个字符呢？例如测试代码中的

//回退位置数组为P[0, 0, 0, 0, 0, 0]
kmp("abcdeg, abcdeh, abcdef!这个会匹配2次","abcdef");

接下来准备写一篇KMP算法的性能分析Java实现实例，下文再见。^_^

来源：http://blog.chinaunix.net/u1/50399/showart_408864.html

输出结果：
源点：0; 终点：2; 长度：10; 终点前趋：-1
源点：0; 终点：4; 长度：30; 终点前趋：-1
源点：0; 终点：3; 长度：50; 终点前趋：1
源点：0; 终点：5; 长度：60; 终点前趋：2

转自：http://www.blogjava.net/javacap/archive/2007/12/13/167364.html
为了便于管理，先引入个基础类：

一 插入排序
该算法在数据规模小的时候十分高效，该算法每次插入第K+1到前K个有序数组中一个合适位置，K从0开始到N-1,从而完成排序：

二 冒泡排序
这可能是最简单的排序算法了，算法思想是每次从数组末端开始比较相邻两元素，把第i小的冒泡到数组的第i个位置。i从0一直到N-1从而完成排序。（当然也可以从数组开始端开始比较相邻两元素，把第i大的冒泡到数组的第N-i个位置。i从0一直到N-1从而完成排序。)

三，选择排序
选择排序相对于冒泡来说，它不是每次发现逆序都交换，而是在找到全局第i小的时候记下该元素位置，最后跟第i个元素交换，从而保证数组最终的有序。
相对与插入排序来说，选择排序每次选出的都是全局第i小的，不会调整前i个元素了。

四 Shell排序
Shell排序可以理解为插入排序的变种，它充分利用了插入排序的两个特点：
1）当数据规模小的时候非常高效
2）当给定数据已经有序时的时间代价为O(N)
所以，Shell排序每次把数据分成若个小块，来使用插入排序，而且之后在这若个小块排好序的情况下把它们合成大一点的小块，继续使用插入排序，不停的合并小块，知道最后成一个块，并使用插入排序。

这里每次分成若干小块是通过“增量” 来控制的，开始时增量交大，接近N/2,从而使得分割出来接近N/2个小块，逐渐的减小“增量“最终到减小到1。

一直较好的增量序列是2^k-1,2^(k-1)-1,.....7,3,1,这样可使Shell排序时间复杂度达到O(N^1.5)
所以我在实现Shell排序的时候采用该增量序列

package algorithms;

/**
 * @author yovn
 */
public class ShellSorter<E extends Comparable<E>> extends Sorter<E>  {

    /* (non-Javadoc)
     * Our delta value choose 2^k-1,2^(k-1)-1,.7,3,1.
     * complexity is O(n^1.5)
     * @see algorithms.Sorter#sort(E[], int, int)
     */
    @Override
    public void sort(E[] array, int from, int len) {
        
        //1.calculate  the first delta value;
        int value=1;
        while((value+1)*2<len)
        {
            value=(value+1)*2-1;
        
        }
    
        for(int delta=value;delta>=1;delta=(delta+1)/2-1)
        {
            for(int i=0;i<delta;i++)
            {
                modify_insert_sort(array,from+i,len-i,delta);
            }
        }

    }
    
    private final  void modify_insert_sort(E[] array, int from, int len,int delta) {
          if(len<=1)return;
          E tmp=null;
          for(int i=from+delta;i<from+len;i+=delta)
          {
              tmp=array[i];
              int j=i;
              for(;j>from;j-=delta)
              {
                  if(tmp.compareTo(array[j-delta])<0)
                  {
                      array[j]=array[j-delta];
                  }
                  else break;
              }
              array[j]=tmp;
          }

    }
}

五 快速排序
快速排序是目前使用可能最广泛的排序算法了。
一般分如下步骤：
1）选择一个枢纽元素（有很对选法，我的实现里采用去中间元素的简单方法）
2）使用该枢纽元素分割数组，使得比该元素小的元素在它的左边，比它大的在右边。并把枢纽元素放在合适的位置。
3）根据枢纽元素最后确定的位置，把数组分成三部分，左边的，右边的，枢纽元素自己，对左边的，右边的分别递归调用快速排序算法即可。
快速排序的核心在于分割算法，也可以说是最有技巧的部分。

还有归并排序，堆排序，桶式排序，基数排序，下次在归纳。

1. import java.io.BufferedWriter;   
2. import java.io.FileOutputStream;   
3. import java.io.FileWriter;   
4. import java.io.IOException;   
5. import java.io.OutputStreamWriter;   
6. import java.io.RandomAccessFile;   
7.   
8. /**  
9.  * 描述：追加内容到文件末尾  
10.  * @author Administrator  
11.  *  
12.  */  
13. public class WriteStreamAppend {   
14.     /**  
15.      * 追加文件：使用FileOutputStream，在构造FileOutputStream时，把第二个参数设为true  
16.      *   
17.      * @param fileName  
18.      * @param content  
19.      */  
20.     public static void method1(String file, String conent) {   
21.         BufferedWriter out = null;   
22.         try {   
23.             out = new BufferedWriter(new OutputStreamWriter(   
24.                     new FileOutputStream(file, true)));   
25.             out.write(conent);   
26.         } catch (Exception e) {   
27.             e.printStackTrace();   
28.         } finally {   
29.             try {   
30.                 out.close();   
31.             } catch (IOException e) {   
32.                 e.printStackTrace();   
33.             }   
34.         }   
35.     }   
36.   
37.     /**  
38.      * 追加文件：使用FileWriter  
39.      *   
40.      * @param fileName  
41.      * @param content  
42.      */  
43.     public static void method2(String fileName, String content) {   
44.         try {   
45.             // 打开一个写文件器，构造函数中的第二个参数true表示以追加形式写文件   
46.             FileWriter writer = new FileWriter(fileName, true);   
47.             writer.write(content);   
48.             writer.close();   
49.         } catch (IOException e) {   
50.             e.printStackTrace();   
51.         }   
52.     }   
53.   
54.     /**  
55.      * 追加文件：使用RandomAccessFile  
56.      *   
57.      * @param fileName  
58.      *            文件名  
59.      * @param content  
60.      *            追加的内容  
61.      */  
62.     public static void method3(String fileName, String content) {   
63.         try {   
64.             // 打开一个随机访问文件流，按读写方式   
65.             RandomAccessFile randomFile = new RandomAccessFile(fileName, "rw");   
66.             // 文件长度，字节数   
67.             long fileLength = randomFile.length();   
68.             // 将写文件指针移到文件尾。   
69.             randomFile.seek(fileLength);   
70.             randomFile.writeBytes(content);   
71.             randomFile.close();   
72.         } catch (IOException e) {   
73.             e.printStackTrace();   
74.         }   
75.     }   
76.   
77.     public static void main(String[] args) {   
78.         System.out.println("start");   
79.         method1("c:/test.txt", "追加到文件的末尾");   
80.         System.out.println("end");   
81.     }   
82.   
83. }  

Hibernate.cfg.xml配置文件：
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD//EN" "hibernate-configuration-2.0.dtd">
<hibernate-configuration>
    <session-factory>
        <!-- properties -->
        <!-- jndi -->
        <property name="connection.datasource">java:comp/env/jdbc/quickstart</property>
        <property name="connection.provider_class">net.sf.hibernate.connection.DatasourceConnectionProvider</property>
        <property name="dialect">net.sf.hibernate.dialect.SQLServerDialect</property>
        <!-- jdbc
        <property name="connection.url">jdbc:microsoft:sqlserver://localhost:1433;SelectMethod=cursor;DatabaseName=pubs</property>
        <property name="connection.driver_class">com.microsoft.jdbc.sqlserver.SQLServerDriver</property>
        <property name="connection.username">sa</property>
        <property name="connection.password"></property>
         -->
        <property name="jdbc.fetch_size">50</property><!-- 一次读的数据库记录数 -->
        <property name="jdbc.batch_size">30</property><!-- 设定对数据库进行批量删除 -->
        <property name="show_sql">true</property><!-- 将Hibernate发送给数据库的sql显示出来 -->
        <!-- Mapping files -->
        <mapping resource="cat.hbm.xml"/>
    </session-factory>
</hibernate-configuration>

数据库表主键的知识点：
Generator 为每个 POJO 的实例提供唯一标识。一般情况，我们使用“native”。class 表示采用由生成器接口net.sf.hibernate.id.IdentifierGenerator 实现的某个实例，其中包括：

“assigned”
主键由外部程序负责生成，在 save() 之前指定一个。

“hilo”
通过hi/lo 算法实现的主键生成机制，需要额外的数据库表或字段提供高位值来源。

“seqhilo”
与hilo 类似，通过hi/lo 算法实现的主键生成机制，需要数据库中的 Sequence，适用于支持 Sequence 的数据库，如Oracle。

“increment”
主键按数值顺序递增。此方式的实现机制为在当前应用实例中维持一个变量，以保存着当前的最大值，之后每次需要生成主键的时候将此值加1作为主键。这种方式可能产生的问题是：不能在集群下使用。

“identity”
采用数据库提供的主键生成机制。如DB2、SQL Server、MySQL 中的主键生成机制。

“sequence”
采用数据库提供的 sequence 机制生成主键。如 Oralce 中的Sequence。

“native”
由 Hibernate 根据使用的数据库自行判断采用 identity、hilo、sequence 其中一种作为主键生成方式。

“uuid.hex”
由 Hibernate 基于128 位 UUID 算法 生成16 进制数值（编码后以长度32 的字符串表示）作为主键。

“uuid.string”
与uuid.hex 类似，只是生成的主键未进行编码（长度16），不能应用在 PostgreSQL 数据库中。

“foreign”
使用另外一个相关联的对象的标识符作为主键。

以下举例：
1、指定参数的情况：
    <id name="id" unsaved-value="0"> 
      <generator class="sequence">
        <param name="sequence">SEQ_CHILD</param>
      </generator>
</id>
使用的是sequence，适合oracle数据库；

2、对于sql server2000中的数据库子增字段,在配置文件使用下列方法实现：
<id name="id" type="long" unsaved-value="0">
     <column name="id" sql-type="numeric" not-null="true" />
     <generator class="identity" /> 
</id>
这里主要是:identity:代表由sql server2000数据库自己提供子增字段.如果要hibernate自己提供,则用increment关键字来实现

3、如果表中的主键用字符串类型:可以用hibernate自己提供的方法实现主键唯一:
  <id name="id" type="string" unsaved-value="null">
      <column name="cid" sql-type="char(32)" not-null="true" />
      <generator class="uuid.hex" />
  </id>
使用的是uuid.hex: 采用128位的算法来生成一个32位字符串。最通用的一种方式。适用于所有数据库。

重要的知识点:
1. 如果有部门表,有员工表,员工表中有dep_id,则表部门类和员工类是one-to-many的关系:
   可以使用:  ( 在部门类department中使用下列)
   Department类:  
     /**  部门的所有员工   */
    private Set staffs = new TreeSet();
    
    xml的文件:
      <set name="staffs" >
          <key column="dep_id"/>
          <one-to-many class="hbp.sys.data.Staff"/>
      </set>
      如果是list,需要用索引<index> </index>,具体其中的含义,不是很明白.待以后研究
      
 2. 如果部门要有一个负责人,即部门表(tb_department)中有一个字段:staff_id.
     那么表示部门和负责人之间的关系是many-to-one的关系
     Department类: 
      /** 部门负责人id */
    private Staff staff;
    
    xml 文件
     <many-to-one name="staff" class="hbp.sys.data.Staff"  column="staff_id"/>  
  
 3. 多对多关系,一般我们是做一个中间关联表.我用角色和权限做了个例子,
      Right(id,name)     Role(id,name)   中间表:tb_role_right(role_id,right_id)
      Right类中有一个Role的集合:private Set roles=new TreeSet();
      Role类中也有一个Right的集合:private Set rights=new TreeSet();
      则两者是明显的多对多关系.使用many-to-many来实现;
      xml文件中
      right.hbm.xml:如下:
        <set name="roles" table="tb_role_right" cascade="all">
           <key column="right_id"/>
           <many-to-many column="role_id" class="hbp.sys.data.Role"/>
        </set> 
      role.hbm.xml文件中类似:
        <set name="rights" table="tb_role_right" cascade="all">
          <key column="role_id"/>
          <many-to-many column="right_id" class="hbp.sys.data.Right"/>
        </set>

4. 几个值得注意的问题:
        a)在xml?映射文件中,写类的名字时一定用类的全名:即:包+类名如:(hbp.sys.data.Staff),这个错误使我费了半天劲.:(
        b)我在写实现基本DAO操作时,写了
             session.delete("from Right as right where right.id="+id);  
             程序死活报错,我折腾了半天,跟踪到底,才恍然大悟,hibernate在解析sql语句的时候把
             其中的right,当成了数据库中的右连接("保留字"),唉,这种关键字,不能随便用啊,:)

5. hibernate中HQL语言的查询根据你的sql的不同而返回不同的对象类型.
         如果你使用session.find(String hql)
         一般会返回一个List,如:from Staff staff;返回的是包含所有的员工对象的集合
         如你的hql为:select count(*) from Staff staff;则返回的是一个Integer对象
         如果你使用的hql为:select count(distinct staff.name),count(*) from Staff staff;则返回的是一个Object
         即Object[],需要先把他转换成Object[],然后在取[0],[1].
         这种设计我不知道hibernate是如何处理的,感觉既好也不好.好的是可以使用一个find获得任意查询
         不好在于根据hql来处理返回结果,容易出错.

public class ExcelManagerFactory {
   private static String key = "key";
   private ExcelManagerFactory() {
   }
  
   private static ExcelManagerIf instance = null;
   public static ExcelManagerIf getInstance(){
    if(instance == null){
             synchronized(key){
                 if(instance == null){
                     instance = new ExcelManagerImpl();
                 }
             }
         }
         return instance;
   }
}

2.声明一个接口

package com.factory;

import java.io.InputStream;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;

import javax.servlet.http.HttpServletResponse;

import com.gpdi.orm.object.ScoreRecordDetail;

public interface ExcelManagerIf {
 
 public boolean export(HttpServletResponse response, List<ScoreRecordDetail> list,LinkedHashMap hashMap);
 /********************************************************************************************************/
 public boolean export1(HttpServletResponse response,List list,LinkedHashMap hashMap);
 /********************************************************************************************************/

}
3.实现接口的类

package com.factory;

import java.io.IOException;

public class ExcelManagerImpl implements ExcelManagerIf
{
         public boolean export1(HttpServletResponse response, List list,LinkedHashMap hashMap)
         {
                    //实现具体功能的代码实现
         }
}
4.调用
  HttpServletResponse response=null;
  LinkedHashMap hm = new LinkedHashMap();
  List list = Object.getList();
   ExcelManagerIf eem = ExcelManagerFactory.getInstance();
   /******************************************************************/
   eem.export(response, list,hm);