xianshi.jsp

智能文档检索系统

       {
          String zu=zuhe_eqrs.getString("eq");
          StringTokenizer zu_sTokenizer=new StringTokenizer(zu,"\\");
       while(zu_sTokenizer.hasMoreTokens())
         { 
            String lisi=zu_sTokenizer.nextToken();
            lisi=lisi.trim();
            zuhe[0][n1]=lisi;//分解的输入内容放到nnn[mmm]里
           zuhe_nnn[zuhe_mmm]=lisi;//存放输入的内容  和 同义词
           zuhe_mmm++;
            n1++;
          
         }
          
          }
     }
     else
      {zuhe[1][n2]=zuhe_nnnn[i];n2++;
          if(zuhe_eqrs.next())
           {
             String zu=zuhe_eqrs.getString("eq");
             StringTokenizer zu_sTokenizer=new StringTokenizer(zu,"\\");
            while(zu_sTokenizer.hasMoreTokens())
              { 
              String zuhe_lisi=zu_sTokenizer.nextToken();
              zuhe_lisi=zuhe_lisi.trim();
              zuhe[1][n2]=zuhe_lisi;//分解的输入内容放到nnn[mmm]里
              n2++;
              zuhe_nnn[zuhe_mmm]=zuhe_lisi;//存放输入的内容  和 同义词
             zuhe_mmm++;
              }//while
           }//if
         }//else
      }//for

      for(int i=0;i<n1;i++)
      {
        for(int j=0;j<n2;j++)
            {if(!zuhe[0][i].equalsIgnoreCase(zuhe[1][j]))
            {zuhe_nnnnn[zuhe_mmmmm]=zuhe[0][i]+" "+zuhe[1][j];
            zuhe_mmmmm++;}
            }
      }
     
      for(int i=0;i<zuhe_mmm;i++)
        {  zuhe_nnnnn[zuhe_mmmmm]=zuhe_nnn[i];
           zuhe_mmmmm++;
        }
}//if2个
      



if(zuhe_mmmm==3)//输入的内容是3段  找同义词  
{ n1=0;n2=0;n3=0;
  for(int i=0;i<=2;i++)
  {String zuhe_eqsql="select eq from tablex where word='"+zuhe_nnnn[i]+"' and eq<>''";
   ResultSet zuhe_eqrs=stmt2.executeQuery(zuhe_eqsql);
    if(i==0)
     { zuhe[0][n1]=zuhe_nnnn[i];
       n1++;
       if(zuhe_eqrs.next())
       {
          String zu=zuhe_eqrs.getString("eq");
          StringTokenizer zu_sTokenizer=new StringTokenizer(zu,"\\");
       while(zu_sTokenizer.hasMoreTokens())
         { 
            String lisi=zu_sTokenizer.nextToken();
            lisi=lisi.trim();
            zuhe[0][n1]=lisi;//分解的输入内容放到nnn[mmm]里
            n1++;
          zuhe_nnn[zuhe_mmm]=lisi;//存放输入的内容  和 同义词
             zuhe_mmm++;
         }//while
          
          }//if
     }//if0
     if(i==1)
      {zuhe[1][n2]=zuhe_nnnn[i];n2++;
          if(zuhe_eqrs.next())
           {
             String zu=zuhe_eqrs.getString("eq");
             StringTokenizer zu_sTokenizer=new StringTokenizer(zu,"\\");
            while(zu_sTokenizer.hasMoreTokens())
              { 
              String lisi=zu_sTokenizer.nextToken();
              lisi=lisi.trim();
              zuhe[1][n2]=lisi;//分解的输入内容放到nnn[mmm]里
              n2++;
              zuhe_nnn[zuhe_mmm]=lisi;//存放输入的内容  和 同义词
             zuhe_mmm++;
              }//while
           }//if
         }//if1
         if(i==2)
      {zuhe[2][n3]=zuhe_nnnn[i];n3++;
          if(zuhe_eqrs.next())
           { 
             String zu=zuhe_eqrs.getString("eq");
             
             StringTokenizer zu_sTokenizer=new StringTokenizer(zu,"\\");
            while(zu_sTokenizer.hasMoreTokens())
              { 
              String lisi=zu_sTokenizer.nextToken();
              lisi=lisi.trim();
              zuhe[2][n3]=lisi;//分解的输入内容放到nnn[mmm]里
              n3++;
              zuhe_nnn[zuhe_mmm]=lisi;//存放输入的内容  和 同义词
             zuhe_mmm++;
              }//while
           }//if
         }//if2
         
      }//for

     for(int i=0;i<n1;i++)
      {
        for(int j=0;j<n2;j++)
            {
            for(int r=0;r<n3;r++)
            {if(!zuhe[0][i].equalsIgnoreCase(zuhe[1][j]) && !zuhe[0][i].equalsIgnoreCase(zuhe[2][r]) && !zuhe[1][j].equalsIgnoreCase(zuhe[2][r]))
             {zuhe_nnnnn[zuhe_mmmmm]=zuhe[0][i]+" "+zuhe[1][j]+" "+zuhe[2][r];
            zuhe_mmmmm++;}}
            }
      }
     for(int i=0;i<zuhe_mmm;i++)
      {
         zuhe_nnnnn[zuhe_mmmmm]=zuhe_nnn[i];
         zuhe_mmmmm++;
       }
}//if(zuhe_mmmm==3)//输入的内容是3段  找同义词  



