Java FrenchAnalyzer类代码示例

import org.apache.lucene.analysis.fr.FrenchAnalyzer; //导入依赖的package包/类
private String removeStopWords(String action) {
    StringBuilder builder = new StringBuilder();
    try {
        FrenchAnalyzer frenchAnalyzer = new FrenchAnalyzer();
        TokenStream tokenStream = frenchAnalyzer.tokenStream("contents", action);
        CharTermAttribute attribute = tokenStream.addAttribute(CharTermAttribute.class);
        tokenStream.reset();
        while (tokenStream.incrementToken()) {
            String term = attribute.toString();
            builder.append(term + " ");
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
    return builder.toString();
}
 

import org.apache.lucene.analysis.fr.FrenchAnalyzer; //导入依赖的package包/类
public FrenchAnalyzerProvider(IndexSettings indexSettings, Environment env, String name, Settings settings) {
    super(indexSettings, name, settings);
    analyzer = new FrenchAnalyzer(
        Analysis.parseStopWords(env, indexSettings.getIndexVersionCreated(), settings, FrenchAnalyzer.getDefaultStopSet()),
        Analysis.parseStemExclusion(settings, CharArraySet.EMPTY_SET)
    );
    analyzer.setVersion(version);
}
 

import org.apache.lucene.analysis.fr.FrenchAnalyzer; //导入依赖的package包/类
@Override
public void inform(ResourceLoader loader) throws IOException {
  if (articlesFile == null) {
    articles = FrenchAnalyzer.DEFAULT_ARTICLES;
  } else {
    articles = getWordSet(loader, articlesFile, ignoreCase);
  }
}
 

import org.apache.lucene.analysis.fr.FrenchAnalyzer; //导入依赖的package包/类
@Inject
public FrenchAnalyzerProvider(Index index, IndexSettingsService indexSettingsService, Environment env, @Assisted String name, @Assisted Settings settings) {
    super(index, indexSettingsService.getSettings(), name, settings);
    analyzer = new FrenchAnalyzer(Analysis.parseStopWords(env, settings, FrenchAnalyzer.getDefaultStopSet()),
                                  Analysis.parseStemExclusion(settings, CharArraySet.EMPTY_SET));
    analyzer.setVersion(version);
}
 

import org.apache.lucene.analysis.fr.FrenchAnalyzer; //导入依赖的package包/类
public void testEmptyTerm() throws IOException {
  Analyzer a = new Analyzer() {
    @Override
    protected TokenStreamComponents createComponents(String fieldName, Reader reader) {
      Tokenizer tokenizer = new KeywordTokenizer(reader);
      return new TokenStreamComponents(tokenizer, new ElisionFilter(tokenizer, FrenchAnalyzer.DEFAULT_ARTICLES));
    }
  };
  checkOneTerm(a, "", "");
}
 

import org.apache.lucene.analysis.fr.FrenchAnalyzer; //导入依赖的package包/类
@Override
public void inform(ResourceLoader loader) throws IOException {
  String articlesFile = args.get("articles");
  boolean ignoreCase = getBoolean("ignoreCase", false);

  if (articlesFile != null) {
    articles = getWordSet(loader, articlesFile, ignoreCase);
  }
  if (articles == null) {
    articles = FrenchAnalyzer.DEFAULT_ARTICLES;
  }
}
 

import org.apache.lucene.analysis.fr.FrenchAnalyzer; //导入依赖的package包/类
public void testEmptyTerm() throws IOException {
  Analyzer a = new Analyzer() {
    @Override
    protected TokenStreamComponents createComponents(String fieldName, Reader reader) {
      Tokenizer tokenizer = new KeywordTokenizer(reader);
      return new TokenStreamComponents(tokenizer, new ElisionFilter(tokenizer, FrenchAnalyzer.DEFAULT_ARTICLES));
    }
  };
  checkOneTermReuse(a, "", "");
}
 

import org.apache.lucene.analysis.fr.FrenchAnalyzer; //导入依赖的package包/类
public final Analyzer getAnalyzer(Locale locale) {
    if (locale.getLanguage().equals(Locale.FRENCH.getLanguage())) {
        return new FrenchAnalyzer(Version.LUCENE_44);
    } else {
        return new StandardAnalyzer(Version.LUCENE_44);
    }
}
 

import org.apache.lucene.analysis.fr.FrenchAnalyzer; //导入依赖的package包/类
@Override
public FrenchAnalyzer get() {
    return this.analyzer;
}
 

import org.apache.lucene.analysis.fr.FrenchAnalyzer; //导入依赖的package包/类
protected void configureLucene() {
    bind(Stemmer.class).to(LuceneStemmer.class).in(Singleton.class);
    bind(TextNormalizer.class).to(LuceneNormalizer.class).in(Singleton.class);
    bind(CharArraySet.class).annotatedWith(Models.named(LuceneNormalizer.LUCENE_STOP_WORDS_MODEL)).toInstance(FrenchAnalyzer.getDefaultStopSet());
}
 

import org.apache.lucene.analysis.fr.FrenchAnalyzer; //导入依赖的package包/类
@Singleton
@Provides @NoStopWordFiltering
public Analyzer getFrenchWithStopWordsAnalyzer() {
    return new FrenchAnalyzer(CharArraySet.EMPTY_SET);
}
 

import org.apache.lucene.analysis.fr.FrenchAnalyzer; //导入依赖的package包/类
@Singleton
@Provides
public Analyzer getFrenchAnalyzer() {
    return new FrenchAnalyzer();
}
 

import org.apache.lucene.analysis.fr.FrenchAnalyzer; //导入依赖的package包/类
/**
 * Returns the default stopwords set used by Lucene language analyzer for the specified language.
 *
 * @param language The language for which the stopwords are. The supported languages are English, French, Spanish,
 *                 Portuguese, Italian, Romanian, German, Dutch, Swedish, Norwegian, Danish, Russian, Finnish,
 *                 Irish, Hungarian, Turkish, Armenian, Basque and Catalan.
 * @return The default stopwords set used by Lucene language analyzers.
 */
private static CharArraySet getDefaultStopwords(String language) {
    switch (language) {
        case "English":
            return EnglishAnalyzer.getDefaultStopSet();
        case "French":
            return FrenchAnalyzer.getDefaultStopSet();
        case "Spanish":
            return SpanishAnalyzer.getDefaultStopSet();
        case "Portuguese":
            return PortugueseAnalyzer.getDefaultStopSet();
        case "Italian":
            return ItalianAnalyzer.getDefaultStopSet();
        case "Romanian":
            return RomanianAnalyzer.getDefaultStopSet();
        case "German":
            return GermanAnalyzer.getDefaultStopSet();
        case "Dutch":
            return DutchAnalyzer.getDefaultStopSet();
        case "Swedish":
            return SwedishAnalyzer.getDefaultStopSet();
        case "Norwegian":
            return NorwegianAnalyzer.getDefaultStopSet();
        case "Danish":
            return DanishAnalyzer.getDefaultStopSet();
        case "Russian":
            return RussianAnalyzer.getDefaultStopSet();
        case "Finnish":
            return FinnishAnalyzer.getDefaultStopSet();
        case "Irish":
            return IrishAnalyzer.getDefaultStopSet();
        case "Hungarian":
            return HungarianAnalyzer.getDefaultStopSet();
        case "Turkish":
            return SpanishAnalyzer.getDefaultStopSet();
        case "Armenian":
            return SpanishAnalyzer.getDefaultStopSet();
        case "Basque":
            return BasqueAnalyzer.getDefaultStopSet();
        case "Catalan":
            return CatalanAnalyzer.getDefaultStopSet();
        default:
            return CharArraySet.EMPTY_SET;
    }
}
 

import org.apache.lucene.analysis.fr.FrenchAnalyzer; //导入依赖的package包/类
public Tokenizer() {
	
	Analyzer en_analyzer = new EnglishAnalyzer(Version.LUCENE_44);
	Analyzer es_analyzer = new SpanishAnalyzer(Version.LUCENE_44);
	Analyzer de_analyzer = new GermanAnalyzer(Version.LUCENE_44);
	Analyzer da_analyzer = new DanishAnalyzer(Version.LUCENE_44);
	Analyzer el_analyzer = new GreekAnalyzer(Version.LUCENE_44);
	Analyzer fr_analyzer = new FrenchAnalyzer(Version.LUCENE_44);
	Analyzer it_analyzer = new ItalianAnalyzer(Version.LUCENE_44);
	Analyzer pt_analyzer = new PortugueseAnalyzer(Version.LUCENE_44);
	Analyzer ru_analyzer = new RussianAnalyzer(Version.LUCENE_44);
	Analyzer fa_analyzer = new PersianAnalyzer(Version.LUCENE_44);	
	Analyzer ar_analyzer = new ArabicAnalyzer(Version.LUCENE_44);
	Analyzer id_analyzer = new IndonesianAnalyzer(Version.LUCENE_44);
	Analyzer pl_analyzer = new MorfologikAnalyzer(Version.LUCENE_44);
	Analyzer nl_analyzer = new DutchAnalyzer(Version.LUCENE_44);
	Analyzer no_analyzer = new NorwegianAnalyzer(Version.LUCENE_44);
	Analyzer ro_analyzer = new RomanianAnalyzer(Version.LUCENE_44);
	Analyzer sv_analyzer = new SwedishAnalyzer(Version.LUCENE_44);
	Analyzer fi_analyzer = new FinnishAnalyzer(Version.LUCENE_44);
	Analyzer tr_analyzer = new TurkishAnalyzer(Version.LUCENE_44);
	Analyzer hu_analyzer = new HungarianAnalyzer(Version.LUCENE_44);
	Analyzer bg_analyzer = new BulgarianAnalyzer(Version.LUCENE_44);
	
	analyzers.put("en", en_analyzer);
	analyzers.put("es", es_analyzer);
	analyzers.put("de", de_analyzer);
	analyzers.put("da", da_analyzer);
	analyzers.put("el", el_analyzer);
	analyzers.put("fr", fr_analyzer);
	analyzers.put("it", it_analyzer);
	analyzers.put("pt", pt_analyzer);
	analyzers.put("ru", ru_analyzer);
	analyzers.put("fa", fa_analyzer);
	analyzers.put("ar", ar_analyzer);
	analyzers.put("id", id_analyzer);
	analyzers.put("pl", pl_analyzer);
	analyzers.put("nl", nl_analyzer);
	analyzers.put("no", no_analyzer);
	analyzers.put("ro", ro_analyzer);
	analyzers.put("sv", sv_analyzer);
	analyzers.put("fi", fi_analyzer);
	analyzers.put("tr", tr_analyzer);
	analyzers.put("hu", hu_analyzer);
	analyzers.put("bg", bg_analyzer);
}