Comparable
Comparable es la interfaz de clasificación.
Si una clase implementa la interfaz comparable, significa "esta clase admite la clasificación". Dado que las clases que implementan la clasificación de la interfaz comparable, suponiendo que ahora hay una "lista de listas (o matriz) de objetos de clases que implementan una interfaz comparable", la lista de listas (o matriz) puede clasificarse mediante colección.sort (o arrays.sort).
Además, el "objeto de la clase que implementa la interfaz comparable" puede usarse como una clave en un "mapa ordenado (como Treemap)" o un elemento en un "conjunto ordenado (TreeSet)" sin especificar un comparador.
La interfaz comparable solo incluye una función, y su definición es la siguiente:
paquete java.lang; import java.util.*; interfaz pública comparable <t> {public int compareto (t o);} Descripción: Supongamos que "comparamos los tamaños de X e Y" a través de X.compareto (y). Si devuelve un "número negativo", significa que "x es más pequeño que y"; Si devuelve un "cero", significa que "x es igual a y"; Si devuelve un "número positivo", significa que "x es mayor que y".
La interfaz comparable ha sido genérica, por lo que el objeto que implementa declara con qué tipo se puede comparar. (Generalmente, este es el tipo de objeto en sí, pero a veces también puede ser una clase padre).
interfaz pública comparable {comparación pública booleana (t otra); }
Por lo tanto, la interfaz comparable contiene un parámetro T de tipo, que es el tipo de objeto que una clase que implementa comparable puede compararse. Esto significa que si define una clase que implementa comparable, como la cadena, debe declarar no solo la clase admite la comparación, sino también a qué puede compararse (generalmente con sí misma):
La cadena de clase pública implementa comparables {...}
Ahora consideremos la implementación de un método binario max (). Desea aceptar dos parámetros del mismo tipo, ambos son comparables y son comparables entre sí. Afortunadamente, esto es bastante intuitivo si usa métodos genéricos y parámetros de tipo restringido:
public static> t max (t t1, t t2) {if (t1.compareto (t2)> 0) return t1; de lo contrario regresar T2; }
En este ejemplo, define un método genérico que se genera en el tipo T, y restringe la extensión de tipo (implementación) comparable. Ambos parámetros deben ser de tipo T, lo que significa que son del mismo tipo, comparación de soporte y son comparables entre sí. ¡fácil!
Aún mejor, el compilador utilizará el razonamiento de tipo para determinar cuál significa el valor de t cuando se llama a max (). Por lo tanto, no hay necesidad de especificar T en absoluto, la siguiente llamada funcionará:
Cadena s = max ("moo", "corteza");El compilador calculará que el valor predeterminado de t es una cadena, por lo que realizará compilación y comprobación de tipo. Pero si intenta llamar a Max () con argumentos a la Clase X que no se implementa comparable, el compilador no lo permitirá.
Comparador
El comparador es la interfaz de comparación.
Si necesitamos controlar el orden de una determinada clase, que en sí misma no admite la clasificación (es decir, no implementa la interfaz comparable); Entonces podemos establecer un "comparador de esta clase" para clasificar. Este "comparador" solo necesita implementar la interfaz de comparación.
Es decir, podemos crear un nuevo comparador "implementando la clase de comparación" y luego ordenar la clase a través del comparador.
La interfaz de comparación solo incluye dos funciones, y su definición es la siguiente:
paquete java.util; comparador de interfaz pública <t> {int compare (t o1, t o2); boolean iguales (objeto obj);} ilustrar:
1. Si una clase quiere implementar la interfaz de comparación: debe implementar la función Compareto (T O1, T O2), pero puede no implementar la función igual (Obj OBJ).
¿Por qué no podemos implementar la función igual (obj obj)? Porque de forma predeterminada, se ha implementado igual (obj obj). Todas las clases en Java se heredan de java.lang.object, y la función igual (obj obj) se implementa en object.java; Por lo tanto, todas las demás clases son equivalentes a implementar esta función.
2.Tint Compare (T O1, T O2) es "Compare los tamaños de O1 y O2". Regresar "número negativo" significa "O1 es más pequeño que O2"; devolver "cero", que significa "O1 es igual a O2"; devolver "número positivo" significa "O1 es mayor que O2".
Comparador y comparable
Comparable es una interfaz de clasificación; Si una clase implementa una interfaz comparable, significa "esta clase admite la clasificación".
El comparador es un comparador; Si necesitamos controlar el orden de una determinada clase, podemos establecer un "comparador de esta clase" para ordenarlo.
No es difícil encontrar que comparable sea equivalente a un "comparador interno", mientras que el comparador es equivalente a un "comparador externo".
Utilizamos un programa de prueba para ilustrar estas dos interfaces. El código fuente es el siguiente:
import java.util.*; import java.lang.comparable;/*** @Desc Programa de comparación entre "Comparador" y "Comparable". * (01) "Comparable" * Es una interfaz de clasificación que contiene solo una función comparación (). * Una clase implementa la interfaz comparable, que significa "la clase en sí admite la clasificación", que se puede ordenar directamente a través de matricess.sort () o colección.sort (). * (02) "Comparador" * Es una interfaz de comparación, que incluye dos funciones: compare () y igual (). * Una clase implementa la interfaz de comparación, luego es un "comparador". Otras clases se pueden clasificar de acuerdo con el comparador. * * Para resumir: comparable es un comparador interno, mientras que el comparador es un comparador externo. * Una clase en sí implementa un comparador comparable, lo que significa que admite la clasificación; Si no se implementa comparable en sí mismo, también se puede clasificar a través del comparador de comparación externo. */public class CompareComParatorAndComParableTest {public static void main (string [] args) {// crea una nueva arrayList (array dynamic) arrayList <Oll> list = new ArrayList <Oll> (); // Agregar un objeto a ArrayList list.add (nueva persona ("CCC", 20)); list.add (nueva persona ("AAA", 30)); list.add (nueva persona ("BBB", 10)); list.add (nueva persona ("DDD", 40)); // Imprima la secuencia original de la lista System.out.printf ("Origen original, lista:%s/n", lista); // Ordenar la lista // aquí se ordenará de acuerdo con la "interfaz <string> comparable implementada por persona", es decir, ordenada de acuerdo con "nombre", colección.sort (lista); System.out.printf ("Nombre, lista, lista:%s/n", lista); // Ordenar la lista a través de "Comparador (AscAgecomparator)" // El método de clasificación de Ascagecomparator es: Ordenado de acuerdo con el orden ascendente de colección "Age". System.out.printf ("ASC (Age) Sort, Lista:%s/n", lista); // Ordenar la lista a través de "Comparador (DescageComparator)". // El método de clasificación de DescageComparator es: Ordena de acuerdo con el orden descendente de la colección "Age". System.out.printf ("Desc (edad) sort, lista:%s/n", lista); // Determinar si las dos personas son iguales testEquals (); } /*** @Desc prueba si las dos personas son iguales. * Dado que la persona implementa la función igual (): si la edad y el nombre de las dos personas son iguales, las dos personas se consideran iguales. * Entonces, aquí P1 y P2 son iguales. * * TODO: Si se elimina la función igual () en persona, entonces p1 no es igual a p2 */ private static testEquals () {persona p1 = nueva persona ("eee", 100); Persona p2 = nueva persona ("eee", 100); if (p1.equals (p2)) {system.out.printf (" %s igual %s/n", p1, p2); } else {System.out.printf (" %s no igual %s/n", p1, p2); }} /*** @Desc Class de persona. * La persona implementa la interfaz comparable, lo que significa que la persona misma es compatible con la clasificación*/ de clase estática privada implementa comparable <persona> {int Age; Nombre de cadena; Persona pública (nombre de cadena, int Age) {this.name = name; this.age = edad; } public String getName () {nombre de retorno; } public int getAge () {return Age; } public String toString () {Nombre de retorno + " -" + edad; } / *** Compare si dos personas son iguales: si su nombre y edad son iguales, se consideran iguales* / boolean iguales (persona persona) {if (this.age == Person.age && this.name == Person.name) return true; devolver falso; } /*** @Desc Implementa la interfaz de "Comparable <String>", es decir, reescribir la función comparación <t t>. * Aquí hay una comparación por "nombre de persona"*/ @Override public int Compareto (persona persona) {return name.compareto (persona.name); // devuelve this.name - Person.name; }} / *** @Desc AscagecomParator Comparator* Es "comparador ascendente de la edad de la persona"* / clase estática privada ascagecomparator implementa el comparador <Oll> {@Override public int Compare (persona p1, persona p2) {return p1.getage () - p2.getage (); }} / *** @Desc Descagecomparator Comparator* Es "comparador ascendente de la edad de la persona"* / clase privada estática Descagecomparator implementa el comparador <Oll> {@Override public int Compare (Person P1, Person P2) {return P2.getage () - p1.getage (); }}} La siguiente es una explicación de este programa.
1. Definición de clase personal. como sigue:
La persona de clase estática privada implementa comparable <Oll> {int Age; Nombre de cadena; ... /*** @Desc implementa la interfaz de "comparable <string>", es decir, anular la función comparación <t t>. * Aquí hay una comparación por "nombre de persona"*/ @Override public int Compareto (persona persona) {return name.compareto (persona.name); // devuelve this.name - Person.name; }} ilustrar:
(1) La clase persona representa a una persona. Hay dos atributos en la clase Persong: edad (edad) y el nombre "nombre de la persona".
(2) La clase de persona implementa la interfaz comparable, por lo que se puede ordenar.
2. En Main (), creamos la matriz de la lista de personas (lista). como sigue:
// Create a new ArrayList(dynamic array)ArrayList<Person> list = new ArrayList<Person>();// Add an object to ArrayList list.add(new Person("ccc", 20));list.add(new Person("AAA", 30));list.add(new Person("bbb", 10));list.add(new Person("ddd", 40)); 3. A continuación, imprimimos todos los elementos de la lista. como sigue:
// Imprima la secuencia original de List System.out.printf ("Origen original, lista:%s/n", lista); 4. Entonces, ordenamos la lista a través de la función sort () de las colecciones.
Dado que la persona implementa la interfaz comparable, al clasificar a través de sort (), se ordenará de acuerdo con el método de clasificación respaldado por la persona, es decir, las reglas definidas por comparación (persona persona). como sigue:
// Ordenar la lista // Aquí ordenaremos de acuerdo con la "interfaz <string> comparable implementada por persona", es decir, clasificar según "nombre" colección.sort (lista); System.out.printf ("Nombre, lista, lista:%s/n", lista); 5. Comparable y comparador
Definimos dos comparadores, Ascagecomparator y Descagecomparator, para ascender y persona de orden inferior, respectivamente.
6. Comparador de Casaspárador: clasifica a la persona en orden ascendente por edad. El código es el siguiente:
/*** @Desc AscagecomParator Comparator* Es "comparador ascendente de la edad de la persona"*/clase estática privada Ascagecomparator implementa comparador <Oll> {@Override public int Compare (Person P1, Person P2) {return p1.getage () - p2.getage (); }} 7. Comparador de DescageComparator: clasifica a la persona en orden descendente por edad. El código es el siguiente:
/*** @Desc DescageComparator Comparator* Es "comparador ascendente de la edad de la persona"*/clase estática privada DescageComparator implementa comparador <Oll> {@Override public int Compare (Person P1, Person P2) {return P2.getage () - p1.getage (); }} 8. Ejecute el programa Como resultado, la salida es la siguiente:
Ordenar original, lista: [CCC - 20, AAA - 30, BBB - 10, DDD - 40] Nombre, Lista: [AAA - 30, BBB - 10, CCC - 20, DDD - 40] ASC (Age) Sort, Lista: [BBB - 10, CCC - 20, AAA - 30, DDD - 40] - 20, BBB - 10] EEE - 100 iguales a EEE - 100