if(zuhe_mmmm>3)//输入的内容是大于3段  找同义词  
{
  for(int i=0;i<zuhe_mmmm;i++)//找同义词
    {   
        String zuhe_eqsql="select eq from tablex where word='"+zuhe_nnnn[i]+"' and eq<>''";
        ResultSet zuhe_eqrs=stmt2.executeQuery(zuhe_eqsql);
        if(zuhe_eqrs.next())
         {   
           String  zuhe_eq=zuhe_eqrs.getString("eq");
           zuhe_eq=zuhe_eq.trim();
           zuhe_nnn[zuhe_mmm]=zuhe_eq;//分解的输入内容的  同意词  放到zuhe_nnn[mmm]里_
           zuhe_mmm++;
         }
     }
   if(zuhe_mmmm>=1) //输入的内容大于一个，需要相互匹配
    {   
      for(int i=0;i<zuhe_mmm;i++)
        {  
           for(int j=0;j<zuhe_mmm;j++)
             {
                if(!zuhe_nnn[i].equalsIgnoreCase(zuhe_nnn[j]))     //如果两个关键字不同则陪，相同则不搭配
                   {
                        zuhe_nnnnn[zuhe_mmmmm]=zuhe_nnn[i]+" "+zuhe_nnn[j];
                        zuhe_mmmmm++;  
                    }
              }
        }   
     for(int i=0;i<zuhe_mmm;i++)//输入所有涉及的内容，以防前面搭配的内容找不到文章
       {
         zuhe_nnnnn[zuhe_mmmmm]=zuhe_nnn[i];
         zuhe_mmmmm++;
       }
   }//if(zuhe_mmmm>=1) //输入的内容大于一个，需要相互匹配
}//end if(zuhe_mmmm>3)//输入的内容是大于3段  找同义词

 
 
 

