Comprensión profunda de Arrays.sort ()

Arrays.sort (T[], Comparador c) es un método para ordenar la matriz de objetos definidos por el usuario. El Java Doc oficial describe brevemente lo que hace, pero no mucho para una comprensión profunda. En esta publicación, analizaré la información clave para una comprensión más profunda de este método.

1. Cómo usar Arrays.sort (): un ejemplo simple

Al leer el siguiente ejemplo, puede hacerse una idea rápida de cómo utilizar este método correctamente. Se define un Comparador para comparar perros por tamaño y luego el Comparador se utiliza como parámetro para el método de clasificación.

import java.util.Arrays;
import java.util.Comparator;
 
class Dog{
	int size;	
	public Dog(int s){
		size = s;
	}
}
 
class DogSizeComparator implements Comparator<Dog>{
 
	@Override
	public int compare(Dog o1, Dog o2) {
		return o1.size - o2.size;
	}
}
 
public class ArraySort {
 
	public static void main(String[] args) {
		Dog d1 = new Dog(2);
		Dog d2 = new Dog(1);
		Dog d3 = new Dog(3);
 
		Dog[] dogArray = {d1, d2, d3};
		printDogs(dogArray);
 
		Arrays.sort(dogArray, new DogSizeComparator());	
		printDogs(dogArray);
	}
 
	public static void printDogs(Dog[] dogs){
		for(Dog d: dogs)
			System.out.print(d.size + " " );
 
		System.out.println();
	}
}

Producción:

2 1 3
1 2 3

2. El patrón de estrategia utilizado en Arrays.sort ()

El método substring () en JDK 6 y JDK 7

Como este es un ejemplo perfecto de patrón de estrategia, vale la pena mencionar aquí por qué el patrón de estrategia es bueno para esta situación. En resumen, el patrón de estrategia permite que se seleccionen diferentes algoritmos en tiempo de ejecución. En este caso, al pasar un Comparador diferente, se pueden seleccionar diferentes algoritmos. Basado en el ejemplo anterior y ahora asumiendo que tiene otro Comparador que compara Perros por peso en lugar de por tamaño, simplemente puede crear un nuevo Comparador como el siguiente.

class Dog{
	int size;
	int weight;
 
	public Dog(int s, int w){
		size = s;
		weight = w; 
	}
}
 
class DogSizeComparator implements Comparator<Dog>{
 
	@Override
	public int compare(Dog o1, Dog o2) {
		return o1.size - o2.size;
	}
}
 
class DogWeightComparator implements Comparator<Dog>{
 
	@Override
	public int compare(Dog o1, Dog o2) {
		return o1.weight - o2.weight;
	}
}
 
public class ArraySort {
 
	public static void main(String[] args) {
		Dog d1 = new Dog(2, 50);
		Dog d2 = new Dog(1, 30);
		Dog d3 = new Dog(3, 40);
 
		Dog[] dogArray = {d1, d2, d3};
		printDogs(dogArray);
 
		Arrays.sort(dogArray, new DogSizeComparator());	
		printDogs(dogArray);
 
		Arrays.sort(dogArray, new DogWeightComparator());	
		printDogs(dogArray);
	}
 
	public static void printDogs(Dog[] dogs){
		for(Dog d: dogs)
			System.out.print("size="+d.size + " weight=" + d.weight + " ");
 
		System.out.println();
	}
}

size=2 weight=50 size=1 weight=30 size=3 weight=40 
size=1 weight=30 size=2 weight=50 size=3 weight=40 
size=1 weight=30 size=3 weight=40 size=2 weight=50

Comparator es solo una interfaz. Cualquier Comparador que implemente esta interfaz se puede utilizar durante el tiempo de ejecución. Esta es la idea clave del patrón de diseño de estrategia.

LeetCode: número de submatrices con máximo acotado (Java)

3. ¿Por qué utilizar «super»?

Es sencillo si «Comparador c» es el parámetro, pero el segundo parámetro es «Comparador c ”. significa que el tipo puede ser T o sus super tipos. ¿Por qué permite super tipos? La respuesta es: este enfoque permite usar el mismo comparador para todas las subclases. Esto es casi obvio en el siguiente ejemplo.

import java.util.Arrays;
import java.util.Comparator;
 
class Animal{
	int size;
}
 
class Dog extends Animal{
	public Dog(int s){
		size = s;
	}
}
 
class Cat extends Animal{
	public Cat(int s){
		size  = s;
	}
}
 
class AnimalSizeComparator implements Comparator<Animal>{
 
	@Override
	public int compare(Animal o1, Animal o2) {
		return o1.size - o2.size;
	}
	//in this way, all sub classes of Animal can use this comparator.
}
 
public class ArraySort {
 
	public static void main(String[] args) {
		Dog d1 = new Dog(2);
		Dog d2 = new Dog(1);
		Dog d3 = new Dog(3);
 
		Dog[] dogArray = {d1, d2, d3};
		printDogs(dogArray);
 
		Arrays.sort(dogArray, new AnimalSizeComparator());	
		printDogs(dogArray);
 
		System.out.println();
 
		//when you have an array of Cat, same Comparator can be used. 
		Cat c1 = new Cat(2);
		Cat c2 = new Cat(1);
		Cat c3 = new Cat(3);
 
		Cat[] catArray = {c1, c2, c3};
		printDogs(catArray);
 
		Arrays.sort(catArray, new AnimalSizeComparator());	
		printDogs(catArray);
	}
 
	public static void printDogs(Animal[] animals){
		for(Animal a: animals)
			System.out.print("size="+a.size + " ");
		System.out.println();
	}
}

size=2 size=1 size=3 
size=1 size=2 size=3 

size=2 size=1 size=3 
size=1 size=2 size=3

4. Resumen

LeetCode - Primer positivo faltante (Java)

Para resumir, los mensajes para llevar de Arrays.sort ():

genérico – super
patrón de estrategia
combinación de ordenación – complejidad de tiempo nlog (n)
Java.util.Collections # sort (List list, Comparator c) tiene una idea similar con Arrays.sort.

Referencias:
1. Arrays.sort (T[], java.util.Comparator)

Artículos Relacionados:

Por Programación.Click

Deja una respuesta Cancelar la respuesta