Coincidencia máxima para la Cadena

Question

Estoy tratando de escribir un método que me devuelva un código correspondiente a un producto bancario que debo pasar a un servicio web. Tengo una matriz de tipos genéricos de productos y la entrada será una cadena que será un tipo específico de cualquiera de los tipos genéricos en la matriz. Voy a explicar esto a través de un código que ya tengo:

public static void main(String[] args) 
{ 
    String[] names = { "Checking", "Savings", "DEMAT", "DEMAT Savings", "Interest Checking" }; 
    String input = "Employee Checking"; 
    int min = Integer.MAX_VALUE; 
    String maxMatch = null; 
    for(String name : names) 
    { 
     int i = input.indexOf(name); 
     if(i > -1 && i < min) 
     { 
     min = i; 
     maxMatch = name; 
     } 
    } 
    if(null != maxMatch) 
    { 
     System.out.println("Maximum match for " + input + " found at " + maxMatch); 
    } 
} 

El fragmento anterior trata de realizar un partido de máxima para la entrada. Por lo tanto, si tengo "Comprobación de intereses de los empleados" como entrada, obtengo una coincidencia en "Comprobación de intereses" y no solo "Comprobación".

Lo que quiero saber es si hay alguna manera de optimizar este fragmento más o hay algún caso en el que este código fallará?

Answer 1

Si se mantiene matriz ordenada por la longitud de la cadena, que puede estar seguro de que el primer partido daría el partido máximo

import java.util.Arrays; 
import java.util.Comparator; 

public class MaxIndex { 

private static String[] names = { "Checking", "Savings", "DEMAT", "DEMAT Savings", 
     "Interest Checking","Savings Interest Checking","My Employee Savings Interest Checking" }; 

public static void main(String[] args) { 

    Arrays.sort(names, new Comparator<String>() { 

     @Override 
     public int compare(String o1, String o2) { 
      Integer L1 = o1.length(); 
      return L1.compareTo(o2.length())*-1; 
     } 
    }); 

    findMaxMatch("Employee Checking"); 
    findMaxMatch("Employee Savings"); 
    findMaxMatch("Employee Interest Checking"); 
    findMaxMatch("Employee Savings Interest Checking"); 
    findMaxMatch("My Employee Savings Interest Checking"); 
    findMaxMatch("Employee Current"); 
} 

private static void findMaxMatch(String input) { 
    String maxMatch = maxMatch(input); 
    if (null != maxMatch) { 
     System.out.println("Maximum match for '" + input + "' found at '" 
       + maxMatch+"'"); 
    }else{ 
     System.out.println("No match for '"+input+"'"); 
    } 
} 

private static String maxMatch(String input) { 
    for (String name : names) { 
     int i = input.indexOf(name); 
     if (i > -1) { 
      return name; 
     } 
    } 
    return null; 
} 

}

salida

Maximum match for 'Employee Checking' found at 'Checking' 
Maximum match for 'Employee Savings' found at 'Savings' 
Maximum match for 'Employee Interest Checking' found at 'Interest Checking' 
Maximum match for 'Employee Savings Interest Checking' found at 'Savings Interest Checking' 
Maximum match for 'My Employee Savings Interest Checking' found at 'My Employee Savings Interest Checking' 
No match for 'Employee Current' 

Answer 2

Esto no funcionaría si la coincidencia máxima no estuviera en la primera parte de la cadena. Si, por ejemplo, su entrada fue Interest Checking For Employees coincidiría con Checking en lugar de Interest Checking. ¿Se supone que match max encuentre la cuenta con la mayoría de los caracteres secuenciales que coincidan? ¿O solo el partido más cercano al final de la entrada?

Answer 3

uso esto para encontrar la última posición

names.lastIndexOf(input) 

basado en posición de matriz, obtener el valor

Answer 4

Si entiendo bien su pregunta que desea buscar el partido más largo en el caso de que haya varios partidos. Una forma de hacerlo sería ordenar sus "nombres" en orden descendente (según su longitud) y detenerse en la primera coincidencia.

Usted puede hacer esto mediante el uso de un SortedMap < Integer, String> en el que se había puesto la longitud de cada "nombre" de sus "nombres" como su clave.

Por ejemplo, haciendo algo como esto:

SortedMap<Integer,String> map = new TreeMap<Integer, String>(new Comparator<Integer>() { 
    public int compare(Integer o1, Integer o2) { 
     return -o1.compareTo(o2); 
    } 
}); 
for (final String name: names) { 
    map.put(name.length(),name); 
} 

A continuación, iterar y dejar tan pronto como se entere el primer partido.

Es un poco "exagerado" pero funciona.

Answer 5

Si entiendo correctamente, la cadena encontrada siempre debe ser una subcadena de la consulta?

Usa para encontrar una subcadena, y si la encuentras, consérvala si es la más larga.

public static void main(String[] args) 
{ 
    String[] names = {"Checking", "Savings", "DEMAT", "DEMAT Savings", "Interest Checking"}; 
    String input = "Employee Interest Checking"; 
    int min = Integer.MIN_VALUE; 
    String maxMatch = null; 
    for (String name : names) 
    { 
     boolean has = input.contains(name); 
     if (has && min < name.length()) 
     { 
      min = name.length(); 
      maxMatch = name; 
     } 
    } 
    if (null != maxMatch) 
    { 
     System.out.println("Maximum match for " + input + " found at " + maxMatch); 
    } 
} 

y al igual que user988052 dicho; si ordena la matriz de la manera correcta, puede detenerse en la primera coincidencia para no tener que seguir buscando y puede eliminar min.

pedidos la matriz descendente por longitud:

Arrays.sort(names, new Comparator<String>() 
    { 
     public int compare(String o1, String o2) 
     { 
      int d = o2.length() - o1.length(); 
      return d != 0? d : ((Comparable<String>)o1).compareTo(o2); 
     } 
    });