Saltar al contenido

Comparador de Java – javatpoint

septiembre 29, 2021

Clase de colecciones

Colecciones La clase proporciona métodos estáticos para ordenar los elementos de una colección. Si los elementos de la colección son de Set o Map, podemos usar TreeSet o TreeMap. Sin embargo, no podemos ordenar los elementos de List. La clase Colecciones también proporciona métodos para clasificar los elementos de los elementos de tipo Lista.

Método de la clase Colecciones para ordenar los elementos de la lista

ordenación de vacíos públicos (Lista de lista, Comparador c): se utiliza para ordenar los elementos de la Lista por el Comparador dado.


Ejemplo de comparador de Java (estilo antiguo no genérico)

Veamos el ejemplo de ordenar los elementos de la Lista según la edad y el nombre. En este ejemplo, hemos creado 4 clases de Java:

  1. Student.java
  2. AgeComparator.java
  3. NameComparator.java
  4. Simple.java

Student.java

Esta clase contiene tres campos rollno, name y age y un constructor parametrizado.

clase Student {int rollno; Nombre de cadena; int age; Estudiante (int rollno, String name, int age) {this.rollno = rollno; this.name = nombre; this.age = edad; }}

AgeComparator.java

Esta clase define la lógica de comparación basada en la edad. Si la edad del primer objeto es mayor que la del segundo, estamos devolviendo un valor positivo. Puede ser cualquiera, como 1, 2, 10. Si la edad del primer objeto es menor que la del segundo, estamos devolviendo un valor negativo, puede ser cualquier valor negativo, y si la edad de ambos objetos es igual, estamos devolviendo 0.

importar java.util. *; class AgeComparator implementa Comparator {public int compare (Object o1, Object o2) {Student s1 = (Student) o1; Estudiante s2 = (Estudiante) o2; if (s1.age == s2.age) return 0; else if (s1.age> s2.age) return 1; si no devuelve -1; }}

NameComparator.java

Esta clase proporciona lógica de comparación basada en el nombre. En tal caso, estamos usando el método compareTo () de la clase String, que proporciona internamente la lógica de comparación.

importar java.util. *; class NameComparator implementa Comparator {public int compare (Object o1, Object o2) {Student s1 = (Student) o1; Estudiante s2 = (Estudiante) o2; return s1.name.compareTo (s2.name); }}

Simple.java

En esta clase, imprimimos los valores del objeto clasificándolos según el nombre y la edad.

importar java.util. *; importar java.io. *; class Simple {public static void main (String args[]) {ArrayList al = new ArrayList (); al.add (nuevo estudiante (101, «Vijay», 23)); al.add (nuevo estudiante (106, «Ajay», 27)); al.add (nuevo estudiante (105, «Jai», 21)); System.out.println («Clasificación por nombre»); Collections.sort (al, new NameComparator ()); Iterador itr = al.iterator (); while (itr.hasNext ()) {Student st = (Student) itr.next (); System.out.println (st.rollno + «» + st.name + «» + st.age); } System.out.println («Clasificación por edad»); Collections.sort (al, new AgeComparator ()); Iterador itr2 = al.iterator (); while (itr2.hasNext ()) {Student st = (Student) itr2.next (); System.out.println (st.rollno + «» + st.name + «» + st.age); }}}

       Sorting by Name
       106 Ajay 27
       105 Jai 21
       101 Vijay 23
       
       Sorting by age       
       105 Jai 21
       101 Vijay 23
       106 Ajay 27

Ejemplo de comparador de Java (genérico)

Student.java

clase Student {int rollno; Nombre de cadena; int age; Estudiante (int rollno, String name, int age) {this.rollno = rollno; this.name = nombre; this.age = edad; }}

AgeComparator.java

importar java.util. *; clase AgeComparator implementa Comparator{public int compare (Student s1, Student s2) {if (s1.age == s2.age) return 0; else if (s1.age> s2.age) return 1; si no devuelve -1; }}

NameComparator.java

