Lucene——数字日期

最新推荐文章于 2021-02-21 01:03:20 发布
最新推荐文章于 2021-02-21 01:03:20 发布
阅读量690 收藏
点赞数
分类专栏： Lucene
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jingtian_xiaozhi/article/details/8453956
版权

为时间增加索引，增加的是NumericField域

//存储数字   
doc.add(new NumericField("attach",Field.Store.YES,true).setIntValue(attachs[i]));  
//存储日期   
doc.add(new NumericField("date",Field.Store.YES,true).setLongValue(dates[i].getTime())); 

时间的转换

这个不会有点丢人

SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-DD"); 
date=sdf.parse("2012-01-01"); 

 

1325408580000L转化成

String str = new SimpleDateFormat("yyyy-MM-dd").format(new Date(1325408580000L));

package org.itat.index;

//创建索引
import java.io.File;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.document.NumericField;
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.Term;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.TermQuery;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
import org.apache.lucene.store.LockObtainFailedException;
import org.apache.lucene.util.Version;

public class IndexUtil {
		private String[] ids={"1","2","3","4","5","6"};
		private String[] emails={"dd@@dd.org","aa@jingtian.org","bb@jingtian.org","cc@ytu.edu","ee@ee.org","ff@ff.org"};
		private String[] contents={"I like soccer","I like football","I like soccer and I like game","I like book","I like soccer","I like soccer"};
		private int[] attachs={3,6,8,9,5,4,5};
		private String[] names={"zhangsan","lisi","wangwu","zhaoliu","wuba","chenjiu"};
		private Directory directory=null;
		private Map<String,Float> scores=new HashMap<String, Float>();
		private Date[] dates=null;
		
