una ¿Cuáles son los diferentes métodos para analizar cadenas en Java?




manejo de cadenas en java (12)

Sun recomienda mantenerse alejado de StringTokenizer y usar el método String.spilt.

También querrás mirar la clase Pattern.

Para analizar comandos de jugador, he usado con mayor frecuencia el método de división para dividir una cadena por delimitadores y luego, para luego averiguar el resto por una serie de s o switch es. ¿Cuáles son algunas formas diferentes de analizar cadenas en Java?


Realmente me gustan las expresiones regulares. Siempre que las cadenas de comandos sean bastante simples, puede escribir algunas expresiones regulares que podrían tomar algunas páginas de código para analizarlas manualmente.

Le sugiero que consulte http://www.regular-expressions.info para obtener una buena introducción a expresiones regulares, así como ejemplos específicos para Java.


Pruebe JavaCC un generador de analizadores para Java.

Tiene muchas funciones para interpretar idiomas y está bien soportado en Eclipse.


Si esto es para analizar las líneas de comando, sugeriría usar Commons Cli .

La biblioteca CLI de Apache Commons proporciona una API para procesar interfaces de línea de comando.


Otro voto para ANTLR / ANTLRWorks. Si crea dos versiones del archivo, una con el código Java para ejecutar realmente los comandos y otra sin (con solo la gramática), entonces tiene una especificación ejecutable del lenguaje, que es ideal para probar, una gran ayuda para la documentación , y un gran ahorro de tiempo si alguna vez decide portarlo.


Supongo que estás tratando de hacer que la interfaz de comando sea tan indulgente como sea posible. Si este es el caso, sugiero que use un algoritmo similar a este:

  1. Leer en la cadena
    • Divide la cadena en tokens
    • Use un diccionario para convertir sinónimos a una forma común
    • Por ejemplo, convierta "golpe", "golpe", "golpe" y "patada" para "golpear"
    • Realizar acciones en una base desordenada e inclusiva
    • Desordenado - "golpear al mono en la cara" es lo mismo que "la cara en el golpe de mono"
    • Inclusive : si se supone que el comando debe ser "golpear al mono en la cara" y le proporcionan "mono punch", debe verificar cuántos comandos concuerda. Si solo un comando, haz esta acción. Incluso podría ser una buena idea tener prioridades de comando, e incluso si hubiera incluso coincidencias, realizaría la acción superior.

@CodingTheWheel Aquí está tu código, un poco de limpieza y eclipse ( ctrl + shift + f ) y el insertado aquí :)

Incluyendo los cuatro espacios al frente de cada línea.

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;
}

Si su texto contiene algunos delimitadores, entonces puede split su método de split .
Si el texto contiene cadenas irregulares significa que tiene un formato diferente, entonces debe usar regular expressions .


Un tokenizador de cadena simple en espacios debería funcionar, pero hay muchas maneras en que podrías hacer esto.

Aquí hay un ejemplo 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);
}

Entonces los tokens se pueden usar para los argumentos. Todo esto supone que no se utilizan espacios en los argumentos ... por lo que es posible que desee desplegar su propio mecanismo de análisis simple (como obtener el primer espacio en blanco y usar texto antes como acción, o usar una expresión regular si no le importa el golpe de velocidad), simplemente resúmalo para que pueda usarse en cualquier lugar.


Si el lenguaje es tan simple como simplemente

SUSTANTIVO VERBO

luego, dividir a mano funciona bien.

Si es más complejo, deberías buscar una herramienta como ANTLR o JavaCC.

Tengo un tutorial sobre ANTLR (v2) en http://javadude.com/articles/antlrtut que le dará una idea de cómo funciona.


JCommander parece bastante bueno, aunque todavía tengo que probarlo.


El análisis manual es muy divertido ... al principio :)

En la práctica, si los comandos no son muy sofisticados, puede tratarlos del mismo modo que los utilizados en los intérpretes de línea de comando. Hay una lista de bibliotecas que puede usar: http://java-source.net/open-source/command-line . Creo que puede comenzar con Apache commons CLI o args4j (usa anotaciones). Están bien documentados y son realmente simples de usar. Manejan el análisis automáticamente y lo único que debe hacer es leer campos particulares en un objeto.

Si tiene comandos más sofisticados, entonces quizás crear una gramática formal sería una mejor idea. Hay una biblioteca muy buena con editor gráfico, depurador e intérprete para gramáticas. Se llama ANTLR (y el editor ANTLRWorks ) y es gratis :) También hay algunos ejemplos de gramáticas y tutoriales.





parsing