example - Java obtiene String CompareTo como un objeto de comparación

implements comparator java

Question

Me gustaría ordenar y buscar binaria una matriz estática de cadenas mediante el 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 integrado?

Answer 1

Además, si desea una comparación insensible a las mayúsculas y minúsculas, en las versiones recientes de Java, la clase String contiene un campo public static final llamado CASE_INSENSITIVE_ORDER que es del tipo Comparator<String> , como descubrí hace poco. Por lo tanto, puede hacer su trabajo usando String.CASE_INSENSITIVE_ORDER .

Answer 2

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

Simplemente reemplace el comparador con la referencia del método: String::compareTo

P.ej:

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

También podrías usar

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

pero incluso antes de lambdas, siempre había 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 3

En cuanto a la answer de Nambari, hubo un error. Si compara valores utilizando el signo doble ==, el programa nunca alcanzará el método de comparación, a menos que alguien use una palabra clave nueva para crear un objeto String que no sea 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);
    }

PD Gracias por sus comentarios;)

Answer 4

Este es un Comparator genérico para cualquier tipo de objeto Comparable , no solo 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 usar con String :

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

Answer 5

Ok, esto es unos años más tarde, pero con java 8 puedes usar 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 orden natural. El comparador devuelto es serializable y arroja NullPointerException al comparar null.

Answer 6

Para generalizar la buena respuesta de Mike Nakis con String.CASE_INSENSITIVE_ORDER , también puede usar:

Collator.getInstance();

Ver Collator

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

Puede escribir su propio comparador

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

Answer 9

Si encuentra que usted necesita un Comparator y ya usa Guava , puede utilizar Ordering.natural() .

Answer 10

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

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

o

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

Answer 11

La clase Arrays tiene versiones de sort() y binarySearch() que no requieren un Comparator. Por ejemplo, puede usar la versión de Arrays.sort() que solo toma una matriz de objetos . Estos métodos llaman al compareTo() de los objetos en la matriz.