全文检索为什么出错？

Question

private String indexPath = "c://";
    private String filePath  = "e://";
    private String queryStr  = "doc";
记住全部要//  不能是单斜杆

Answer 1

c://?
是c:\\吧
不过好像c:/也可以啊

Answer 2

是因为你在执行的时候，lucence的索引库还没有建成吧，这样的话你怎么查询呢？
有几个缺省的文件你看在不在，write.lock;segment;deletable还有一些以“_”开头的文件，是实际存放索引的文件。

Answer 3

对了，你有没有看过车东的那篇文章，可以去他的主页上找找，他有一个lucence的opensource;网址好像是www.chedong.com/lucence/;找找看。解决了告诉我如何建一个空的索引库，嗬嗬，我也一直没有解决，不过我有一个很小的库，每次就在这个上面建，不会出错，但是指定一个空的目录不行，而且我还没有彻底弄明白那个三文件的格式和确切意义。

Answer 4

有个别的问题，你为什么用SimpleAnalyzer？这个对中文的支持很弱的，分词是根据标点符号切分的，这样的话你必须匹配至少一句话才能查询出来，做搜索的不用我教你吧，分词是很关键的。

Answer 5

我这里有个切分单字的，嗬嗬，基于词库的当然是不能给你了！
package org.apache.lucene.analysis.cn;import java.io.*;import org.apache.lucene.analysis.*;public final class ChineseTokenizer
    extends Tokenizer {
    private int offset;
    private int bufferIndex;
    private int dataLen;
    private static final int MAX_WORD_LEN = 255;
    private static final int IO_BUFFER_SIZE = 1024;
    private final char buffer[] = new char[255];
    private final char ioBuffer[] = new char[1024];
    private int length;
    private int start;    public ChineseTokenizer(Reader reader) {
        offset = 0;
        bufferIndex = 0;
        dataLen = 0;
        super.input = reader;
    }    private final void push(char c) {
        if (length == 0) {
            start = offset - 1;
        }
        buffer[length++] = Character.toLowerCase(c);
    }    private final void pop() {
        length--;
    }    private final Token flush() {
        if (length > 0) {
            return new Token(new String(buffer, 0, length), start,
                             start + length);
        }
        else {
            return null;
        }
    }    public final Token next() throws IOException {
        length = 0;
        start = offset;
        Token token = null;
        while (token == null) {
            offset++;
            if (bufferIndex >= dataLen) {
                dataLen = super.input.read(ioBuffer);
                bufferIndex = 0;
            }
            if (dataLen == -1) {
                token = flush();
                if (token == null || token.termText().length() <= 1) {
                    return null;
                }
                break;
            }
            char c = ioBuffer[bufferIndex++];
            switch (Character.getType(c)) {
                case Character.TITLECASE_LETTER:
                case Character.MODIFIER_LETTER:
                case Character.NON_SPACING_MARK:
                case Character.ENCLOSING_MARK:
                case Character.COMBINING_SPACING_MARK:
                default:
                    if (length == 1) {
                        pop();
                    }
                    else if (length > 0) {
                        token = flush();
                    }
                    break;                case Character.UPPERCASE_LETTER:
                case Character.LOWERCASE_LETTER:
                case Character.DECIMAL_DIGIT_NUMBER:
                    if (length > 0 &&
                        Character.getType(buffer[length - 1]) ==
                        Character.OTHER_LETTER) {
                        if (length > 1) {
                            token = flush();
                            bufferIndex--;
                            break;
                        }
                        else {
                            pop();
                        }
                    }
                    push(c);
                    if (length == 255) {
                        token = flush();
                    }
                    break;                case Character.OTHER_LETTER:
                    if (length > 0) {
                        if (Character.getType(buffer[length - 1]) ==
                            Character.OTHER_LETTER) {
                            push(c);
                            token = flush();
                            bufferIndex--;
                        }
                        else {
                            if (length > 1) {
                                bufferIndex--;
                                token = flush();
                            }
                            else {
                                pop();
                                push(c);
                            }
                        }
                    }
                    else {
                        push(c);
                    }
                    break;
            }
        }
        /*
          String temp = token.termText();
          try {
           System.out.println("index word: "+new String(temp.getBytes("GBK"))+" word length = "+temp.length());
          } catch (Exception e) {}
         */
        return token;
    }
}