精华内容
下载资源
问答
  • java中文分词算法

    万次阅读 2016-05-19 11:10:47
    分词算法我还没来得及修改,还可以看到现象:   http://www.talaishuo.com/searchResult.do?searchFileName=hello 你会发现只有开始包含hello这个字段的搜索串才能得到匹配,这就问题来了,数据库中...

     我想只要是学过数据库的孩纸,不管是mysql,还是sqlsever,一提到查找,本能的想到的便是like关键字,其实去转盘网分类模式)之前也是采用这种算法,但我可以告诉大家一个很不幸的事情,like匹配其实会浪费大量的有用资源,原因这里不说了请自己想一想,我们还是直接摆事实验证。

       现在用去转盘网搜:hello 找个单词,如下:

       http://www.quzhuanpan.com/source/search.action?q=hello&currentPage=1

    翻页你会发现只要是包含hello的单词都找到了,但是如果你用like的话是不会有这个效果的,不信让我们再看一下,还好他来说电影网的分词算法我还没来得及修改,还可以看到现象:

       http://www.talaishuo.com/searchResult.do?searchFileName=hello

    你会发现只有开始包含hello这个字段的搜索串才能得到匹配,这就问题来了,数据库中大量的资源岂不是白白浪费了,不过没事,伟大的人类还是很聪明的,发明了分词,分词的原理我就不讲了,请自己百度吧,还是直接上代码,提示,这里需要四个jar包作为工具,我先上传的去转盘,想要做分词的请先下载:

       分词包下载地址1

       分词包下载地址2

    另外附上2篇有用的博客:百度网盘爬虫 百度图片爬虫

    package com.tray.indexData;
    import java.io.File;
    import java.io.IOException;
    import java.io.StringReader;
    import java.math.BigInteger;
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
     
    import org.apache.lucene.analysis.Analyzer;
    import org.apache.lucene.analysis.TokenStream;
    import org.apache.lucene.document.Document;
    import org.apache.lucene.document.Fieldable;
    import org.apache.lucene.index.CorruptIndexException;
    import org.apache.lucene.index.IndexReader;
    import org.apache.lucene.index.IndexWriter;
    import org.apache.lucene.index.IndexWriterConfig;
    import org.apache.lucene.index.IndexWriterConfig.OpenMode;
    import org.apache.lucene.index.Term;
    import org.apache.lucene.queryParser.MultiFieldQueryParser;
    import org.apache.lucene.queryParser.QueryParser;
    import org.apache.lucene.search.IndexSearcher;
    import org.apache.lucene.search.PrefixQuery;
    import org.apache.lucene.search.Query;
    import org.apache.lucene.search.ScoreDoc;
    import org.apache.lucene.search.TermQuery;
    import org.apache.lucene.search.TopDocs;
    import org.apache.lucene.search.TopScoreDocCollector;
    import org.apache.lucene.search.WildcardQuery;
    import org.apache.lucene.search.highlight.Highlighter;
    import org.apache.lucene.search.highlight.QueryScorer;
    import org.apache.lucene.search.highlight.SimpleHTMLFormatter;
    import org.apache.lucene.store.Directory;
    import org.apache.lucene.store.FSDirectory;
    import org.apache.lucene.util.Version;
    import org.wltea.analyzer.lucene.IKAnalyzer;
     
    import com.tray.bean.SerachResult;
    import com.tray.common.tools.DateFormater;
     
    public class LuceneSearch {
         
        private static String DISC_URL = "/home/indexData/data";
         
        static {
            String os = System.getProperty("os.name");  
            if(os.toLowerCase().startsWith("win")){  
                DISC_URL = "E:\\indexData\\data"; 
            }
            else{
                DISC_URL ="/home/indexData/data";
            }
        }
             
        //指定分词器 
        private Analyzer analyzer=new IKAnalyzer(); 
        private static Directory directory;
        //配置
        private static IndexWriterConfig iwConfig;
        //配置IndexWriter
        private static IndexWriter writer;  
        private static File indexFile = null;  
         
        private static Version version = Version.LUCENE_36;
         
        private final int PAPGESIZE=10;
     
        /**
         * 全量索引
         * @Author haoning
         */
        public void init() throws Exception {
             
            try {
                indexFile = new File(DISC_URL);
                if (!indexFile.exists()) {
                    indexFile.mkdir();
                }
                directory=FSDirectory.open(indexFile);  
                //配置IndexWriterConfig  
                iwConfig = new IndexWriterConfig(version,analyzer);  
                iwConfig.setOpenMode(OpenMode.CREATE_OR_APPEND);  
                    //创建写索引对象  
                writer = new IndexWriter(directory,iwConfig);   
            } catch (Exception e) {
            }
        }
         
        public void closeWriter(){
            try {
                writer.close();
            } catch (CorruptIndexException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
         
        public void commit(){
             
            try {
                writer.commit();
            } catch (CorruptIndexException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
         
        /**
         * 一个一个索引
         * @Author haoning
         */
        public void singleIndex(Document doc) throws Exception {
            writer.addDocument(doc);
        }
         
        /**
         * 一个跟新
         * @Author haoning
         */
        public void singleUpdate(Document doc) throws Exception {
            Term term = new Term("url", doc.get("url"));
            writer.updateDocument(term,doc);
        }
         
        /**
         * 全量索引
         * @Author haoning
         */
        public void fullIndex(Document[] documentes) throws Exception {
             
            writer.deleteAll();
            for (Document document : documentes) {
                writer.addDocument(document);
            }
            writer.commit();
        }
         
        /**
         * 根据id删除索引
         * @Author haoning
         */
        public void deleteIndex(Document document)throws Exception{
            Term term = new Term("url", document.get("url"));//url才是唯一标志
            writer.deleteDocuments(term);
            writer.commit();
        }
         
        /**
         * 根据id增量索引
         * @Author haoning
         */
        public void updateIndex(Document[] documentes) throws Exception{
            for (Document document : documentes) {
                Term term = new Term("url", document.get("url"));
                writer.updateDocument(term, document);
            }
            writer.commit();
        }
         
        /**
         * 直接查询
         * @Author haoning
         */
        public void simpleSearch(String filedStr,String queryStr,int page, int pageSize) throws Exception{
            File indexDir = new File(DISC_URL);  
            //索引目录  
            Directory dir=FSDirectory.open(indexDir);  
            //根据索引目录创建读索引对象  
            IndexReader reader = IndexReader.open(dir);  
            //搜索对象创建  
            IndexSearcher searcher = new IndexSearcher(reader);
            TopScoreDocCollector topCollector = TopScoreDocCollector.create(searcher.maxDoc(), false);
             
            Term term = new Term(filedStr, queryStr);
            Query query = new TermQuery(term);
            searcher.search(query, topCollector);
            ScoreDoc[] docs = topCollector.topDocs((page-1)*pageSize, pageSize).scoreDocs;
             
            printScoreDoc(docs, searcher);
        }
         
        /**
         * 高亮查询
         * @Author haoning
         */
        public Map<String, Object> highLightSearch(String filed,String keyWord,int curpage, int pageSize) throws Exception{
            List<SerachResult> list=new ArrayList<SerachResult>();
            Map<String,Object> map = new HashMap<String,Object>();
            if (curpage <= 0) {
                curpage = 1;
            }
            if (pageSize <= 0 || pageSize>20) {
                 pageSize = PAPGESIZE;
            }
            File indexDir = new File(DISC_URL); //索引目录   
            Directory dir=FSDirectory.open(indexDir);//根据索引目录创建读索引对象    
            IndexReader reader = IndexReader.open(dir);//搜索对象创建    
            IndexSearcher searcher = new IndexSearcher(reader);
             
            int start = (curpage - 1) * pageSize;
             
            Analyzer analyzer = new IKAnalyzer(true);
            QueryParser queryParser = new QueryParser(Version.LUCENE_36, filed, analyzer);
            queryParser.setDefaultOperator(QueryParser.AND_OPERATOR);
            Query query = queryParser.parse(keyWord);
             
            int hm = start + pageSize;
            TopScoreDocCollector res = TopScoreDocCollector.create(hm, false);
            searcher.search(query, res);
             
            SimpleHTMLFormatter simpleHTMLFormatter = new SimpleHTMLFormatter("<span style='color:red'>", "</span>");
            Highlighter highlighter = new Highlighter(simpleHTMLFormatter, new QueryScorer(query));
             
            long amount = res.getTotalHits();
            //long pages = (rowCount - 1) / pageSize + 1; //计算总页数
             
            map.put("amount",amount);//总共多少条记录
             
            TopDocs tds = res.topDocs(start, pageSize);
            ScoreDoc[] sd = tds.scoreDocs;
             
            for (int i = 0; i < sd.length; i++) {
                Document doc = searcher.doc(sd[i].doc);
                String temp=doc.get("name");
                //做高亮处理
                TokenStream ts = analyzer.tokenStream("name", new StringReader(temp));
                 
                SerachResult record=new SerachResult();
                String name = highlighter.getBestFragment(ts,temp); 
                String skydirverName=doc.get("skydirverName");
                String username=doc.get("username");
                String shareTime=doc.get("shareTime");
                String describ=doc.get("describ");
                String typeId=doc.get("typeId");
                String id=doc.get("id");
                String url=doc.get("url");
                 
                record.setName(name);
                record.setSkydriverName(skydirverName);
                record.setUsername(username);
                record.setShareTime(DateFormater.getFormatDate(shareTime,"yyyy-MM-dd HH:mm:ss"));
                record.setDescrib(describ);
                record.setTypeId(Integer.parseInt(typeId));
                record.setId(new BigInteger(id));
                record.setUrl(url);
                list.add(record);
                 
                /*System.out.println("name:"+name);
                System.out.println("skydirverName:"+skydirverName);
                System.out.println("username:"+username);
                System.out.println("shareTime:"+shareTime);
                System.out.println("describ:"+describ);
                System.out.println("typeId:"+typeId);
                System.out.println("id:"+id);
                System.out.println("url:"+url);*/
            }
            map.put("source",list);
            return map;
        }
         
        /**
         * 根据前缀查询
         * @Author haoning
         */
        public void prefixSearch(String filedStr,String queryStr) throws Exception{
            File indexDir = new File(DISC_URL);  
            //索引目录  
            Directory dir=FSDirectory.open(indexDir);  
            //根据索引目录创建读索引对象  
            IndexReader reader = IndexReader.open(dir);  
            //搜索对象创建  
            IndexSearcher searcher = new IndexSearcher(reader);
             
            Term term = new Term(filedStr, queryStr);
            Query query = new PrefixQuery(term);
             
            ScoreDoc[] docs = searcher.search(query, 3).scoreDocs;
            printScoreDoc(docs, searcher);
        }
         
        /**
         * 通配符查询
         * @Author haoning
         */
        public void wildcardSearch(String filedStr,String queryStr) throws Exception{
            File indexDir = new File(DISC_URL);  
            //索引目录  
            Directory dir=FSDirectory.open(indexDir);  
            //根据索引目录创建读索引对象  
            IndexReader reader = IndexReader.open(dir);  
            //搜索对象创建  
            IndexSearcher searcher = new IndexSearcher(reader);
             
            Term term = new Term(filedStr, queryStr);
            Query query = new WildcardQuery(term);
            ScoreDoc[] docs = searcher.search(query, 3).scoreDocs;
            printScoreDoc(docs, searcher);
        }
         
        /**
         * 分词查询
         * @Author haoning
         */
        public void analyzerSearch(String filedStr,String queryStr) throws Exception{
            File indexDir = new File(DISC_URL);  
            //索引目录  
            Directory dir=FSDirectory.open(indexDir);  
            //根据索引目录创建读索引对象  
            IndexReader reader = IndexReader.open(dir);  
            //搜索对象创建  
            IndexSearcher searcher = new IndexSearcher(reader);
             
            QueryParser queryParser = new QueryParser(version, filedStr, analyzer);
            Query query = queryParser.parse(queryStr);
             
            ScoreDoc[] docs = searcher.search(query, 3).scoreDocs;
            printScoreDoc(docs, searcher);
        }
         
        /**
         * 多属性分词查询
         * @Author haoning
         */
        public void multiAnalyzerSearch(String[] filedStr,String queryStr) throws Exception{
            File indexDir = new File(DISC_URL);  
            //索引目录  
            Directory dir=FSDirectory.open(indexDir);  
            //根据索引目录创建读索引对象  
            IndexReader reader = IndexReader.open(dir);  
            //搜索对象创建  
            IndexSearcher searcher = new IndexSearcher(reader);
            QueryParser queryParser = new MultiFieldQueryParser(version, filedStr, analyzer);
            Query query = queryParser.parse(queryStr);
             
            ScoreDoc[] docs = searcher.search(query, 3).scoreDocs;
            printScoreDoc(docs, searcher);
        }
         
        public void printScoreDoc(ScoreDoc[] docs,IndexSearcher searcher)throws Exception{
            for (int i = 0; i < docs.length; i++) {
                List<Fieldable> list = searcher.doc(docs[i].doc).getFields();
                for (Fieldable fieldable : list) {
                    String fieldName = fieldable.name();
                    String fieldValue = fieldable.stringValue();
                    System.out.println(fieldName+" : "+fieldValue);
                }
            }
        }
    }

    注意由于去转盘网(http://www.quzhuanpan.com)是部署到linux上的,所以DISC_URL可以更具系统变换,我是通过url来判定索引文件是否唯一的,你可以更具id来判断,具体情况具体对待吧。

    下面是索引部分:

    package com.tray.indexData;
     
    import java.sql.SQLException;
    import org.apache.lucene.document.Document;
    import org.apache.lucene.document.Field;
    import com.mysql.jdbc.Connection;
    import com.mysql.jdbc.ResultSet;
    import com.mysql.jdbc.Statement;
     
    public class IndexFile {
         
         private static Connection conn = null;     
         private static Statement stmt = null;  
         private final int NUM=500000;
         private LuceneSearch ls;
         private long count=0;
          
         public ResultSet deal6SourceTable(String tableName) throws SQLException{
               String sql = "SELECT distinct `NAME`,SKYDRIVER_NAME,USERNAME,SHARE_TIME,DESCRIB,TYPE_ID,ID,URL FROM "+tableName+" where STATUS=1 and TYPE_ID !='-1' and (TYPE_NAME is null or TYPE_NAME!=1) limit "+NUM;
               //System.out.println(sql);
               ResultSet rs = (ResultSet) stmt.executeQuery(sql);
               return rs;
         }
          
         public void update6SourceTable(String tableName) throws SQLException{
               Statement st = (Statement) conn.createStatement();
               String sql = "update "+tableName+" set TYPE_NAME=1 where STATUS=1 and TYPE_ID !='-1' and (TYPE_NAME is null or TYPE_NAME!=1) limit "+NUM;
               //System.out.println("update"+sql);
                try {
                    st.executeUpdate(sql);
                } catch (SQLException e) {
                    e.printStackTrace();
                }
         }
          
         public void indexInit(){//数据库+lcene初始化
            conn = (Connection) JdbcUtil.getConnection();     
            if(conn == null) {     
                try {
                    throw new Exception("数据库连接失败!");
                } catch (Exception e) {
                    e.printStackTrace();
                }     
            }
            ls=new LuceneSearch();
            try {
                ls.init();
            } catch (Exception e2) {
                e2.printStackTrace();
            }
         }
          
         public void indexEnd(){//数据库+lcene关闭
              
             ls.closeWriter();
             try {
                    conn.close();//关闭数据库
                 } catch (SQLException e) {
                    e.printStackTrace();
              }
         }
          
         public void Index6Data() throws SQLException{   
                try {
                    stmt = (Statement) conn.createStatement();
                } catch (SQLException e1) {
                    e1.printStackTrace();
                }
                 
                ResultSet r1=null;
                ResultSet r2=null;
                ResultSet r3=null;
                ResultSet r4=null;
                ResultSet r5=null;
                ResultSet r6=null;
                 
                boolean stop=false;
                do{
                     r1=deal6SourceTable("film_and_tv_info");
                     stop=this.createIndex(r1,ls,"1");   //给数据库创建索引,此处执行一次,不要每次运行都创建索引,以后数据有更新可以后台调用更新索引 
                     if(!stop){
                         ls.commit();//加个判断条件
                     }
                     //System.out.println("stop"+stop);
                     
                }while(!stop);
                
                stop=false;
                do{
                     r2=deal6SourceTable("music_and_mv_info");
                     stop=this.createIndex(r2,ls,"2");   //给数据库创建索引,此处执行一次,不要每次运行都创建索引,以后数据有更新可以后台调用更新索引  
                     if(!stop){
                         ls.commit();//加个判断条件
                     }
                     
                }while(!stop);
                 
                stop=false;
                do{
                     r3=deal6SourceTable("e_book_info");
                     stop=this.createIndex(r3,ls,"3");   //给数据库创建索引,此处执行一次,不要每次运行都创建索引,以后数据有更新可以后台调用更新索引  
                     if(!stop){
                         ls.commit();//加个判断条件
                     }
                     
                }while(!stop);
                 
                stop=false;
                do{
                     r4=deal6SourceTable("bt_file_info");
                     stop=this.createIndex(r4,ls,"4");   //给数据库创建索引,此处执行一次,不要每次运行都创建索引,以后数据有更新可以后台调用更新索引  
                     if(!stop){
                         ls.commit();//加个判断条件
                     }
                     
                }while(!stop);
                 
                stop=false;
                do{
                     r5=deal6SourceTable("characteristic_software_info");
                     stop=this.createIndex(r5,ls,"5");   //给数据库创建索引,此处执行一次,不要每次运行都创建索引,以后数据有更新可以后台调用更新索引  
                     if(!stop){
                         ls.commit();//加个判断条件
                     }
                     
                }while(!stop);
                 
                stop=false;
                do{
                     r6=deal6SourceTable("source_code_info");
                     stop=this.createIndex(r6,ls,"6");   //给数据库创建索引,此处执行一次,不要每次运行都创建索引,以后数据有更新可以后台调用更新索引  
                     if(!stop){
                         ls.commit();//加个判断条件
                     }
                     
                }while(!stop);
                stop=false;
                
         }
          
         public ResultSet deal2Share(String tableName) throws SQLException{
            String sql = "SELECT  distinct NAME,SKYDRIVER_NAME,USERNAME,SHARE_TIME,DESCRIB,TYPE_ID,ID,SHORTURL from "+tableName+" where STATUS=1  and FS_ID ='1' limit "+NUM; //利用FS_ID这个字段,没什么用处 
            ResultSet rs = (ResultSet) stmt.executeQuery(sql);
            return rs;
        }
         
        public ResultSet deal3Share(String tableName) throws SQLException{
            String sql = "SELECT  distinct title,channel,uid,ctime,description,port,id,shorturl from "+tableName+" where name ='1' limit "+NUM;  
            ResultSet rs = (ResultSet) stmt.executeQuery(sql);
            return rs;
        }
         
        public void Index3Data() throws SQLException{
                try {
                    stmt = (Statement) conn.createStatement();
                } catch (SQLException e1) {
                    e1.printStackTrace();
                }
                 
                ResultSet r1=null;
                ResultSet r2=null;
                ResultSet r3=null;
                 
                boolean stop=false;
                do{
                     r1=deal2Share("share1");
                     stop=this.createIndex(r1,ls,"7");   //给数据库创建索引,此处执行一次,不要每次运行都创建索引,以后数据有更新可以后台调用更新索引  
                     if(!stop){
                         ls.commit();//加个判断条件
                     }
                     //System.out.println("stop"+stop);
                     
                }while(!stop);
                
                stop=false;
                do{
                     r2=deal2Share("share2");
                     stop=this.createIndex(r2,ls,"8");   //给数据库创建索引,此处执行一次,不要每次运行都创建索引,以后数据有更新可以后台调用更新索引  
                     if(!stop){
                         ls.commit();//加个判断条件
                     }
                     
                }while(!stop);
                 
                stop=false;
                do{
                     r3=deal3Share("share3");
                     stop=this.createIndex(r3,ls,"9");   //给数据库创建索引,此处执行一次,不要每次运行都创建索引,以后数据有更新可以后台调用更新索引  
                     if(!stop){
                         ls.commit();//加个判断条件
                     }
                     
                }while(!stop);
                stop=false;
            }
         
            public void update2ShareTable(String tableName) throws SQLException{
                Statement st = (Statement) conn.createStatement();
               String sql = "update "+tableName+" set FS_ID=0 where STATUS=1  and FS_ID ='1' limit "+NUM; //利用FS_ID这个字段,没什么用处 
               //System.out.println("update"+sql);
                try {
                    st.executeUpdate(sql);
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
             
            public void update3ShareTable(String tableName) throws SQLException{
                Statement st = (Statement) conn.createStatement();
               String sql = "update "+tableName+" set name=0 where name ='1' limit "+NUM;  
               //System.out.println("update"+sql);
                try {
                    st.executeUpdate(sql);
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
                
            public boolean createIndex(ResultSet rs,LuceneSearch ls,String mark) {
                try {
                    String tableName=null;
                    if(mark.equals("1")){
                        tableName="film_and_tv_info";
                    }
                    if(mark.equals("2")){
                        tableName="music_and_mv_info";
                    }
                    if(mark.equals("3")){
                        tableName="e_book_info";
                    }
                    if(mark.equals("4")){
                        tableName="bt_file_info";
                    }
                    if(mark.equals("5")){
                        tableName="characteristic_software_info";
                    }
                    if(mark.equals("6")){
                        tableName="source_code_info";
                    }
                    if(mark.equals("7")){
                        tableName="share1";
                    }
                    if(mark.equals("8")){
                        tableName="share2";
                    }
                    if(mark.equals("9")){
                        tableName="share3";
                    }
     
                    boolean isNull=rs.next();
                    //System.out.println("hehe"+isNull);
                    if(isNull==false){
                        return true;//处理完毕
                    }
                    while(isNull){
                        if(Integer.parseInt(mark)>=1&&Integer.parseInt(mark)<=8){
                            Document doc = new Document();  
                            //System.out.println("name"+rs.getString("NAME"));        
                            Field name = new Field("name",rs.getString("NAME"),Field.Store.YES,Field.Index.ANALYZED);
                            String skName=rs.getString("SKYDRIVER_NAME");
                            if(skName==null){
                                skName="百度";
                            }
                            Field skydirverName = new Field("skydirverName",skName, Field.Store.YES,Field.Index.NOT_ANALYZED);
                            Field username = new Field("username",rs.getString("USERNAME"),Field.Store.YES, Field.Index.ANALYZED);    
                            Field shareTime = new Field("shareTime",rs.getString("SHARE_TIME"), Field.Store.YES,Field.Index.NOT_ANALYZED);
                            String desb=rs.getString("DESCRIB");
                            if(desb==null){
                                desb="-1";
                            }
                            Field describ = new Field("describ",desb,Field.Store.NO,Field.Index.NOT_ANALYZED);     
                            Field typeId = new Field("typeId",rs.getString("TYPE_ID"), Field.Store.YES,Field.Index.NOT_ANALYZED); 
                            Field id = new Field("id",rs.getString("ID"),Field.Store.YES,Field.Index.NOT_ANALYZED);
                            Field url =null;
                            if(Integer.parseInt(mark)>=7&&Integer.parseInt(mark)<=8){
                                url = new Field("url",rs.getString("SHORTURL"), Field.Store.YES,Field.Index.ANALYZED); 
                            }
                            else{
                                url = new Field("url",rs.getString("URL"), Field.Store.YES,Field.Index.ANALYZED);  
                            }
                            doc.add(name);
                            doc.add(skydirverName);
                            doc.add(username);
                            doc.add(shareTime);
                            doc.add(describ);
                            doc.add(typeId);
                            doc.add(id);
                            doc.add(url);
                            ls.singleUpdate(doc);//用跟新更为合适     
                            isNull=rs.next();
                        }
                        else{
                            Document doc = new Document();  
                            //System.out.println("title"+rs.getString("title"));        
                            Field name = new Field("name",rs.getString("title"),Field.Store.YES,Field.Index.ANALYZED);
                            String skName=rs.getString("channel");
                            Field skydirverName = new Field("skydirverName",skName, Field.Store.YES,Field.Index.NOT_ANALYZED);
                            Field username = new Field("username",rs.getString("uid"),Field.Store.YES, Field.Index.ANALYZED);     
                            Field shareTime = new Field("shareTime",rs.getString("ctime"), Field.Store.YES,Field.Index.NOT_ANALYZED);
                            String desb=rs.getString("description");
                            if(desb==null){
                                desb="-1";
                            }
                            Field describ = new Field("describ",desb,Field.Store.NO,Field.Index.NOT_ANALYZED);     
                            Field typeId = new Field("typeId",rs.getString("port"), Field.Store.YES,Field.Index.NOT_ANALYZED);
                            Field id = new Field("id",rs.getString("id"),Field.Store.YES,Field.Index.NOT_ANALYZED);    
                            Field url = new Field("url",rs.getString("shorturl"), Field.Store.YES,Field.Index.ANALYZED);  
                             
                            doc.add(name);
                            doc.add(skydirverName);
                            doc.add(username);
                            doc.add(shareTime);
                            doc.add(describ);
                            doc.add(typeId);
                            doc.add(id);
                            doc.add(url);
                            ls.singleUpdate(doc);//用跟新更为合适     
                            isNull=rs.next();
                        }
                        count=count+1;
                    }
                    if(Integer.parseInt(mark)>=1&&Integer.parseInt(mark)<=6){
                        update6SourceTable(tableName);//处理完成后做标志
                    }
                    else if(Integer.parseInt(mark)>=7&&Integer.parseInt(mark)<=8){
                        update2ShareTable(tableName);//处理完成后做标志
                    }
                    else{
                        update3ShareTable(tableName);//处理完成后做标志
                    }
                    System.out.println("Has index "+count+"条数据,数据来自表"+tableName);
                     
                } catch (Exception e) {
                    e.printStackTrace();
                }
                return false;
            }
    }

    数据库之类的请不要关心,看思路即可,你如果需要换成你的即可,这里就不多说了。看最后的部分:

    package com.tray.indexData;
     
    import java.sql.SQLException;
     
     
     
    public class Application {
         
        public static void main(String[] args){
            /*IndexFile indexFile=new IndexFile();
            indexFile.indexInit();
            try {
                indexFile.Index6Data();
            } catch (SQLException e1) {
                e1.printStackTrace();
            }
            indexFile.indexEnd();*/
             
            IndexFile indexFile1=new IndexFile();
            indexFile1.indexInit();
            try {
                indexFile1.Index3Data();
            } catch (SQLException e1) {
                e1.printStackTrace();
            }
            indexFile1.indexEnd();
             
            LuceneSearch lch=new LuceneSearch();
            try {
                long a = System.currentTimeMillis();
                lch.highLightSearch("name", "flv", 1,3);
                long b = System.currentTimeMillis();
                long c = b - a;
                System.out.println("[高级检索花费时间:" + c + "毫秒]");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }


    你可以在一个applicationic程序中开始索引,也可以写个定时器来定时索引,看需求。以上代码是楼主幸苦的作品,转载请不要改动,本人确保代码完全可用。



    展开全文
  • JAVA中文分词算法

    千次阅读 2012-06-15 10:37:52
    原文地址:... 下面是demo,记得要加lucene-core-2.3.2.jar和lucene-Analyzer.jar以及IKAnalyzer.jar这几个包 import java.io.Reader; import java.io.StringRea

    原文地址:http://hi.baidu.com/lewutian/blog/item/ee6d9dd7780bf8d1a144dfef.html
    下面是demo,记得要加lucene-core-2.3.2.jar和lucene-Analyzer.jar以及IKAnalyzer.jar这几个包

    import java.io.Reader;
    import java.io.StringReader;

    import org.apache.lucene.analysis.Analyzer;
    import org.apache.lucene.analysis.StopFilter;
    import org.apache.lucene.analysis.Token;
    import org.apache.lucene.analysis.TokenFilter;
    import org.apache.lucene.analysis.TokenStream;
    import org.apache.lucene.analysis.cjk.CJKAnalyzer;
    import org.apache.lucene.analysis.cn.ChineseAnalyzer;
    import org.apache.lucene.analysis.standard.StandardAnalyzer;
    import org.mira.lucene.analysis.IK_CAnalyzer;

    public class TestJeAnalyzer {
    private static String testString1 = "冗长的代码常常是复杂性会导致代码难以测试和维护.";
    public static void testStandard(String testString) throws Exception{
    Analyzer analyzer = new StandardAnalyzer();
    Reader r = new StringReader(testString);
    StopFilter sf = (StopFilter) analyzer.tokenStream("", r);
    System.err.println("=====standard analyzer====");
    System.err.println("分析方法:默认没有词只有字");
    Token t;
    while ((t = sf.next()) != null) {
    System.out.println(t.termText());
    }
    }
    public static void testCJK(String testString) throws Exception{
    Analyzer analyzer = new CJKAnalyzer();
    Reader r = new StringReader(testString);
    StopFilter sf = (StopFilter) analyzer.tokenStream("", r);
    System.err.println("=====cjk analyzer====");
    System.err.println("分析方法:交叉双字分割");
    Token t;
    while ((t = sf.next()) != null) {
    System.out.println(t.termText());
    }
    }
    public static void testChiniese(String testString) throws Exception{
    Analyzer analyzer = new ChineseAnalyzer();
    Reader r = new StringReader(testString);
    TokenFilter tf = (TokenFilter) analyzer.tokenStream("", r);
    System.err.println("=====chinese analyzer====");
    System.err.println("分析方法:基本等同StandardAnalyzer");
    Token t;
    while ((t = tf.next()) != null) {
    System.out.println(t.termText());
    }
    }

    public static void testJe(String testString) throws Exception{
    // Analyzer analyzer = new MIK_CAnalyzer();
    Analyzer analyzer = new IK_CAnalyzer();
    Reader r = new StringReader(testString);
    TokenStream ts = (TokenStream)analyzer.tokenStream("", r);
    System.err.println("=====je analyzer====");
    System.err.println("分析方法:字典分词,具体不明");
    Token t;
    while ((t = ts.next()) != null) {
    System.out.println(t.termText());
    }
    }
    public static void main(String[] args) throws Exception{
    // String testString = testString1;
    String testString = testString1;
    System.out.println(testString);

    testStandard(testString);
    testCJK(testString);
    // testPaoding(testString);

    testChiniese(testString);
    testJe(testString);
    }

    }

    展开全文
  • publicstaticListsplitWord(Stringstr){Listlist=null;try{if(str!=null&&!"".equals(str)){list=newArrayList();StringReaderreader=newStringReader(str);IKSegmenterik=newIKSegmenter(reade...

    public static List splitWord(String str) {

    List list=null;

    try {

    if(str!=null&&!"".equals(str)){

    list=new ArrayList();

    StringReader reader=new StringReader(str);

    IKSegmenter ik=new IKSegmenter(reader, true);

    Lexeme le=null;

    while((le=ik.next())!=null){

    list.add(le.getLexemeText());

    }

    }

    } catch (Exception e) {

    e.printStackTrace();

    }

    return list;

    }

    public static String splitWordStr(String str,String splitStr) {

    StringBuffer buffer=new StringBuffer("");

    String retVal="";

    try {

    if(str!=null&&!"".equals(str)){

    StringReader reader=new StringReader(str);

    IKSegmenter ik=new IKSegmenter(reader, true);

    Lexeme le=null;

    while((le=ik.next())!=null){

    buffer.append(le.getLexemeText()).append(splitStr);

    }

    retVal=buffer.toString();

    retVal=retVal.substring(0,retVal.length()-1);

    }

    } catch (Exception e) {

    e.printStackTrace();

    }

    return retVal;

    }

    展开全文
  • java 实现的中文分词算法(代码)

    热门讨论 2011-04-14 20:10:38
    java 实现的基于FMM BMM算法的,中文分词算法(代码)
  • 主要介绍了Java实现的最大匹配分词算法,简单说明了最大匹配分词算法的原理并结合具体实例形式最大匹配分词算法的实现方法与相关注意事项,需要的朋友可以参考下
  • 主要介绍了Java实现的双向匹配分词算法,结合完整实例形式详细分析了双向匹配分词算法的原理与java实现技巧,需要的朋友可以参考下
  • //Java实现逆向最大匹配中文分词算法public class SplitChineseCharacter { public static void main(String[] args) { String input = "太好了,今天是星期六啊"; // 要匹配的字符串 new Split(input)....
    写道
    //Java实现逆向最大匹配中文分词算法
    public class SplitChineseCharacter {
    public static void main(String[] args) {
    String input = "太好了,今天是星期六啊"; // 要匹配的字符串
    new Split(input).start();
    }
    }

    class Split {
    private String[] dictionary = {"今天","是","星期","星期六"}; //词典
    private String input = null;

    public Split(String input) {
    this.input = input;
    }

    public void start() {
    String temp = null;
    for(int i=0;i<this.input.length();i++) {
    temp = this.input.substring(i); // 每次从字符串的首部截取一个字,并存到temp中
    // System.out.println("*****" + temp + "*********" + this.input);
    // 如果该词在字典中, 则删除该词并在原始字符串中截取该词
    if(this.isInDictionary(temp)) {
    System.out.println(temp);
    this.input = this.input.replace(temp, "");
    i = -1; // i=-1是因为要重新查找, 而要先执行循环中的i++
    }
    }

    // 当前循环完毕,词的末尾截去一个字,继续循环, 直到词变为空
    if(null != this.input && !"".equals(this.input)) {
    this.input = this.input.substring(0,this.input.length()-1);
    this.start();
    }
    }

    //判断当前词是否在字典中
    public boolean isInDictionary(String temp) {
    for(int i=0;i<this.dictionary.length;i++) {
    if(temp.equals(this.dictionary[i])) {
    return true;
    }
    }
    return false;
    }
    }

    /**
    过程分析:
    第一词循环:
    太好了,今天是星期六啊
    好了,今天是星期六啊
    了,今天是星期六啊
    ,今天是星期六啊
    今天是星期六啊
    天是星期六啊
    是星期六啊
    星期六啊
    期六啊
    六啊

    第一次循环没有找到,则从“太好了,今天是星期六啊”中把最后一个截取,开始第二次循环

    第二次循环:
    太好了,今天是星期六
    好了,今天是星期六
    了,今天是星期六
    ,今天是星期六
    今天是星期六
    天是星期六
    是星期六
    星期六 --------->输出:星期六,并在原字符串中截去“星期六”-->变为“太好了,今天是”
    太好了,今天是
    好了,今天是
    了,今天是
    ,今天是
    今天是
    天是
    是 ----------> 输出:是, 并在原字符串中截去“是”-->变为“太好了,今天”
    直到原字符串变为空。
    */

     

    展开全文
  • word分词是一个Java实现的中文分词组件,提供了多种基于词典的分词算法,并利用ngram模型来消除歧义。 能准确识别英文、数字,以及日期、时间等数量词,能识别人名、地名、组织机构名等未登录词。 同时提供了Lucene...
  • simhash算法对字符串计算权重时,对中文要做特殊操作,及先分词,请自行下载sanford中文分词jar包及中文分词库
  • 算法是基于分词词典实现,从字符串左侧进行分割匹配,如果词典存在则返回分割出来的词语并将该词从之前的字符串中切除,循环进行切割直到字符串大小为0。
  • 中科院中文分词算法的接口介绍,包括C++,java,C#等语言
  • Java中文分词

    2018-12-12 11:34:59
    JAVA中maven的使用,中文分词,以及了解协同过滤算法如何做词频分析
  • Java中文分词组件 - word分词

    万次阅读 2019-02-10 16:17:50
    word分词是一个Java实现的分布式的中文分词组件,提供了多种基于词典的分词算法,并利用ngram模型来消除歧义。能准确识别英文、数字,以及日期、时间等数量词,能识别人名、地名、组织机构名等未登录词。能通过...
  • java中文分词的简单实现

    万次阅读 多人点赞 2018-12-03 11:33:30
    java中文分词的简单实现中文分词算法算法思路算法实现代码及注释评价结语 中文分词 通俗来讲,中文分词是指将一句中文句子中的所有中文词汇相互分隔开来。它是文本挖掘的基础,有着十分广阔的应用前景。下面,我们来...
  • 2、每来一次分词构造,就顺着trie树进行分词,这将产生很多种结果,于是就生成了一个DGA,分词的有向无环图,终点是句子的左边或者右边(实际上应该分别以左边和右边为终点来做处理)。 3、利用动态规划,从句子的...
  • 采用正向和反向最大匹配算法,可拆分文件,字符串等,也可扩展自己想要的功能,很方便
  • java中文分词,协同过滤算法词频分析,javaGUI界面初步,生成java数据词云
  • 基于逆向匹配的中文分词算法,实验结果 步骤 分析 性能比较
  • java中文分词

    2015-07-01 11:26:24
    用NetBeans打开,编译通过可运行。包含统计分词、逆向、正向三个算法
  • 中文分词算法研究

    千次阅读 2016-06-30 23:00:47
    中文分词算法总结 介绍分词语料—— 中文分词入门之资源  互联网时代的社会语言学:基于SNS的文本数据挖掘 字标注问题 先看一个句子:我是一名程序员。将所有字分为4类,S表示单字,B表示词首,M表示词中,E...
  • 中文分词算法

    2009-06-22 09:57:00
    这里主要介绍了我自己的中文分词算法,我觉得它比现在开源代码比较多的中文匹配法要好多了。这里的内容没有任何背景知识啥的,毕竟论文里的背景知道我也是从网上粘贴的,呵呵!因此这篇文章的内容可能适合做搜索引擎...
  • 中文分词算法

    2008-04-12 00:41:00
    这里主要介绍了我自己的中文分词算法,我觉得它比现在开源代码比较多的中文匹配法要好多了。这里的内容没有任何背景知识啥的,毕竟论文里的背景知道我也是从网上粘贴的,呵呵!因此这篇文章的内容可能适合做搜索引擎...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 16,077
精华内容 6,430
关键字:

java中文分词算法

java 订阅