Wie erlaubt mehr als zwei Wörter in diesem Java-Code überprüft werden

Question

Ich muss dieses Skript ändern, so dass mehr als zwei Wörter überprüft werden können und meine Kenntnisse von Java ist zu begrenzt, um die Änderungen selbst vorzunehmen. Dieses Skript ist Teil einer OpenSource-Grammatikprüfung für OpenOffice (LanguageTool), und der Zweck des Skripts besteht darin, bestimmte Wörter durch andere Wörter zu ersetzen.

Die Datei von Wörtern geprüft werden wird als „coherency.txt“ und es ist Format ist wie folgt: WrongWord1 = CorrectWord1 WrongWord2 = CorrectWord2

Und wenn ich schreibe: WrongWord1 es durch das Skript gekennzeichnet ist und sagt mir, ich sollte stattdessen CorrectWord1 verwenden.

Aber ich muss in der Lage sein, drei Worte oder mehr zu haben, wie folgt aus: WrongWord1 = WrongWord2 = CorrectWord1 WrongWord3 = WrongWord4 = WrongWord5 = CorrectWord2 WrongWord6 = CorrectWord3

So dass, wenn ich tippe WrongWord3 es ist mich markiert und das Skript sagt ich CorrectWord1 verwenden mich CorrectWord2 ODER wenn ich WrongWord2 geben Sie es auch gekennzeichnet ist und das Skript sagt, ich sollte

Wenn Sie Hilfe kann ich einen Link zu Ihrer Webseite platzieren können http://www.sbbic.org/lang/en-us/volunteer/

verwenden sollten

Jede Hilfe, die Sie geben können, wie Sie diesen Code ändern können, damit mehr als zwei Wörter verglichen werden können, wäre sehr zu begrüßen! Danke, Nathan

/* LanguageTool, a natural language style checker 
* Copyright (C) 2005 Daniel Naber (http://www.danielnaber.de) 
* 
* This library is free software; you can redistribute it and/or 
* modify it under the terms of the GNU Lesser General Public 
* License as published by the Free Software Foundation; either 
* version 2.1 of the License, or (at your option) any later version. 
* 
* This library is distributed in the hope that it will be useful, 
* but WITHOUT ANY WARRANTY; without even the implied warranty of 
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 
* Lesser General Public License for more details. 
* 
* You should have received a copy of the GNU Lesser General Public 
* License along with this library; if not, write to the Free Software 
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 
* USA 
*/ 
package de.danielnaber.languagetool.rules; 

import java.io.BufferedReader; 
import java.io.IOException; 
import java.io.InputStream; 
import java.io.InputStreamReader; 
import java.util.ArrayList; 
import java.util.HashMap; 
import java.util.List; 
import java.util.Locale; 
import java.util.Map; 
import java.util.ResourceBundle; 

import de.danielnaber.languagetool.AnalyzedSentence; 
import de.danielnaber.languagetool.AnalyzedTokenReadings; 
import de.danielnaber.languagetool.JLanguageTool; 
import de.danielnaber.languagetool.tools.StringTools; 

/** 
* A Khmer rule that matches words or phrases which should not be used and suggests 
* correct ones instead. Loads the relevant words from 
* <code>rules/km/coherency.txt</code>, where km is a code of the language. 
* 
* @author Andriy Rysin 
*/ 
public abstract class KhmerWordCoherencyRule extends KhmerRule { 

    private Map<String, String> wrongWords; // e.g. "вреѿті реѿт" -> "зреѿтою" 

    private static final String FILE_NAME = "/km/coherency.txt"; 

    public abstract String getFileName(); 

    private static final String FILE_ENCODING = "utf-8"; 

    public String getEncoding() { 
    return FILE_ENCODING; 
    } 

    /** 
    * Indicates if the rule is case-sensitive. Default value is <code>true</code>. 
    * @return true if the rule is case-sensitive, false otherwise. 
    */ 
    public boolean isCaseSensitive() { 
    return false; 
    } 

    /** 
    * @return the locale used for case conversion when {@link #isCaseSensitive()} is set to <code>false</code>. 
    */ 
    public Locale getLocale() { 
    return Locale.getDefault(); 
    } 

    public KhmerWordCoherencyRule(final ResourceBundle messages) throws IOException { 
    if (messages != null) { 
     super.setCategory(new Category(messages.getString("category_misc"))); 
    } 
    wrongWords = loadWords(JLanguageTool.getDataBroker().getFromRulesDirAsStream(getFileName())); 
    } 

    public String getId() { 
    return "KM_WORD_COHERENCY"; 
    } 

    public String getDescription() { 
    return "Checks for wrong words/phrases"; 
    } 

    public String getSuggestion() { 
    return " is not valid, use "; 
    } 

    public String getShort() { 
    return "Wrong word"; 
    } 

