una - manejo de cadenas en java




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

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?


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

Cuando el separador String para el comando es siempre el mismo String o char (como el ";"), le recomendamos que use la clase StrinkTokenizer:

StringTokenizer

pero cuando el separador varía o es complejo, te recomiendo que uses las expresiones regulares, que pueden ser usadas por la clase String misma, método dividido, desde 1.4. Utiliza la clase Pattern del paquete java.util.regex

Pattern


El método de división puede dividir una cadena en una matriz de la expresión específica de subcadena regex . Sus argumentos en dos formas, a saber: split ( String regex ) y split ( String regex, int limit ), que split ( String regex ) es en realidad llamando split (String regex, int limit) para lograr, limit es 0 . Entonces, cuando el límite> 0 y el límite <0 representa qué?

Cuando el jdk explicó: cuando límite> 0 subejuntas longitudes hasta límite, es decir, si es posible, puede ser límite-1 subdivisión, quedando como una subcadena (excepto por límite-1 veces que el carácter tiene extremo dividido) ;

límite <0 indica que no hay límite en la longitud de la matriz;

limit = 0 final de la cadena cadena vacía se truncará. StringTokenizer clase StringTokenizer es por razones de compatibilidad y se conserva la clase heredada, por lo que deberíamos intentar usar el método de división de la clase String. consulte el link


Miraría las migraciones de Java de Zork y me inclinaría hacia un procesador de lenguaje natural simple (dirigido por tokenización o expresión regular) como el siguiente (desde este enlace):

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

...

Todo lo que le da al programador un motivo para volver a mirar a Zork es bueno en mi libro, solo ten cuidado con Grues.

...


Pruebe JavaCC un generador de analizadores para Java.

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


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.


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.


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 .


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.

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.





parsing