Domanda

Per l'analisi di comandi del giocatore, l'ho usato più spesso il split metodo per dividere una stringa da delimitatori e quindi poi basta capire il resto da una serie di ifs o switches.Quali sono alcuni modi diversi per analizzare le stringhe in Java?

È stato utile?

Soluzione

Presumo che si sta cercando di rendere l'interfaccia di comando disposti a perdonare come possibile.Se questo è il caso, vi suggerisco di usare un algoritmo simile a questo:

  1. Leggere la stringa
    • Dividere la stringa in token
    • Utilizzare un dizionario per convertire i sinonimi di una forma comune
    • Per esempio, la conversione "hit", "punch", "sciopero", e "calcio" a "colpire"
    • Eseguire azioni su un ordinato inclusive base
    • Non ordinata - "pugno di scimmia in faccia" è la stessa cosa come "the face in the monkey punch"
    • Inclusive - Se il comando dovrebbe essere "pugno di scimmia in faccia" e la loro fornitura "pugno di scimmia", si dovrebbe verificare il numero di comandi di questo match.Se un solo comando, eseguire questa azione.Potrebbe anche essere una buona idea avere il comando di priorità, e anche se c'erano anche le partite, sarebbe eseguire l'azione.

Altri suggerimenti

Mi piacciono molto le espressioni regolari.Come lungo come le stringhe di comando sono abbastanza semplici, è possibile scrivere un paio di espressioni regolari che potrebbe prendere un paio di pagine di codice per analizzare in modo manuale.

Vorrei consigliamo di verificare http://www.regular-expressions.info per una buona introduzione alle espressioni regolari, così come esempi specifici per Java.

L'analisi manualmente è un sacco di divertimento...all'inizio:)

In pratica se i comandi non sono molto sofisticati si può trattare allo stesso modo come quelli utilizzati nel interpreti della riga di comando.C'è un elenco delle librerie che si possono utilizzare: http://java-source.net/open-source/command-line.Penso che si può iniziare con apache commons CLI o args4j (utilizza le annotazioni).Essi sono ben documentati, e veramente semplice da usare.Gestire analisi automaticamente e l'unica cosa che devi fare è leggere in particolare i campi di un oggetto.

