List集合去重使用lambda表明式,C语言实例

name age sex
Lucy 22 woman
Lily 23 woman
Tom 24 man
Lucy 22 woman
Lily 23 woman
LiLei 25 man

 
设计的应用程序供给同时帮助SQLserver和Oracle,于是,根据SQLserver标准编写制定的N多sql语句出现了好多在Oracle中不能够科学执行的地点,在此将里面包车型地铁几点距离简单做下记录:    

二头talk C栗子吧(第10十八遍:C语言实例–使用共享内存进行进度间通讯二)


诸君看官们,我们好,上2遍中大家说的是运用共享内部存款和储蓄器进行进度间通讯的事例,那一次大家接着上贰遍内容继续说使用共享内部存款和储蓄器举行进度间通讯。闲话休提,言归正转。让大家一起talk
C栗子吧!

小编们在上2遍中介绍了共享内部存款和储蓄器的概念和血脉相通函数的用法,那二遍中我们通超过实际际的事例来证明怎么样使用共享内部存储器实行进度间的通讯。下边是运用共享内部存款和储蓄器的具体步骤:

1.定义三个结构体类型,用来作为共享内部存款和储蓄器的类型;
2.采取shmget函数到手共享内部存款和储蓄器,代码中的键使用了111那一个自由数字;
3.使用shmat函数把共享连接到进度的地方空间中;
4.从共享内部存款和储蓄器中读取数据,恐怕向共享内部存款和储蓄器中写入数据;
5.使用shmdt函数把共享内部存储器从进程的地址空间中分离出来;
6.使用shmctl函数删除共享内部存款和储蓄器,供给选用的通令:IPC_RMID;

看官们,正文中就不写代码了,详细的代码放到了本人的财富中,大家能够点击那里下载应用。

上面是先后的运维结果,请大家参考:

./s -r                                  //运行程序并且使用-r参数,表示启动读取数据的进程
there is not any data in share memory   //这时共享内存中还没有数据
./s -w                                  //运行程序并且使用-w参数,表示启动写入数据的进程
write data into share memory.count:3,data:hello share memory //提示写入的数据
./s -r                                //再次运行程序并且使用-r参数,表示启动读取数据的进程                
the data of share memory.count:3,data:hello share memory  //显示从共享内存中读取的数据

在先后中我们应用参数来分别不相同的进度,同时使用贰个符号位来判定共享内部存款和储蓄器中是不是有数量。此外,使用共享内部存储器进行进程间通讯时须要动用同步机制,比如大家在刚起头运营程序时,因为还尚未举办写进度,共享内存中没有数量,那时候,读进度不能够从共享内部存款和储蓄器中读取到多少。

诸君看官,关于使用共享内部存款和储蓄器进行进度间通讯的事例大家就说到此处。欲知后边还有什么样例子,且听下回分解


 

C栗子吧(第玖十八次:C语言实例–使用共享内部存款和储蓄器举办进程间通讯二)
各位看官们,大家好,上3次中我们说的是采纳共享内部存款和储蓄器进行…

一 、是或不是实行实时搜索

  • 实时搜索:只要数据库一变更,立刻要创新索引,要采取writer.commit来操作,可是那种情况太费用财富。
  • 近实时寻找:当用户修改了音讯之后,先把索引保存到内部存款和储蓄器中,然后在1个联合的时间内对内部存款和储蓄器中的目录实行付出操作。基于那些缘故大家一般举行的是近实时搜索。
List<Person> list_persons = new List<Person>(new Person("Lucy",22,"woman"),new Person("Lily",23,"woman"),new Person("Tom",24,"man"),new Person("Lucy",22,"woman"),new Person("Lily",23,"woman"),new Person("LiLei",25,"man"));

(1)在sqlserver中允许使用分号“;”将多条sql语句实行分隔,然后一并展开实施,但是在Oracle中不允许那样的多条语句同时施行,务必拆分为多条单独语句进行实践才行。    