Esta clase proporciona lógica de comparación basada en el nombre. En tal caso, estamos usando el método compareTo () de la clase String, que proporciona internamente la lógica de comparación.

importar java.util. *; class NameComparator implementa Comparator{public int compare (Student s1, Student s2) {return s1.name.compareTo (s2.name); }}

Simple.java

En esta clase, imprimimos los valores del objeto clasificándolos según el nombre y la edad.

importar java.util. *; importar java.io. *; class Simple {public static void main (String args[]){ Lista de arreglo al = new ArrayList(); al.add (nuevo estudiante (101, «Vijay», 23)); al.add (nuevo estudiante (106, «Ajay», 27)); al.add (nuevo estudiante (105, «Jai», 21)); System.out.println («Clasificación por nombre»); Collections.sort (al, new NameComparator ()); for (Student st: al) {System.out.println (st.rollno + «» + st.name + «» + st.age); } System.out.println («Clasificación por edad»); Collections.sort (al, new AgeComparator ()); for (Student st: al) {System.out.println (st.rollno + «» + st.name + «» + st.age); }}}

       Sorting by Name
       106 Ajay 27
       105 Jai 21
       101 Vijay 23

       Sorting by age     
       105 Jai 21
       101 Vijay 23
       106 Ajay 27

Interfaz del comparador Java 8

La interfaz Java 8 Comparator es una interfaz funcional que contiene solo un método abstracto. Ahora, podemos usar la interfaz Comparator como destino de asignación para una expresión lambda o referencia de método.

Métodos de la interfaz de comparación de Java 8

Método Descripción
int comparar (T o1, T o2) Compara el primer objeto con el segundo objeto.
estático > Comparador comparando (Función super T ,? extiende U> keyExtractor) Acepta una función que extrae una clave de clasificación comparable de un tipo T y devuelve un comparador que se compara por esa clave de clasificación.
estática Comparador comparando (Función super T ,? extiende U> keyExtractor, Comparator super U> keyComparator) Acepta una función que extrae una clave de clasificación de un tipo T y devuelve un Comparador que compara por esa clave de clasificación usando el Comparador especificado.
estático Comparator comparingDouble (ToDoubleFunction super T> keyExtractor) Acepta una función que extrae una clave de clasificación doble de un tipo T y devuelve un Comparador que se compara por esa clave de clasificación.
static Comparator comparingInt (ToIntFunction super T> keyExtractor) Acepta una función que extrae una clave de clasificación int de un tipo T y devuelve un Comparador que se compara por esa clave de clasificación.
static Comparator comparingLong (ToLongFunction super T> keyExtractor) Acepta una función que extrae una clave de ordenación larga de un tipo T y devuelve un Comparador que se compara por esa clave de clasificación.
booleano es igual a (Objeto obj) Se utiliza para comparar el objeto actual con el objeto especificado.
estático > Comparador naturalOrder () Devuelve un comparador que compara objetos comparables en orden natural.
static Comparator nullsFirst (Comparador super T> comparador) Devuelve un comparador que considera que los nulos son menores que los elementos no nulos.
static Comparator nullsLast (Comparator super T> comparator) Devuelve un comparador que considera que el valor nulo es mayor que los elementos no nulos.
Comparador predeterminado invertido () Devuelve un comparador que contiene el orden inverso del comparador proporcionado.
estático > Comparador reverseOrder () Devuelve un comparador que contiene el orden inverso al natural.
Comparador predeterminado luego Comparando (Comparador super T> otro) Devuelve un comparador de orden lexicográfico con otro comparador.
predeterminado > Comparador luegoComparing (Función super T ,? extiende U> keyExtractor) Devuelve un comparador de orden lexicográfico con una función que extrae una clave de clasificación Comparable.
predeterminado Comparator thenComparing (Función super T ,? extiende U> keyExtractor, Comparator super U> keyComparator) Devuelve un comparador de orden lexicográfico con una función que extrae una clave para compararla con el Comparador dado.
Comparador predeterminado luegoComparingDouble (ToDoubleFunction super T> keyExtractor) Devuelve un comparador de orden lexicográfico con una función que extrae una clave de clasificación doble.
Comparador predeterminado thenComparingInt (ToIntFunction super T> keyExtractor) Devuelve un comparador de orden lexicográfico con una función que extrae una clave de ordenación int.
Comparador predeterminado thenComparingLong (ToLongFunction super T> keyExtractor) Devuelve un comparador de orden lexicográfico con una función que extrae una clave de ordenación larga.