Se si dispone di comandi più sofisticati, quindi forse la creazione di una grammatica formale sarebbe un'idea migliore.C'è una biblioteca molto buona con grafica editor, debugger e interprete per le grammatiche.Si chiama ANTLR (e l'editor ANTLRWorks) ed è gratis:) Ci sono anche alcuni esempi di grammatiche e tutorial.

Vorrei guardare Java migrazioni di Zork, e appoggiarsi in direzione di un semplice Linguaggio Naturale Processore (azionato mediante la creazione di token o regex) come il seguente (da questo link):

    public static boolean simpleNLP( String inputline, String keywords[])
    {
        int i;
        int maxToken = keywords.length;
        int to,from;
        if( inputline.length() = inputline.length()) return false; // check for blank and empty lines
        while( to >=0 )
        {
            to = inputline.indexOf(' ',from);
            if( to > 0){
                lexed.addElement(inputline.substring(from,to));
                from = to;
                while( inputline.charAt(from) == ' '
                && from = keywords.length) { status = true; break;}
            }
        }
        return status;
    }

...

Qualcosa che dà un programmatore, un motivo per guardare Zork è di nuovo bene nel mio libro, basta guardare fuori per Grues.

...

Sole stesso consiglia di stare lontano da StringTokenizer e utilizzando la Stringa.versato metodo, invece.

Potrai anche voler guardare il Modello di classe.

Un altro voto per ANTLR/ANTLRWorks.Se si creano due versioni del file, uno con il codice Java per eseguire i comandi, e uno senza (con solo la grammatica), poi si dispone di una specifica eseguibile del linguaggio, che è grande per i test, una manna per la documentazione e un grande risparmio di tempo se si decide di porta.

Se questo è quello di analizzare le linee di comando consiglierei Commons Cli.

L'Apache Commons CLI biblioteca fornisce un'API per l'elaborazione di interfacce a riga di comando.

Provare JavaCC un generatore di parser per Java.

Ha un sacco di funzioni per l'interpretazione delle lingue, ed è ben supportato su Eclipse.

@CodingTheWheel Heres il vostro codice, un po ' di pulizia e attraverso eclipse (ctrl+shift+f) e inserito di nuovo qui :)

Tra i quattro spazi davanti a ogni riga.

public static boolean simpleNLP(String inputline, String keywords[]) {
    if (inputline.length() < 1)
        return false;

    List<String> lexed = new ArrayList<String>(); 
    for (String ele : inputline.split(" ")) {
        lexed.add(ele);
    }


    boolean status = false;
    to = 0;
    for (i = 0; i < lexed.size(); i++) {
        String s = (String) lexed.get(i);
        if (s.equalsIgnoreCase(keywords[to])) {
            to++;
            if (to >= keywords.length) {
                status = true;
                break;
            }
        }
    }
    return status;
}

Un semplice string tokenizer su spazi dovrebbe funzionare, ma ci sono davvero molti modi si può fare questo.

Qui è un esempio di utilizzo di un tokenizer:

String command = "kick person";
StringTokenizer tokens = new StringTokenizer(command);
String action = null;

if (tokens.hasMoreTokens()) {
    action = tokens.nextToken();
}

if (action != null) {
    doCommand(action, tokens);
}

Quindi i gettoni possono essere ulteriormente utilizzati per gli argomenti.Tutto questo assume alcuna spazi sono utilizzati negli argomenti...così si potrebbe desiderare per arrotolare analisi semplice meccanismo (come ottenere il primo spazio e utilizzo del testo prima dell'azione, o utilizzando un'espressione regolare, se non ti dispiace la velocità hit), solo astratto e fuori in modo che esso può essere utilizzato ovunque.

Quando il separatore di Stringa per il comando è sempre la stessa Stringa o char (come il ";") y consiglia di utilizzare il StrinkTokenizer classe:

StringTokenizer

ma quando il separatore varia o è complessa y consiglia di utilizzare le espressioni regolari, che potrà essere utilizzato dalla classe String stesso, il metodo split, dal 1.4.Si utilizza il Modello di classe java.util.regex pacchetto

Modello

Se la lingua è morto semplice come solo

VERBO SOSTANTIVO

quindi la divisione a mano funziona bene.

Se è più complesso, si dovrebbe davvero guardare in uno strumento come ANTLR o JavaCC.

Ho un tutorial su ANTLR (v2) a http://javadude.com/articles/antlrtut che vi darà un'idea di come funziona.

JCommander sembra abbastanza buona, anche se devo ancora testarlo.

Se il testo contiene alcune delimitatori quindi è possibile la vostra split metodo.
Se il testo contiene irregolare stringhe significa formato diverso in esso, allora è necessario utilizzare regular expressions.

metodo split può dividere una stringa in un array di sottostringa specificata espressione regex.I suoi argomenti in due forme, cioè:split (String regex) e split (String regex, int limit), che split (String regex) è in realtà chiamando split (String regex, int limite) al fine di conseguire, il limite è 0.Poi, quando il limite> 0 e limite <0 rappresenta cosa?

Quando il jdk ha spiegato:quando limite> 0 sub-array lunghezze fino al limite, che è, se possibile, può essere limite-1 sub-division, rimanendo come una sottostringa (tranne che con il limite di 1 volta il carattere di stringa split end);

limite <0 indica alcun limite alla lunghezza dell'array;

limite = 0 fine della stringa stringa vuota verrà troncato.StringTokenizer la classe è per ragioni di compatibilità, ed è conservato classe, così si dovrebbe provare a utilizzare il metodo split della classe String.fare riferimento a link

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top