二 、入门程序(工程lucene-nearRealTime

IndexUtil.java

package cn.itcast.util;
import java.io.File;
import java.io.IOException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.Executors;
import org.apache.lucene.analysis.TokenStream;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.document.Fieldable;
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.FieldInfo.IndexOptions;
import org.apache.lucene.index.StaleReaderException;
import org.apache.lucene.index.Term;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.SearcherManager;
import org.apache.lucene.search.SearcherWarmer;
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.store.RAMDirectory;
import org.apache.lucene.util.Version;

public class IndexUtil {
    private String[] ids = {"1", "2", "3", "4", "5", "6"};
    //下面是邮件
    private String[] emails = {"aa@qq.com", "bb@sina.edu", "cc@yahu.org", "ss@sina.com", "dd@gmail.com", "ee@163.com"};
    //下面是邮件内容
    private String[] content = {
            "welcom to visited the space,I like football", 
            "hello boy, i like someone", 
            "come on baby", 
            "first blood", 
            "I like football,I like football", 
            "my girlfriend is so beatiful, every body like game"
    };
    private int[] attaches = {2,5,6,5,8,4};//附件数量
    //发件人名字
    private String[] names = {"Tom", "Jack", "goudan", "alibaba", "jerry", "kitty"};
    //邮件的日期
    private Date[] dates = null;

    private Directory directory = null;
    private Map<String, Float> scores = new HashMap<String, Float>();//新建一个Map,用来存储权值
    /*private static IndexReader reader = null;//声明一个IndexReader的属性*/
    private SearcherManager mgr = null;

    public IndexUtil() {
        try {
            setDates();//设置日期
            scores.put("qq.com", 2.0f);//如果是"qq.com"结尾的索引则让其权值为2.0,注意:默认是1.0
            scores.put("sina.edu", 1.5f);
            directory = FSDirectory.open(new File("E:/myeclipse/Lucene/index"));
            mgr = new SearcherManager(directory, new SearcherWarmer() {
                //在重新打开的时候可能需要做一个控制,这些控制可以在这个方法中做
                @Override
                public void warm(IndexSearcher searcher) throws IOException {
                    System.out.println("has changed");
                }
            }, Executors.newCachedThreadPool());
        } catch (IOException e) {
            e.printStackTrace(); 
        }
    }

    //创建索引
    public void index(){
        IndexWriter writer = null;
        try {
            writer = new IndexWriter(directory, new IndexWriterConfig(Version.LUCENE_35, new StandardAnalyzer(Version.LUCENE_35)));
            //此方法可将索引全部清空
            writer.deleteAll();
            Document document = null;
            for(int i = 0; i < ids.length; i++){
                document = new Document();
                //id需要存储,不需要加权、分词,email也需要存储,但不需要分词,有时候也需要加权
                //对于内容,我们不需要存储和加权,但需要分词。而名字需要存储,不需要分词和加权
                //这里我们先不对整型数据进行索引,后面再说
                document.add(new Field("id", ids[i], Field.Store.YES, Field.Index.NOT_ANALYZED_NO_NORMS));
                document.add(new Field("email", emails[i], Field.Store.YES, Field.Index.NOT_ANALYZED));
                document.add(new Field("content", content[i], Field.Store.NO, Field.Index.ANALYZED));
                document.add(new Field("name", names[i], Field.Store.YES, Field.Index.NOT_ANALYZED_NO_NORMS));

                //为数字添加索引,第三个参数设置为true表示默认索引
                document.add(new NumericField("attach", Field.Store.YES, true).setIntValue(attaches[i]));
                //为日期添加索引
                document.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)){
                    document.setBoost(scores.get(et));
                }else{
                    document.setBoost(0.5f);
                }
                writer.addDocument(document);
            }
        } 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) {
                    e.printStackTrace();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    //查询
    public void query(){
        try {
            IndexReader reader = IndexReader.open(directory);
            //maxDoc 和 numDocs()方法的区别:maxDoc()返回索引中删除和未被删除的文档总数,
            //后者返回索引中未被删除的文档总数,通过reader可以有效获取文档的数量
            System.out.println("numDocs: " + reader.numDocs());
            System.out.println("maxDocs: " + reader.maxDoc());
            //查看被删除的索引
            System.out.println("deleteDocs : " + reader.numDeletedDocs());
            //记得用完之后关闭
            reader.close();

        } catch (CorruptIndexException e) {
            e.printStackTrace();
        } catch (IOException e) {
            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是一个精确查找的值
            //这里我们测试此方法之后再次执行搜索方法,发现文档数numDocs还有5个,比之前少了一个,但是maxDoc还是6个
            //在我们的索引目录中发现出现了一个delete的文件。这里的删除就像一个回收站一样,是可以恢复的
            writer.deleteDocuments(new Term("id", "1"));//这里表示删除索引为1的id
            writer.commit();
        } catch (CorruptIndexException e) {
            e.printStackTrace();
        } catch (LockObtainFailedException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //更新索引
    public void update(){
        IndexWriter writer = null;
        try {
            writer = new IndexWriter(directory, new IndexWriterConfig(Version.LUCENE_35, new StandardAnalyzer(Version.LUCENE_35)));

            /* lucene并没有提供更新,这里的更新操作其实是如下两个操作的合集
             * 先删除之后再添加,所以不是在之前的位置更新
             * 测试之后我们会发现回收站中有一个索引
             * */
            Document document = new Document();
            document.add(new Field("id", "11", Field.Store.YES, Field.Index.NOT_ANALYZED_NO_NORMS));
            document.add(new Field("email", emails[0], Field.Store.YES, Field.Index.NOT_ANALYZED));
            document.add(new Field("content", content[0], Field.Store.NO, Field.Index.ANALYZED));
            document.add(new Field("name", names[0], Field.Store.YES, Field.Index.NOT_ANALYZED_NO_NORMS));
            writer.updateDocument(new Term("id", "1"), document);
        } 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) {
                    e.printStackTrace();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public void search01(){
        IndexReader reader;
        try {
            reader = IndexReader.open(directory);
            IndexSearcher searcher = new IndexSearcher(reader);
            TermQuery query = new TermQuery(new Term("content", "like"));//搜索内容中含有like的
            TopDocs tds = searcher.search(query, 10);
            for(ScoreDoc sd : tds.scoreDocs){
                Document doc = searcher.doc(sd.doc);
                //这里我们获取权值getBoost()的时候发现都是1.0,这是因为这里是获取的一个document,和原来的没有关系。
                //要想看其权值信息,可以使用luke工具
                //而这里的日期需要我们转换成日期格式
                System.out.println("(" + sd.doc + "权值:"+ doc.getBoost() + ")" + doc.get("name") + "[" + doc.get("email") + "]-->" 
                            + doc.get("id") + "-->" + doc.get("attach") + "-->" + doc.get("date"));
                reader.close();
            }
        } catch (CorruptIndexException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //设置日期
    private void setDates(){
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        try {
            dates = new Date[ids.length];
            dates[0] = sdf.parse("2015-02-15");
            dates[1] = sdf.parse("2015-03-01");
            dates[2] = sdf.parse("2015-05-18");
            dates[3] = sdf.parse("2015-09-05");
            dates[4] = sdf.parse("2015-12-15");
            dates[5] = sdf.parse("2015-08-29");
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
    public void search02(){
        IndexSearcher searcher = null;
        try {
            mgr.maybeReopen();//判断是否需要重新打开一个IndexSearcher
            searcher = mgr.acquire();
            TermQuery query = new TermQuery(new Term("content", "like"));//搜索内容中含有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() + ")" + doc.get("name") + "[" + doc.get("email") + "]-->" 
                            + doc.get("id") + "-->" + doc.get("attach") + "-->" + doc.get("date"));
            }
        } catch (CorruptIndexException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                mgr.release(searcher);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

说明:那是大家事先写过的3个工具类,和前面差异的是大家这里不再直接获得IndexReader,而是定义3个SearcherManager对象:

private SearcherManager mgr = null;

然后对IndexUtil艺术举办改建,我们通过SearcherManager来管理IndexReader,同时在大家立异索引的进程中大家还是能对财富做一些操作。再对章程search02List集合去重使用lambda表明式,C语言实例。艺术开始展览改造,这里大家是由此SearcherManager来获得IndexReader指标的,同时是还是不是打开二个新的IndexReaderSearcherManager的方法maybeReopen来决定。而使用完之后大家也不要求关闭IndexReader,只需求将其保释即可,使用办法release

下边举办测试:

package cn.lucene.test;
import org.junit.Test;
import cn.itcast.util.IndexUtil;

public class TestIndex {
    @Test
    public void testIndex(){
        IndexUtil util = new IndexUtil();
        util.index();
    }

    @Test
    public void testQuery(){
        IndexUtil util = new IndexUtil();
        util.query();
    }

    @Test
    public void testDelete(){
        IndexUtil util = new IndexUtil();
        util.delete();
    }

    @Test
    public void testUpdate(){
        IndexUtil util = new IndexUtil();
        util.update();
    }
    @Test
    public void testSearch01(){
        IndexUtil util = new IndexUtil();
        util.search01();
    }
    @Test
    public void testSearch02(){
        IndexUtil util = new IndexUtil();
        for(int i = 0; i < 5; i++){
            util.search02();//这里我们让其执行5次
            System.out.println("************************");
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

说明:在测试方法testSearch02事先大家先使用方法testIndex重建索引,然后我们利用方法testQuery可以看出记录数:

美高梅开户网址 1

1

而在testSearch02方法还不曾运营完时大家应用testDelete主意进行删减,此时大家发现testSearch02情势在末端的输出少了一条记下。将记录0给删除了。固然这么,当我们重新行使testQuery艺术查询的时候发现记录没有被删掉,这是因为并从未交给,而采取SearcherManager亟需开始展览writer.commit才会检查和测试到,于是那就必要动用NRTManager本条类了。

注意:我们在reopen时可能要求对一些财富做一些操作,可以在艺术SearcherWarmer. Warm中进行,我们在testSearch02艺术的输出中也足以见见打字与印刷出了has changed

 

(2)在sqlserver中,是同意将空字符“”插入到数量库表的Not
NULL字段的,但是在Oracle中是不容许那样举行插队的,务必使用科学的数据类型举办填空方可。   

③ 、近实时寻找(工程lucene-nearRealTime01

只是利用SearcherManager是不可能落到实处实时搜索的,因为只是更新的内部存款和储蓄器,而并不曾真正的交付。
在类IndexUtil.java中大家添加两性情子:

private NRTManager nrtMgr = null;
private IndexWriter writer;

对相关方法举行改建:

package cn.itcast.util;
import java.io.File;
import java.io.IOException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.Executors;
import org.apache.lucene.analysis.TokenStream;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.document.Fieldable;
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.FieldInfo.IndexOptions;
import org.apache.lucene.index.StaleReaderException;
import org.apache.lucene.index.Term;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.NRTManager;
import org.apache.lucene.search.NRTManagerReopenThread;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.SearcherManager;
import org.apache.lucene.search.SearcherWarmer;
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.store.RAMDirectory;
import org.apache.lucene.util.Version;

public class IndexUtil {
    private String[] ids = {"1", "2", "3", "4", "5", "6"};
    //下面是邮件
    private String[] emails = {"aa@qq.com", "bb@sina.edu", "cc@yahu.org", "ss@sina.com", "dd@gmail.com", "ee@163.com"};
    //下面是邮件内容
    private String[] content = {
            "welcom to visited the space,I like football", 
            "hello boy, i like someone", 
            "come on baby like", 
            "first blood like", 
            "I like football,I like football", 
            "my girlfriend is so beatiful, every body like game"
    };
    private int[] attaches = {2,5,6,5,8,4};//附件数量
    //发件人名字
    private String[] names = {"Tom", "Jack", "goudan", "alibaba", "jerry", "kitty"};
    //邮件的日期
    private Date[] dates = null;

    private Directory directory = null;
    private Map<String, Float> scores = new HashMap<String, Float>();//新建一个Map,用来存储权值
    /*private static IndexReader reader = null;//声明一个IndexReader的属性*/
    private SearcherManager mgr = null;
    private NRTManager nrtMgr = null;
    private IndexWriter writer;

    public IndexUtil() {
        try {
            setDates();//设置日期
            scores.put("qq.com", 2.0f);//如果是"qq.com"结尾的索引则让其权值为2.0,注意:默认是1.0
            scores.put("sina.edu", 1.5f);
            directory = FSDirectory.open(new File("E:/myeclipse/Lucene/index"));
            writer = new IndexWriter(directory, new IndexWriterConfig(Version.LUCENE_35, new StandardAnalyzer(Version.LUCENE_35)));
            nrtMgr = new NRTManager(writer, new SearcherWarmer() {

                @Override
                public void warm(IndexSearcher arg0) throws IOException {
                    System.out.println("reopen");

                }
            });
            //重新打开的时候间隔最大为5.0,最小为0.025,0.025为25秒
            NRTManagerReopenThread reopen = new NRTManagerReopenThread(nrtMgr, 5.0, 0.025);
            reopen.setDaemon(true);
            reopen.setName("NrtManger Reopen Thread");
            reopen.start();//启动线程NRTManager的reopen线程
            mgr = nrtMgr.getSearcherManager(true);//允许所有更新
        } catch (IOException e) {
            e.printStackTrace(); 
        }
    }

    //创建索引
    public void index(){
        IndexWriter writer = null;
        try {
            writer = new IndexWriter(directory, new IndexWriterConfig(Version.LUCENE_35, new StandardAnalyzer(Version.LUCENE_35)));
            //此方法可将索引全部清空
            writer.deleteAll();
            Document document = null;
            for(int i = 0; i < ids.length; i++){
                document = new Document();
                //id需要存储,不需要加权、分词,email也需要存储,但不需要分词,有时候也需要加权
                //对于内容,我们不需要存储和加权,但需要分词。而名字需要存储,不需要分词和加权
                //这里我们先不对整型数据进行索引,后面再说
                document.add(new Field("id", ids[i], Field.Store.YES, Field.Index.NOT_ANALYZED_NO_NORMS));
                document.add(new Field("email", emails[i], Field.Store.YES, Field.Index.NOT_ANALYZED));
                document.add(new Field("content", content[i], Field.Store.NO, Field.Index.ANALYZED));
                document.add(new Field("name", names[i], Field.Store.YES, Field.Index.NOT_ANALYZED_NO_NORMS));

                //为数字添加索引,第三个参数设置为true表示默认索引
                document.add(new NumericField("attach", Field.Store.YES, true).setIntValue(attaches[i]));
                //为日期添加索引
                document.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)){
                    document.setBoost(scores.get(et));
                }else{
                    document.setBoost(0.5f);
                }
                writer.addDocument(document);
            }
        } 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) {
                    e.printStackTrace();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    //查询
    public void query(){
        try {
            IndexReader reader = IndexReader.open(directory);
            //maxDoc 和 numDocs()方法的区别:maxDoc()返回索引中删除和未被删除的文档总数,
            //后者返回索引中未被删除的文档总数,通过reader可以有效获取文档的数量
            System.out.println("numDocs: " + reader.numDocs());
            System.out.println("maxDocs: " + reader.maxDoc());
            //查看被删除的索引
            System.out.println("deleteDocs : " + reader.numDeletedDocs());
            //记得用完之后关闭
            reader.close();

        } catch (CorruptIndexException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //删除索引
    public void delete(){
        IndexWriter writer = null;
        try {
            nrtMgr.deleteDocuments(new Term("id", "1"));//这里表示删除索引为1的id
        } catch (CorruptIndexException e) {
            e.printStackTrace();
        } catch (LockObtainFailedException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //更新索引
    public void update(){
        try {
            /* lucene并没有提供更新,这里的更新操作其实是如下两个操作的合集
             * 先删除之后再添加,所以不是在之前的位置更新
             * 测试之后我们会发现回收站中有一个索引
             * */
            Document document = new Document();
            document.add(new Field("id", "11", Field.Store.YES, Field.Index.NOT_ANALYZED_NO_NORMS));
            document.add(new Field("email", emails[0], Field.Store.YES, Field.Index.NOT_ANALYZED));
            document.add(new Field("content", content[0], Field.Store.NO, Field.Index.ANALYZED));
            document.add(new Field("name", names[0], Field.Store.YES, Field.Index.NOT_ANALYZED_NO_NORMS));
            nrtMgr.updateDocument(new Term("id", "1"), document);
        } catch (CorruptIndexException e) {
            e.printStackTrace();
        } catch (LockObtainFailedException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void search01(){
        IndexReader reader;
        try {
            reader = IndexReader.open(directory);
            IndexSearcher searcher = new IndexSearcher(reader);
            TermQuery query = new TermQuery(new Term("content", "like"));//搜索内容中含有like的
            TopDocs tds = searcher.search(query, 10);
            for(ScoreDoc sd : tds.scoreDocs){
                Document doc = searcher.doc(sd.doc);
                //这里我们获取权值getBoost()的时候发现都是1.0,这是因为这里是获取的一个document,和原来的没有关系。
                //要想看其权值信息,可以使用luke工具
                //而这里的日期需要我们转换成日期格式
                System.out.println("(" + sd.doc + "权值:"+ doc.getBoost() + ")" + doc.get("name") + "[" + doc.get("email") + "]-->" 
                            + doc.get("id") + "-->" + doc.get("attach") + "-->" + doc.get("date"));
                reader.close();
            }
        } catch (CorruptIndexException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //设置日期
    private void setDates(){
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        try {
            dates = new Date[ids.length];
            dates[0] = sdf.parse("2015-02-15");
            dates[1] = sdf.parse("2015-03-01");
            dates[2] = sdf.parse("2015-05-18");
            dates[3] = sdf.parse("2015-09-05");
            dates[4] = sdf.parse("2015-12-15");
            dates[5] = sdf.parse("2015-08-29");
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
    public void search02(){
        IndexSearcher searcher = null;
        try {
            mgr.maybeReopen();//判断是否需要重新打开一个IndexSearcher
            searcher = mgr.acquire();
            TermQuery query = new TermQuery(new Term("content", "like"));//搜索内容中含有like的
            TopDocs tds = searcher.search(query, 10);
            for(ScoreDoc sd : tds.scoreDocs){
                Document doc = searcher.doc(sd.doc);
                System.out.println(doc.get("id") + "-->" + doc.get("name") + "[" + doc.get("email") + "]-->" 
                             + doc.get("attach") + "-->" + doc.get("date"));
            }
        } catch (CorruptIndexException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                mgr.release(searcher);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public void commit(){
        try {
            writer.commit();
        } catch (CorruptIndexException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

说明:在方法IndexUtil中我们实例化了IndexWriter指标,同时使用NRTManager目的来获得SearcherManager对象,进而管理IndexSearcher。在deleteupdate主意中,间接采纳NRTManager来进行有关的操作,因为此指标实现了IndexSearcher的保有办法,所以大家不直接选拔IndexSearcher了。在章程search0第22中学我们运用办法maybeReopen认清是不是须求再次打开IndexSearcher,而这几个打开的日子大家在章程IndexUtil中设置的为25-5000秒之内。

测试:
测试时对testSearch02主意开始展览改动:

    @Test
    public void testSearch02(){
        IndexUtil util = new IndexUtil();
        for(int i = 0; i < 5; i++){
            util.search02();//这里我们让其执行5次
            System.out.println("************************");
            util.delete();
            if(i == 2){
                util.update();
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

说明:测试结果:

1-->Tom[aa@qq.com]-->2-->1423929600000
2-->Jack[bb@sina.edu]-->5-->1425139200000
5-->jerry[dd@gmail.com]-->8-->1450108800000
6-->kitty[ee@163.com]-->4-->1440777600000
************************
reopen
2-->Jack[bb@sina.edu]-->5-->1425139200000
5-->jerry[dd@gmail.com]-->8-->1450108800000
6-->kitty[ee@163.com]-->4-->1440777600000
************************
2-->Jack[bb@sina.edu]-->5-->1425139200000
5-->jerry[dd@gmail.com]-->8-->1450108800000
6-->kitty[ee@163.com]-->4-->1440777600000
************************
reopen
2-->Jack[bb@sina.edu]-->5-->1425139200000
11-->Tom[aa@qq.com]-->null-->null
5-->jerry[dd@gmail.com]-->8-->1450108800000
6-->kitty[ee@163.com]-->4-->1440777600000
************************
2-->Jack[bb@sina.edu]-->5-->1425139200000
11-->Tom[aa@qq.com]-->null-->null
5-->jerry[dd@gmail.com]-->8-->1450108800000
6-->kitty[ee@163.com]-->4-->1440777600000
************************

那边我们是先进行询问,之后展开删除,同时在第三回查询的时候进行更新,更新其实就是将事先id为1(删除的那条记下)更新为11,能够阅览相应的结果。而此时我们再将去除和换代的局部注释掉,即:

util.delete();
if(i == 2){
    util.update();
}

重新查询,发现并从未删除,那是因为除去只是在内部存款和储蓄器中进行,而并不曾付诸。那里要留意的是:这里之所以叫近实时搜索,就是以此立异的大运是由线程序控制制,那里大家能够将休眠时间独家该为1秒和2秒(同时将mgr.maybeReopen();美高梅开户网址,诠释掉)来查阅效果。当然在那个测试方法的末梢加上

uti.commit();

才会将有关的换代持久化。而相比较SearcherManagerNRTManager不需求交给就能被搜寻到,这样我们就足以在2个合并的岁月对索引实行更新了。

未完待续。。。

犹如上表中,名字(name)中再次的想要去除,使用linq实行去重的主意,使用Distinct()根本不可能达到须求。那么:

 (3)在sqlserver中实践清除数据库表的操作,即正是数据表内容为空,如故能够正确地履行,但是在Oracle中,只有当数码表中的数码不为空的时候,才能去除成功,不然会抛出拾贰分,请保管删除有内容的数据表,或然利用try
catch将语句进行丰硕捕获均可。    

var list_distinct = list_Persons.GroupBy(c => c.name).Select(c => c.First());

(4)在sqlserver中,sql语句中对数字型字符串举办拼接的时候,可以一向利用“+”进行,不过在Oracle中,要是利用“+”的话,则会将八个数字进行求和,并非是将字符串举行拼接,应该使用concat进行拼接。    

其实的趣味是基于某一列进行分组,然后拿走每一组的首先条数据,可以消除此次供给

(5)在sqlserver中,求取当前系统时间的函数为getdate(),在Oracle中动用的函数为SYSDATE。    

 

(6)在sqlserver准将时间型字符串插入数据库相应字段时候,如2009-5-9
17:45:22,能够健康实施,不过在Oracle中是不能够将那样的数量直接插入数据库中的,需求开始展览一定的变换方可。
(7)在sqlserver中,在insert数据的时候,数据表的标识字段是不要进行插队的,可是在采取Oracle的时候,因没有“标识”的定义,所以,依然供给展开插队。

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图