DISABILITARE ADBLOCK

ADBlock sta bloccando alcuni contenuti del sito

ADBlock errore
risultati trovati: 

DOMANDA

Per analizzare i comandi del giocatore, ho usato spesso split metodo per dividere una stringa per delimitatori e poi per capire il resto con una serie di if s switch es. Quali sono alcuni modi diversi di analizzare le stringhe in Java?

SOLUZIONE

Presumo che tu stia cercando di rendere l'interfaccia di comando il più tollerante possibile. In questo caso, ti suggerisco di utilizzare un algoritmo simile a questo:

  1. Leggi nella stringa
    • Dividi la stringa in token
    • Utilizza un dizionario per convertire i sinonimi in un modulo comune
    • Ad esempio, converti " premi " ;, " punch " ;, " strike " ;, e " kick " tutto su " premi "
    • Esegui azioni su una base inclusiva non ordinata
    • Non ordinato - " dai un pugno alla scimmia in faccia " è la stessa cosa di " la faccia nel pugno di scimmia "
    • Incluso - Se si suppone che il comando sia " dai un pugno alla scimmia in faccia " e forniscono " punch monkey " ;, dovresti controllare quanti comandi corrisponde. Se solo un comando, esegui questa azione. Potrebbe anche essere una buona idea avere priorità di comando, e anche se ci fossero anche partite, eseguirà l'azione migliore.

Se ti va lasciaci una tua opinione

L'articolo ti è stato utile ed è tradotto correttamente?

ALTRI SUGGERIMENTI

Mi piacciono molto le espressioni regolari. Finché le stringhe di comando sono abbastanza semplici, puoi scrivere alcune regex che potrebbero richiedere alcune pagine di codice per analizzare manualmente.

Ti suggerirei di dare un'occhiata a http://www.regular-expressions.info per una buona introduzione alle regex, nonché esempi specifici per Java.

L'analisi manuale è molto divertente ... all'inizio :)

In pratica, se i comandi non sono molto sofisticati, puoi trattarli allo stesso modo di quelli utilizzati negli interpreti della riga di comando. C'è un elenco di librerie che puoi usare: http://java-source.net/open -source / riga di comando . Penso che puoi iniziare con CLI comuni di apache o args4j (usa le annotazioni). Sono ben documentati e molto semplici da usare. Gestiscono l'analisi automaticamente e l'unica cosa che devi fare è leggere determinati campi in un oggetto.

Se hai comandi più sofisticati, forse creare una grammatica formale sarebbe un'idea migliore. C'è una libreria molto buona con editor grafico, debugger e interprete per grammatiche. Si chiama ANTLR (e l'editor ANTLRWorks ) ed è gratuito :) Ci sono anche alcuni esempi di grammatiche ed esercitazioni.

Vorrei esaminare Migrazioni Java di Zork , e inclinati verso un semplice Natural Language Processor (guidato da tokenizzazione 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;
    }

...

Tutto ciò che dà a un programmatore un motivo per guardare di nuovo Zork è buono nel mio libro, stai attento a Grues.

...

Sun stesso consiglia di stare alla larga da StringTokenizer e di utilizzare invece il metodo String.split.

Dovrai anche guardare la classe Pattern.

Un altro voto per ANTLR / ANTLRWorks. Se crei due versioni del file, una con il codice Java per eseguire effettivamente i comandi e una senza (con solo la grammatica), hai una specifica eseguibile del linguaggio, che è ottima per i test, un vantaggio per la documentazione e un grande risparmio di tempo se decidi di portarlo.

Se questo è per analizzare le righe di comando, suggerirei di utilizzare Commons Cli .

  

La libreria CLI di Apache Commons fornisce un'API per l'elaborazione delle interfacce della riga di comando.

Prova JavaCC un generatore di parser per Java.

Ha molte funzioni per l'interpretazione delle lingue ed è ben supportato su Eclipse.

@CodingTheWheel Ecco il tuo codice, un po 'pulito e tramite eclissi ( ctrl + shift + f ) e inserito di nuovo qui: )

Compresi i quattro spazi davanti a ciascuna 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 tokenizer di stringa sugli spazi dovrebbe funzionare, ma ci sono davvero molti modi per farlo.

Ecco un esempio usando 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 token possono essere ulteriormente utilizzati per gli argomenti. Tutto questo presuppone che non vengano utilizzati spazi negli argomenti ... quindi potresti voler arrotolare il tuo semplice meccanismo di analisi (come ottenere il primo spazio bianco e usare prima il testo come azione, o usare un'espressione regolare se non ti dispiace il speed hit), basta estrarlo in modo che possa essere utilizzato ovunque.

Quando il separatore String per il comando è sempre lo stesso String o char (come " ;; ") y si consiglia di utilizzare la classe StrinkTokenizer:

StringTokenizer

ma quando il separatore varia o è complesso si consiglia di utilizzare le espressioni regolari, che possono essere utilizzate dalla classe String stessa, suddivisione del metodo, da 1.4. Utilizza la classe Pattern dal pacchetto java.util.regex

Pattern

Se la lingua è morta semplice come solo

VERB NOUN

quindi la divisione manuale funziona bene.

Se è più complesso, dovresti davvero cercare uno strumento come ANTLR o JavaCC.

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

JCommander sembra abbastanza buono, anche se devo ancora provarlo.

Se il testo contiene alcuni delimitatori, è possibile utilizzare il metodo split.
Se il testo contiene stringhe irregolari significa un formato diverso, allora devi usare regular expressions.

Il metodo

split può dividere una stringa in un array dell'espressione di sottostringa specificata regex. I suoi argomenti in due forme, vale a dire: split (String regex) e split (String regex, int limit), che split (StringTokenizer) è in realtà chiamando split (String regex, limite int) per raggiungere, limite è 0 . Quindi, quando il limite & Gt; 0 e limite & Lt; 0 rappresenta cosa?

Quando il jdk ha spiegato: quando limite > 0 lunghezze sub-array fino al limite, ovvero, se possibile, può essere limite-1 suddivisione, rimanendo come sottostringa (tranne per limite-1 volte che il carattere ha una stringa fine diviso);

limite < 0 indica nessun limite sulla lunghezza dell'array;

limite = 0 fine della stringa stringa vuota verrà troncata. La classe <=> è per motivi di compatibilità ed è conservata la classe legacy, quindi dovremmo provare a usare il metodo split della classe String. fare riferimento al link

Licensed under: CC-BY-SA with attribution
Not affiliated with StackOverflow