Java obtener String CompareTo como objeto de comparación

Question

Me gustaría ordenar y buscar binaria una matriz estática de cadenas a través del comparador String.CompareTo.

El problema es que tanto la ordenación como la búsqueda binaria requieren que se pase un objeto Comparator. Entonces, ¿cómo paso el comparador de cadenas incorporado?

Answer 1

La clase Arrays tiene versiones de sort()binarySearch() y que no requieren un Comparator. Por ejemplo, puede utilizar the version of Arrays.sort() which just takes an array of objects. Estos métodos llaman al método compareTo() de los objetos en la matriz.

Answer 2

puede escribir su propio comparador

public class ExampleComparator implements Comparator<String> { 
    public int compare(String obj1, String obj2) { 
    if (obj1 == null) { 
     return -1; 
    } 
    if (obj2 == null) { 
     return 1; 
    } 
    if (obj1.equals(obj2)) { 
     return 0; 
    } 
    return obj1.compareTo(obj2); 
    } 
} 

Answer 3

Si usted encuentra yourslef necesidad de un Comparator, y ya utilizar Guava, puede utilizar Ordering.natural().

Answer 4

Este es un genérico Comparator para cualquier tipo de Comparable objeto, no sólo String:

package util; 

import java.util.Comparator; 

/** 
* The Default Comparator for classes implementing Comparable. 
* 
* @param <E> the type of the comparable objects. 
* 
* @author Michael Belivanakis (michael.gr) 
*/ 
public final class DefaultComparator<E extends Comparable<E>> implements Comparator<E> 
{ 
    @SuppressWarnings("rawtypes") 
    private static final DefaultComparator<?> INSTANCE = new DefaultComparator(); 

    /** 
    * Get an instance of DefaultComparator for any type of Comparable. 
    * 
    * @param <T> the type of Comparable of interest. 
    * 
    * @return an instance of DefaultComparator for comparing instances of the requested type. 
    */ 
    public static <T extends Comparable<T>> Comparator<T> getInstance() 
    { 
     @SuppressWarnings("unchecked") 
     Comparator<T> result = (Comparator<T>)INSTANCE; 
     return result; 
    } 

    private DefaultComparator() 
    { 
    } 

    @Override 
    public int compare(E o1, E o2) 
    { 
     if(o1 == o2) 
      return 0; 
     if(o1 == null) 
      return 1; 
     if(o2 == null) 
      return -1; 
     return o1.compareTo(o2); 
    } 
} 

Cómo utilizar con String:

Comparator<String> stringComparator = DefaultComparator.getInstance(); 

Answer 5

También, si quieres comparación entre mayúsculas y minúsculas, en versiones recientes de Java, la clase String contiene un campo public static final llamado CASE_INSENSITIVE_ORDER que es del tipo Comparator<String>, como acabo de descubrir recientemente. Por lo tanto, puede hacer su trabajo usando String.CASE_INSENSITIVE_ORDER.

Answer 6

De nuevo, no necesita el comparador para Arrays.binarySearch(Object[] a, Object key), siempre y cuando los tipos de objetos sean comparables, pero con las expresiones lambda esto es mucho más fácil.

Sólo tiene que sustituir el comparador con la referencia al método: String::compareTo

Ej:

Arrays.binarySearch(someStringArray, "The String to find.", String::compareTo); 

También es posible usar

Arrays.binarySearch(someStringArray, "The String to find.", (a,b) -> a.compareTo(b)); 

pero incluso antes de lambdas, siempre hubo clases anónimas:

Arrays.binarySearch(
       someStringArray, 
       "The String to find.", 
       new Comparator<String>() { 
        @Override 
        public int compare(String o1, String o2) { 
         return o1.compareTo(o2); 
        } 
       }); 

Answer 7

Podemos usar el comparador String.CASE_INSENSITIVE_ORDER para comparar las cadenas en caso de que el orden no sea sensible.

Arrays.binarySearch(someStringArray, "The String to find.",String.CASE_INSENSITIVE_ORDER); 

Answer 8

Solución para Java basado en 8 java.util.Comparator.comparing(...):

Comparator<String> c = Comparator.comparing(String::toString); 

o

Comparator<String> c = Comparator.comparing((String x) -> x); 

Answer 9

Respecto de answer había un error Nambari.Si se comparan los valores utilizando el doble signo igual programa == nunca alcanzarán método de comparación, a menos que alguien va a utilizar nueva palabra clave para crear el objeto de cadena que no es la mejor práctica. Esta podría ser una solución un poco mejor:

public int compare(String o1, String o2) { 
     if (o1 == null && o2 == null){return 0;} 
     if (o1 == null) { return -1;} 
     if (o2 == null) { return 1;} 
     return o1.compareTo(o2); 
    } 

P.S. Gracias por los comentarios;)

Answer 10

generalizar el buena respuesta de Mike Nakis con String.CASE_INSENSITIVE_ORDER, también se puede utilizar:

Collator.getInstance(); 

Ver Collator

Answer 11

Muy bien, este es un par de años más tarde, pero con Java 8 se puede utilizar Comparator.naturalOrder():

http://docs.oracle.com/javase/8/docs/api/java/util/Comparator.html#naturalOrder--

De javadoc:

static <T extends Comparable<? super T>> Comparator<T> naturalOrder() 

Devuelve un comparador que compara objetos comparables en el orden natural. El comparador devuelto es serializable y arroja NullPointerException al comparar null.