Ejemplo de comparador de Java 8

Veamos el ejemplo de ordenar los elementos de la Lista según la edad y el nombre.

Archivo: Student.java

clase Student {int rollno; Nombre de cadena; int age; Estudiante (int rollno, String name, int age) {this.rollno = rollno; this.name = nombre; this.age = edad; } public int getRollno () {return rollno; } public void setRollno (int rollno) {this.rollno = rollno; } public String getName () {nombre de retorno; } public void setName (nombre de cadena) {this.name = nombre; } public int getAge () {edad de retorno; } public void setAge (int edad) {this.age = edad; }}

Archivo: TestSort1.java

importar java.util. *; public class TestSort1 {public static void main (String args[]){ Lista de arreglo al = new ArrayList(); al.add (nuevo estudiante (101, «Vijay», 23)); al.add (nuevo estudiante (106, «Ajay», 27)); al.add (nuevo estudiante (105, «Jai», 21)); // Clasificación de elementos según el comparador de nombres cm1 = Comparator.comparing (Student :: getName); Collections.sort (al, cm1); System.out.println («Clasificación por nombre»); for (Student st: al) {System.out.println (st.rollno + «» + st.name + «» + st.age); } // Clasificación de elementos según el comparador de edad cm2 = Comparator.comparing (Student :: getAge); Collections.sort (al, cm2); System.out.println («Clasificación por edad»); for (Student st: al) {System.out.println (st.rollno + «» + st.name + «» + st.age); }}}

Sorting by Name
106 Ajay 27
105 Jai 21
101 Vijay 23
Sorting by Age
105 Jai 21
101 Vijay 23
106 Ajay 27

Ejemplo de comparador de Java 8: método nullsFirst () y nullsLast ()

Aquí, ordenamos la lista de elementos que también contiene null.

Archivo: Student.java

clase Student {int rollno; Nombre de cadena; int age; Estudiante (int rollno, String name, int age) {this.rollno = rollno; this.name = nombre; this.age = edad; } public int getRollno () {return rollno; } public void setRollno (int rollno) {this.rollno = rollno; } public String getName () {nombre de retorno; } public void setName (nombre de cadena) {this.name = nombre; } public int getAge () {edad de retorno; } public void setAge (int edad) {this.age = edad; }}

Archivo: TestSort2.java

importar java.util. *; public class TestSort2 {public static void main (String args[]){ Lista de arreglo al = new ArrayList(); al.add (nuevo estudiante (101, «Vijay», 23)); al.add (nuevo estudiante (106, «Ajay», 27)); al.add (nuevo estudiante (105, nulo, 21)); Comparador cm1 = Comparator.comparing (Student :: getName, Comparator.nullsFirst (String :: compareTo)); Collections.sort (al, cm1); System.out.println («Considera que nulo es menor que no nulo»); for (Student st: al) {System.out.println (st.rollno + «» + st.name + «» + st.age); } Comparador cm2 = Comparator.comparing (Student :: getName, Comparator.nullsLast (String :: compareTo)); Collections.sort (al, cm2); System.out.println («Considera que nulo es mayor que no nulo»); for (Student st: al) {System.out.println (st.rollno + «» + st.name + «» + st.age); }}}

Considers null to be less than non-null
105 null 21
106 Ajay 27
101 Vijay 23
Considers null to be greater than non-null
106 Ajay 27
101 Vijay 23
105 null 21
close