    public final RuleMatch[] match(final AnalyzedSentence text) { 
    final List<RuleMatch> ruleMatches = new ArrayList<RuleMatch>(); 
    final AnalyzedTokenReadings[] tokens = text.getTokensWithoutWhitespace(); 

    for (int i = 1; i < tokens.length; i++) { 
     final String token = tokens[i].getToken(); 

     final String origToken = token; 
     final String replacement = isCaseSensitive()?wrongWords.get(token):wrongWords.get(token.toLowerCase(getLocale())); 
     if (replacement != null) { 
     final String msg = token + getSuggestion() + replacement; 
     final int pos = tokens[i].getStartPos(); 
     final RuleMatch potentialRuleMatch = new RuleMatch(this, pos, pos 
      + origToken.length(), msg, getShort()); 
     if (!isCaseSensitive() && StringTools.startsWithUppercase(token)) { 
      potentialRuleMatch.setSuggestedReplacement(StringTools.uppercaseFirstChar(replacement)); 
     } else { 
      potentialRuleMatch.setSuggestedReplacement(replacement); 
     } 
     ruleMatches.add(potentialRuleMatch); 
     } 
    } 
    return toRuleMatchArray(ruleMatches); 
    } 


    private Map<String, String> loadWords(final InputStream file) throws IOException { 
    final Map<String, String> map = new HashMap<String, String>(); 
    InputStreamReader isr = null; 
    BufferedReader br = null; 
    try { 
     isr = new InputStreamReader(file, getEncoding()); 
     br = new BufferedReader(isr); 
     String line; 

     while ((line = br.readLine()) != null) { 
     line = line.trim(); 
     if (line.length() < 1) { 
      continue; 
     } 
     if (line.charAt(0) == '#') { // ignore comments 
      continue; 
     } 
     final String[] parts = line.split("="); 
     if (parts.length != 2) { 
      throw new IOException("Format error in file " 
       + JLanguageTool.getDataBroker().getFromRulesDirAsUrl(getFileName()) + ", line: " + line); 
     } 
     map.put(parts[0], parts[1]); 
     } 

    } finally { 
     if (br != null) { 
     br.close(); 
     } 
     if (isr != null) { 
     isr.close(); 
     } 
    } 
    return map; 
    } 

    public void reset() { 
    } 

} 

Answer 1

Für kleine Anpassungen:

Betrachten Sie das gewünschte Eingabeformat zu

WrongWord = CorrectWord[, CorrectWord]* 

Der Schlüssel wird das falsche Wort zu ändern, wird der Wert eine durch Kommata getrennte Liste von korrekten Alternativen. So können Sie die Analyse der Datei so beibehalten, wie sie ist.

Die Karte sollte vom Typ Map<String, Set<String>> sein - jedes Token entspricht einer Reihe von Alternativen.

Jetzt können Sie jede Zeile um = aufteilen, um ein Schlüssel/Wert-Paar und jeden Wert um , zu erhalten, um ein Array von vorgeschlagenen Tokens zu erhalten, um die Eingabe zu ersetzen.

---

Dann werden Sie einige Änderungen in th match müssen neue Nachricht montieren, da Sie nun mehr als einen Vorschlag erwarten.

ändern Sie die Linien nach final String origToken = token; zu

final String[] replacements = wrongWords.get(token); 
    if (replacements != null) { 
    final String msg = createMessage(token, replacements); 
    final int pos = tokens[i].getStartPos(); 

und Umsetzung der createMessage Methode eine menschliche lesbare Nachricht zurückzugeben, die dem Benutzer die eine zu vielen Alternativen für die Token erzählt.

Answer 2

Das, was Sie ändern müssen, ist dieser Teil in loadWords:

final String[] parts = line.split("="); 
if (parts.length != 2) { 
    throw new IOException("Format error in file " + JLanguageTool.getDataBroker().getFromRulesDirAsUrl(getFileName()) + ", line: " + line); 
} 
map.put(parts[0], parts[1]); 

Dieser Auf die linke Seite des Gleichheits als Schlüssel und die rechte Seite als Wert in die Karte setzt.Deshalb denke ich, dass die linke Seite das falsche Wort sein muss. Daher sollte Ihre Eingabe wrong1 = wrong2 = ... = correct lauten.

Mit dieser Einstellung können Sie einfach an folgende ändern

final String[] parts = line.split("="); 
if (parts.length < 2) { 
    throw new IOException("Format error in file " + JLanguageTool.getDataBroker().getFromRulesDirAsUrl(getFileName()) + ", line: " + line); 
} 
for (int i = 0; i < parts.length - 1; i++) { 
    map.put(parts[i], parts[parts.length - 1]); 
} 

die die Folowing Einträge in der Karte erzeugen würde:

wrong1 = correct 
wrong2 = correct 
wrong3 = correct 
... 

Wahrscheinlich ist es nicht die effizienteste Lösung, aber es sollte irgendwie so funktionieren. Mit dieser Karte können falsche Wörter gesucht werden und die Vorschläge sind die richtigen.

(P. S .: Ich konnte nicht den Code ausführen, so könnte es einige Codierungsfehler drin sein)

Answer 3

import java.util.regex.Matcher; 
import java.util.regex.Pattern; 




public class Test { 

     public static void main(String[] args) { 

      String txtFromFile = "Hipopotamus=hIppoPotamus=hiiippotamus Magazine=Mazagine=Masagine"; 
      String searchWord = "Masagine"; 
      Pattern searchPattern= Pattern.compile("\\s*(\\w+=)*?("+searchWord+")"); 
      Matcher m = searchPattern.matcher(txtFromFile); 
      String source = ""; 
      while(m.find()) { 
       source = m.group(); 
       System.out.println("word pairs:"+source); 
      } 
      System.out.println("correct word:"+source.split("=")[0]); 
     } 
    }