		public IndexUtil()
		{
			scores.put("jingtian.org", 8f);
			scores.put("ytu.edu", 6f);
			
			try {
				directory=FSDirectory.open(new File("e:/lucene/index02"));
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		public void query()
		{
			try {
				IndexReader reader=IndexReader.open(directory);
				System.out.println("numdocs:"+reader.numDocs());
				System.out.println("maxDocs:"+reader.maxDoc());
				System.out.println("detelemaxDocs:"+reader.numDeletedDocs());
				reader.close();
				
			} catch (CorruptIndexException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			
		}
		
		public void index()
		{
				setDate();
			   IndexWriter writer=null;
			   Document doc=null;
			   try {
//				   writer.deleteAll(); 
				writer =new IndexWriter(directory,new IndexWriterConfig(Version.LUCENE_35, 
						   new StandardAnalyzer(Version.LUCENE_35)));
				for(int i=0;i<ids.length;i++)
				{
					doc=new Document();
			    	doc.add(new Field("id",ids[i],Field.Store.YES,Field.Index.NOT_ANALYZED_NO_NORMS));
			    	doc.add(new Field("email",emails[i],Field.Store.YES,Field.Index.ANALYZED));
			    	doc.add(new Field("content",contents[i],Field.Store.NO,Field.Index.ANALYZED));
			    	doc.add(new Field("name",names[i],Field.Store.YES,Field.Index.NOT_ANALYZED_NO_NORMS));

			        //存储数字   
                    doc.add(new NumericField("attach",Field.Store.YES,true).setIntValue(attachs[i]));  
                    //存储日期   
                    doc.add(new NumericField("date",Field.Store.YES,true).setLongValue(dates[i].getTime()));  
                    
			    	String et=emails[i].substring(emails[i].lastIndexOf("@")+1);  
                    System.out.println(et);  
                    if(scores.containsKey(et))  
                    {  
                        doc.setBoost(scores.get(et));  
                    }  
                    else {  
                        doc.setBoost(5f);  
                    }  

                    writer.addDocument(doc);
				}
			} catch (CorruptIndexException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (LockObtainFailedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			   finally{
				   if(writer!=null)
				   {
					  try {
						writer.close();
					} catch (CorruptIndexException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					} catch (IOException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}   
				   }
			   }
		}
		//删除
		public void delete()  
        {  
            IndexWriter writer=null;  
            try {  
                writer=new IndexWriter(directory, new IndexWriterConfig(Version.LUCENE_35,  
                        new StandardAnalyzer(Version.LUCENE_35)));  
                //参数是一个选项.可以是一个query，也可以是一个term  term就是一个精确查找的值   
                //此时删除的文档并未完全删除，而是存储在回收站中，可以恢复的   
                writer.deleteDocuments(new Term("id","1"));  
            } catch (CorruptIndexException e) {  
                e.printStackTrace();  
            } catch (LockObtainFailedException e) {  
                e.printStackTrace();  
            } catch (IOException e) {  
                e.printStackTrace();  
            }  
            finally{  
                if (writer!=null) {  
                    try {  
                        writer.close();  
                    } catch (CorruptIndexException e) {  
                        // TODO Auto-generated catch block   
                        e.printStackTrace();  
                    } catch (IOException e) {  
                        // TODO Auto-generated catch block   
                        e.printStackTrace();  
                    }  
                }  
            }  
        } 
		//恢复
		public void undelete()  
        {  
            try {  
                //恢复时必须把reader的只读设为false   
                IndexReader reader=IndexReader.open(directory,false);  
                reader.undeleteAll();  
                
                reader.close();  
            } catch (CorruptIndexException e) {  
                // TODO Auto-generated catch block   
                e.printStackTrace();  
            } catch (IOException e) {  
                // TODO Auto-generated catch block   
                e.printStackTrace();  
            }  
              
        }
		
		 //清空回收站，强制优化   
        public void forceDelete()  
        {  
            IndexWriter writer=null;  
            try {  
                writer=new IndexWriter(directory, new IndexWriterConfig(Version.LUCENE_35,  
                        new StandardAnalyzer(Version.LUCENE_35)));  
                writer.forceMergeDeletes(); 
            } catch (CorruptIndexException e) {  
                e.printStackTrace();  
            } catch (LockObtainFailedException e) {  
                e.printStackTrace();  
            } catch (IOException e) {  
                e.printStackTrace();  
            }  
            finally{  
                if (writer!=null) {  
                    try {  
                        writer.close();  
                    } catch (CorruptIndexException e) {  
                        // TODO Auto-generated catch block   
                        e.printStackTrace();  
                    } catch (IOException e) {  
                        // TODO Auto-generated catch block   
                        e.printStackTrace();  
                    }  
                }  
            }  
        }  

        public void merge()  
        {  
            IndexWriter writer=null;  
            try {  
                writer=new IndexWriter(directory, new IndexWriterConfig(Version.LUCENE_35,  
                        new StandardAnalyzer(Version.LUCENE_35)));  
                //将索引合并为两段，建议不实用，开销太大
                writer.forceMerge(2);  
            } catch (CorruptIndexException e) {  
                e.printStackTrace();  
            } catch (LockObtainFailedException e) {  
                e.printStackTrace();  
            } catch (IOException e) {  
                e.printStackTrace();  
            }  
            finally{  
                if (writer!=null) {  
                    try {  
                        writer.close();  
                    } catch (CorruptIndexException e) {  
                        // TODO Auto-generated catch block   
                        e.printStackTrace();  
                    } catch (IOException e) {  
                        // TODO Auto-generated catch block   
                        e.printStackTrace();  
                    }  
                }  
            }  
        }  


        //更新索引   
        public void update()  
        {  
//            lucene本身不支持更新 
//            通过删除索引然后再建立索引来更新 
              
              IndexWriter writer=null;  
               Document doc=null;  
               try {  
                writer =new IndexWriter(directory,new IndexWriterConfig(Version.LUCENE_35,   
                           new StandardAnalyzer(Version.LUCENE_35)));  
                 
                  
                    doc=new Document();  
                    doc.add(new Field("id","111",Field.Store.YES,Field.Index.NOT_ANALYZED_NO_NORMS));  
                    doc.add(new Field("emails",emails[0],Field.Store.YES,Field.Index.ANALYZED));  
                    doc.add(new Field("contents",contents[0],Field.Store.NO,Field.Index.ANALYZED));  
                    doc.add(new Field("name",names[0],Field.Store.YES,Field.Index.NOT_ANALYZED_NO_NORMS));  
                    writer.updateDocument(new Term("id","1"), doc);   
                  
            } catch (CorruptIndexException e) {  
                // TODO Auto-generated catch block   
                e.printStackTrace();  
            } catch (LockObtainFailedException e) {  
                // TODO Auto-generated catch block   
                e.printStackTrace();  
            } catch (IOException e) {  
                // TODO Auto-generated catch block   
                e.printStackTrace();  
            }  
               finally{  
                   if(writer!=null)  
                   {  
                      try {  
                        writer.close();  
                    } catch (CorruptIndexException e) {  
                        // TODO Auto-generated catch block   
                        e.printStackTrace();  
                    } catch (IOException e) {  
                        // TODO Auto-generated catch block   
                        e.printStackTrace();  
                    }     
                   }  
               }      
        }  
        
        public void setDate()  
        {  
            SimpleDateFormat sdf=new SimpleDateFormat("yyyy-mm-kk"); //时间转换，这个不会有点丢人
            try {  
                dates=new Date[ids.length];  
                dates[0]=sdf.parse("2010-08-17");  
                dates[1]=sdf.parse("2011-02-17");  
                dates[2]=sdf.parse("2012-03-17");  
                dates[3]=sdf.parse("2011-04-17");  
                dates[4]=sdf.parse("2012-05-17");  
                dates[5]=sdf.parse("2011-07-17");  
            } catch (Exception e) {  
                e.printStackTrace();  
                // TODO: handle exception   
            }  
        }   

        public void search()  
        {  
            try {  
               IndexReader reader=IndexReader.open(directory);  
               IndexSearcher searcher=new IndexSearcher(reader);  
               TermQuery query=new TermQuery(new Term("content","like"));  
               TopDocs tds=searcher.search(query, 10);  
                 
               for(ScoreDoc sd:tds.scoreDocs)  
               {  
                   Document doc=searcher.doc(sd.doc);  
                   System.out.println("("+sd.doc+"-"+doc.getBoost()+"-"+sd.score+")--------------"+doc.get("name")+"["+doc.get("email")+"]--------------------"  
                           +doc.get("id")+","+doc.get("attach")+","+doc.get("date")); 
                   
               }  
           } catch (CorruptIndexException e) {  
               // TODO Auto-generated catch block   
               e.printStackTrace();  
           } catch (IOException e) {  
               // TODO Auto-generated catch blocket   
               e.printStackTrace();  
           }  
        }  

  

}

景天晓志
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Lucene时间区间搜索
08-05
c#下实现Lucene时间区间查询匹配。主要还是对Lucene查循对像Query的实现
lucene索引日期和数字
weixin_33749131的博客
04-18 87
1.用途。 索引数字的场景主要有两种：一是把它们当作字符串一样处理，比如“要是搁以前，术士能暴击10000多，有木有！”中的"10000"，它和其它的词没什么区别，你可以把它仅仅想成一个字符串；另一种场景则是某个域只索引数字，且可以搜索数字的范围等，比如设计了某个Field存储邮件的大小，现在要搜索大小在3M－10M的邮件。 对于第一种情况，你要做的仅仅是选一个不会对数字进行分...
Lucene笔记06-对日期和数字进行索引
王劭阳的博客
10-18 450
一、对数字进行索引 public void index() { IndexWriter indexWriter = null; int[] attachFiles = {1, 2, 3, 4, 5, 6}; try { indexWriter = new IndexWriter(directory, new IndexWriterConfig(Versi...
Lucene小练九——各种搜索（精确，范围，数字）
Smallearth的专栏
09-13 223
package Java.se.lucene; // 主类 import java.io.IOException; import java.text.SimpleDateFormat; import java.util.Date; import java.util.HashMap; import java.util.Map; import org.apache.lucene.analysis.s...
lucene日期索引与搜索
每天=生命的最后一天
03-14 3038
工具类里：TimestampConverter类里的方法：/**  * lucene建日期索引转换  * @param timestamp  * @return  */ public String timestampToShortStr2(Timestamp timestamp){        Date date = new Date(timestamp.getTime());  SimpleD
Lucene初试——关于大文本建立索引和中文乱码以及QueryParser检索的一些体会 - sheen口开河 - CSDN博客
08-03
一、大文本建索引问题 二、中文乱码问题 三、关于检索的一些认识 四、其他格式文本的检索 五、下面附上代码：
lucene:lucene技术细节
05-01
lucene lucene词典的构造原理 lucene模糊查询以及正则查询的原理 lucene删除索引的实现 lucene段merge的过程 lucene怎么实现Field lucene的分词过程
集成Lucene和HBase
02-26
在所有先进的应用程序中，不管是购物站点还是社交网络乃至风景...每个字段值都由一个或多个可搜索的元素——即词汇（term）——组成。Lucene搜索基于反向索引，其中包含了关于可搜索文档的信息。在使用正常索引时，你可
lucene7.7.2稳定版本
04-10
lucene7.7.2稳定版本
Lucene+PanGu
08-18
Lucene+PanGu 分词程序可供项目运行
lucene-索引日期与索引数字和排序
深未来技术
12-25 1022
一、索引日期1、Field.Keyword(String,Date)方法和DateField类进行索引索引今天的日期可以这么做:Document doc=new Document（）；doc.add(Field.Keyword("indexDate",new Date()))；lucene内部使用了DateField类将日期转成字符串。2、可以先转换为YYYYMMDD格式的
lucene对日期(date)和整形(int)处理
abxlep7702的博客
02-02 141
项目结构： 运行效果： ========================================== 代码部分： ========================================== /lucene_0400_dateAndInt/src/com/b510/lucene/util/LuceneUtil.java 1 /** 2 ...
lucene为数字和日期添加索引
KarlDoenitz的专栏
09-12 992
热烈感谢我们亲爱的smallearth，我前期的程序在系统更新时被删掉了，现在发现smallearth写了，太好了，我可以转载了，就不用辛辛苦苦的重写了！ //主程序 package org.se.lucene; import java.io.File; import java.io.IOException; //import java.sql.Date; import java.text.
Lucene小练四——为数字和日期添加索引
Smallearth的专栏
09-08 117
//主程序 package org.se.lucene; import java.io.File; import java.io.IOException; //import java.sql.Date; import java.text.SimpleDateFormat; import java.util.Date; import java.util.HashMap; import java....
Lucene的数字范围搜索 (Numeric Range Query)原理
jimmee的专栏
04-05 692
0. 全文索引的核心就是倒排索引.     1. 若数字不支持范围查询, 直接变成字符串查找即可     2. 如果要支持范围查询, 直接的字符串存储支持么?      目前lucene要求term按照字典序(lexicographic sortable)排列,然后它的范围查询根据tii找到范围的起始Term，然后把这中间的所有的Term展开成一个BooleanQuery。 ...
编程点滴.LUCENE.对数字、日期、时间等进行索引
weixin_30699235的博客
08-01 198
争取每日记录一些 索引数字 1.如果数字在文本中,比如"Be sure to include Form 1099 in your tax return".要搜索1099就要在创建索引使用不丢弃数字的分析器. 比如:WhitespaceAnalyzer或StandardAnalyzer 2.如果本身就是数字字段就可以使用NumericField进行索引,如果需要对这个字段进行排序,需要这个字段只能...
Lucene 数字范围查询
水墨江南
12-04 245
public List&lt;Document&gt; rangeSearch(){ List&lt;Document&gt; docList = new ArrayList&lt;Document&gt;(); Double start = 20.0; Double end = 40.0; NumericRange...
java lucene 搜索_java – Lucene中的索引和搜索日期
weixin_32571629的博客
02-21 158
我尝试使用DateTools.dateToString()方法索引日期.它的工作正常索引和搜索.但是我已经编入索引的数据有一些引用,就是将Date作为一个新的Date().getTime()进行索引.所以我的问题是如何对这个数据执行RangeSearch Query任何解决这个？提前致谢.您需要在您的日期字段上使用TermRangeQuery.该字段始终需要使用DateTools.dateToSt...
lucene7与lucene8
最新发布
07-12
lucene7与lucene8是Apache Lucene搜索引擎的两个主要版本。Lucene是一个开源的全文搜索引擎库，用于构建强大的搜索功能。 Lucene7是在2017年发布的一个重要版本，它引入了许多新功能和改进。其中一些改进包括更快的搜索速度、更高效的内存使用、更好的压缩算法以及更强大的查询语法支持。此外，Lucene7还引入了一些新的模块和API，使其更易于使用和扩展。 Lucene8是在2018年发布的下一个主要版本，它进一步改进了Lucene7的功能和性能。其中一些更新包括更快的索引和搜索速度、更好的压缩率、更强大的查询语法和更灵活的排序功能。此外，Lucene8还引入了一些新的特性，如动态文档、索引分类和重用索引数据等。 总的来说，Lucene8在性能、功能和扩展性方面都有所提升，使开发者能够构建更高效和强大的搜索应用程序。不过，具体使用哪个版本还需要根据项目需求和实际情况来决定。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值