for(int zuhe_i=0;zuhe_i<zuhe_mmmmm;zuhe_i++)//大循环  循环查找论文编号放到n[l]中
{     
    String zuhe_parameterValue=null;
    zuhe_parameterValue=zuhe_nnnnn[zuhe_i]; 


    int j=0,k=0,t=0,w=0;
    int o=0; int u=0; int io=0;int qq=0;int jj=0; int kk=0;int ee=0;int mmm=0; int xxx=0;int bbb=0;
    String shui=null;
    String a[]=new String[1200];
    String nnn[]=new String[1200];
    String b[]=new String[1200]; 

    StringTokenizer sTokenizer=null; 
 
    sTokenizer=new StringTokenizer(zuhe_parameterValue,"\t\b.,:?#;'@!$%^*&()《》 ");//提取要搜索的内容，去掉没用的空格 

    while(sTokenizer.hasMoreTokens())
    { 
       String lisi=sTokenizer.nextToken();
       nnn[mmm]=lisi;//分解的输入内容放到nnn[mmm]里

       mmm++;
    }

   String hotsql="select ID,did,times from hotsearch where word='"+zuhe_parameterValue+"'";//使用的是未分解的输入内容
   ResultSet hotrs=stmt2.executeQuery(hotsql);

   if(hotrs.next())//热表里有相应的词
   {   
        int times=hotrs.getInt("times");//如果热表里面有相应的词，则次数加一
        int hotID=hotrs.getInt("ID");
        times++;
        hotsql="update hotsearch set times="+times+" where ID="+hotID;
        stmt.executeUpdate(hotsql);
addTimes.addTimes(zuhe_parameterValue);
        StringTokenizer stok=null;
        String hotid=hotrs.getString("did");
        hotid=hotid.trim();
        stok=new StringTokenizer(hotid,"\\");//hotid中去掉\

        while(stok.hasMoreTokens()) //提出文章号
         {  
            String li=stok.nextToken();
            n[l]=Integer.parseInt(li);
            l++;     
         }
   } 
   else//热表里没有相应的词，则从search表开始查找，并把文章号加入到热表里
    {
                   
       
         for(int x=0;x<mmm;x++)
          {
             String lisi=nnn[x];
             String sql="select relation from search where word='"+lisi+"'" ; //sql语句查找词属于哪种 ; 
             ResultSet rs=stmt.executeQuery(sql);//执行sql
             while(rs.next())
                {
                     int i=Integer.parseInt(rs.getString("relation"));
                     if(i==2)//是作者
                       { 
                         a[j]=lisi;j++;//j中存储查询框中所输入的作者的个数 a[j]中存储作者
                       };
                     if(i==3)//是关键字
                       {
                         b[k]=lisi;
                         k++;                                   //k中存储的为查询框所输入的关键字的数量 b[k]中存储关键字
                       }; 
                };

            rs.close();

              //这里要增添新的代码，以判断查询框中的词汇有否来自于另外一个新表，即词汇本体表，表中存储着关键字，关键字的同义词，上位词以及它的下位词（以下简称回）。如果查询框中输入了某个关键字的同义词，那么，我们新设一个记数变量，记录之。

           }; //退出while循环，统计查询框中所输入字符流中相应作者和关键字的数量并用两个数组存储之。

    /*这里要新加入一个判断，因为输入的关键字也有可能存在于词汇本题表中，即对于同一个关键字，w,k都是要++的。
    判断所要完成的工作是：如果关键字数组中的记录数值k和回数组中的记录数值hui相同，说明这是两个关键字，不再做回的
    比较于扩充，一切皆在if关键字中去实现。（）

    */ // 分情况书写sql语句，作者为多个时，完成自身的多次连接。同理关键字。 
           int c[]=new int[20];
           int d=0;
           int x;// 记录d值 
           if(j==1)// j==1;作者为一个时，从author表中查找did 存储到c[d]中
             { 
                String sql1="select did from author where name='"+a[0]+"'" ; //sql语句 ; 
                ResultSet rs1=stmt.executeQuery(sql1);
                while(rs1.next())
                 {
                    c[d]=Integer.parseInt(rs1.getString("did"));
                    d++;
                 };
                rs1.close(); 
              } ;

            if(j==2) // j==2;作者为两个时候，两表自身查询找相同的did 
            { 
                 String sql1="select first.did from author first, author second where first.did=second.did and first.name='"+a[0]+"'and second.name='"+a[1]+"' "; //sql语句 ; 

                ResultSet rs1=stmt.executeQuery(sql1);
            //如果两表自身查询结果为空，则说明两个作者的did不同，既他们不曾写过相同的一篇文章，这里我们跳出循环，结束程序。
                while(rs1.next())
                {
                  c[d]=Integer.parseInt(rs1.getString("did"));d++;
                };
                rs1.close(); 
            } ; 

            if(j>=3)// j==3;作者为两个时候，三表自身查询找相同的did 
            { 
                String sql1="select first.did from author first, author second ,author third where first.did=second.did and second.did=third.did and first.name='"+a[0]+"'and second.name='"+a[1]+"'and third.name='"+a[2]+"' "; //sql语句 ; 
                ResultSet rs1=stmt.executeQuery(sql1);
            //如果三表自身查询结果为空，则说明三个作者的did不同，既他们不曾写过相同的一篇文章，这里我们跳出循环，结束程序。
            //c=n;
               while(rs1.next())
                 {
                   c[d]=Integer.parseInt(rs1.getString("did"));d++;
                 };
               rs1.close(); 
            } ; 

                x=d;//记录d值;即根据作者所查找出的具有相同论文id的论文id个数           
                int f=0;
                int e[]=new int[2000];
                if(k==1)//k==1 关键字为一个时，从keyword 中查找did并存储到e[f]中
                { 
                    String sql2="select did from keyword where word='"+b[0]+"'" ; //sql语句 ; 
                    ResultSet rs2=stmt.executeQuery(sql2);
                    //e=n;
                    while(rs2.next())
                    {
                         e[f]=Integer.parseInt(rs2.getString("did"));
                         f++;
                                                                         //e[f]中存储的是关键字为b[k]时从关键字表中查询出符合要求的论文的id.注:一个关键字时,只从本表查询;
                                                                    //多个关键字时,将完成本表的多次自身连接,找出相同的id并存储之*/
                    }; 
                    rs2.close();
                } ;


                if(k==2)//k==2时，关键字为两个，两表自身查询寻找相同的did
                { 
                    String sql2="select first.did from keyword first, keyword second where first.word='"+b[0]+"' and second.word='"+b[1]+"'and first.did=second.did " ; //sql语句 ; 
                    ResultSet rs2=stmt.executeQuery(sql2);
                                                                  //如果两表自身查询结果为空，则说明两个关键字的did不同，既他们不曾出现在相同的一篇文章里，这里我们跳出循环，结束程序。
                    while(rs2.next())
                    {
                       e[f]=Integer.parseInt(rs2.getString("did"));
                       f++;
                                                                //e[f]中存储的是两个关键字之相同的论文id,即这两个关键字可能
                                                                    //对应着多篇论文,在这里,我们用e[f]数组存储这或者多篇论文的id 
                    } 
                    rs2.close();
                }


                if(k>=3)
                { 
                    String sql2="select first.did from keyword first, keyword second,keyword third where first.word='"+b[0]+"' and second.word='"+b[1]+"'and third.word='"+b[2]+"'and first.did=second.did and third.did=second.did " ; //sql语句 ; 
                    ResultSet rs2=stmt.executeQuery(sql2);
                    //如果两表自身查询结果为空，则说明两个关键字的did不同，既他们不曾出现在相同的一篇文章里，这里我们跳出循环，结束程序。
                    //e=n;
                    while(rs2.next())
                    {
                       e[f]=Integer.parseInt(rs2.getString("did"));
                       f++;//e[f]中存储的是两个关键字之相同的论文id,即这两个关键字可能对应着多篇论文,在这里,我们用e[f]数组存储这或者多篇论文的id */
                    }; 
                    rs2.close();
                }

                int everyl=0;
                int everyn[]=new int[400];
                
                if(mmm>=0)//首先查找题目中包含关键字的文章号
                   {                                 
                        String sqlxian_title="select ID from discourse where title like '%"+nnn[0]+"%' ";                   
                        for(int i=1;i<mmm;i++)
                           { 
                               sqlxian_title=sqlxian_title+"or title like '%"+nnn[i]+"%'";                       
                           }
                        ResultSet rsxian_title=stmt1.executeQuery(sqlxian_title);
                        while(rsxian_title.next())
                          {
                             n[l]=Integer.parseInt(rsxian_title.getString("ID"));
                             l++;
                             everyn[everyl]=Integer.parseInt(rsxian_title.getString("ID"));
                             everyl++;
                          }
                    }
                
                if(f!=0&&d!=0)//作者和关键子都不是零
                { 
                    for(int i=0;i<f;i++)
                    {
                      for(int ii=0;ii<d;ii++) 
                      {
                          if(e[i]==c[ii])//作者的文章号是否等于关键子的文章号
                            {
                               n[l]=e[i];
                               everyn[everyl]=e[i];
                               l++;
                               everyl++;   
                            }