Ordenar en Java

Cada vez que escuchamos que los algoritmos de clasificación entran en juego, como la clasificación por selección, la clasificación por burbujas, la clasificación por inserción, la clasificación por radix, la clasificación por cubos, etc., pero si miramos más de cerca aquí, no se nos pide que usemos ningún tipo de algoritmo. Es una clasificación simple con la ayuda de estructuras de datos lineales y no lineales presentes en Java. Entonces, se realiza la clasificación con la ayuda de la fuerza bruta en Java con la ayuda de bucles y hay dos métodos incorporados para clasificar en Java. 

Formas de ordenar en Java

1. Usando bucles
2. Usando el método sort() de la clase Arrays
3. Usando el método de clasificación de la clase Collections
4. Ordenar en un subarreglo

Analicemos los cuatro y propongamos un código para cada uno de ellos.

Forma 1: usar bucles

// Java Program to sort an elements
// by bringing Arrays into play
 
// Main class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Custom input array
        int arr[] = { 4, 3, 2, 1 };
 
        // Outer loop
        for (int i = 0; i < arr.length; i++) {
 
            // Inner nested loop pointing 1 index ahead
            for (int j = i + 1; j < arr.length; j++) {
 
                // Checking elements
                int temp = 0;
                if (arr[j] < arr[i]) {
 
                    // Swapping
                    temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
 
            // Printing sorted array elements
            System.out.print(arr[i] + " ");
        }
    }
}

1 2 3 4 

Forma 2: Usar el método sort() de la clase Arrays  

Arrays.Sort() funciona para arrays que pueden ser de tipo de datos primitivo y que, a su vez, se ordenan de forma predeterminada en orden ascendente.

Ejemplo 1

// Java program to demonstrate working of
// sort() method of Arrays class
 
// Importing Arrays class from java.util package
import java.util.Arrays;
 
// Main class
public class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Custom input array
        int[] arr = { 13, 7, 6, 45, 21, 9, 101, 102 };
 
        // Calling the sort() method present
        // inside Arrays class
        Arrays.sort(arr);
 
        // Printing and display sorted array
        System.out.printf("Modified arr[] : %s",
                          Arrays.toString(arr));
    }
}

Modified arr[] : [6, 7, 9, 13, 21, 45, 101, 102]

Ejemplo 2

// A sample Java program to sort an array
// in descending order using Arrays.sort().
import java.util.Arrays;
import java.util.Collections;
 
public class GFG {
    public static void main(String[] args)
    {
        // Note that we have Integer here instead of
        // int[] as Collections.reverseOrder doesn't
        // work for primitive types.
        Integer[] arr = { 13, 7, 6, 45, 21, 9, 2, 100 };
 
        // Sorts arr[] in descending order
        Arrays.sort(arr, Collections.reverseOrder());
 
        System.out.printf("Modified arr[] : %s",
                          Arrays.toString(arr));
    }
}

Modified arr[] : [100, 45, 21, 13, 9, 7, 6, 2]

Forma 3: Usar el método sort() de la clase Collections 

Collections.sort() funciona para colecciones de objetos como ArrayList y LinkedList.

Ejemplo

// Java program to demonstrate working of Collections.sort()
import java.util.*;
 
public class GFG {
    public static void main(String[] args)
    {
        // Create a list of strings
        ArrayList<String> al = new ArrayList<String>();
        al.add("Geeks For Geeks");
        al.add("Friends");
        al.add("Dear");
        al.add("Is");
        al.add("Superb");
 
        /* Collections.sort method is sorting the
        elements of ArrayList in ascending order. */
        Collections.sort(al);
 
        // Let us print the sorted list
        System.out.println("List after the use of"
                           + " Collection.sort() :\n" + al);
    }
}

List after the use of Collection.sort() :
[Dear, Friends, Geeks For Geeks, Is, Superb]

Ejemplo 2

// Java program to demonstrate working of Collections.sort()
// to descending order.
import java.util.*;
 
public class GFG {
    public static void main(String[] args)
    {
        // Create a list of strings
        ArrayList<String> al = new ArrayList<String>();
        al.add("Geeks For Geeks");
        al.add("Friends");
        al.add("Dear");
        al.add("Is");
        al.add("Superb");
 
        /* Collections.sort method is sorting the
        elements of ArrayList in ascending order. */
        Collections.sort(al, Collections.reverseOrder());
 
        // Let us print the sorted list
        System.out.println("List after the use of"
                           + " Collection.sort() :\n" + al);
    }
}

List after the use of Collection.sort() :
[Superb, Is, Geeks For Geeks, Friends, Dear]

Forma 4: ordenar solo un subarreglo

// Java program to sort a subarray
// using Arrays.sort()
 
// Importing Arrays class from java.util package
import java.util.Arrays;
 
// Main class
public class GFG {
 
    // Main drive method
    public static void main(String[] args)
    {
        // Custom input array
        int[] arr = { 13, 7, 6, 45, 21, 9, 2, 100 };
 
        // Sort subarray from index 1 to 4, i.e.,
        // only sort subarray {7, 6, 45, 21} and
        // keep other elements as it is.
        Arrays.sort(arr, 1, 5);
 
        // Printing sorted array
        System.out.printf("Modified arr[] : %s",
                          Arrays.toString(arr));
    }
}

Modified arr[] : [13, 6, 7, 21, 45, 9, 2, 100]

Nota:

• ¿Qué algoritmo de clasificación usa Java en sort()?  
  Anteriormente, el método Arrays.sort de Java usaba Quicksort para arrays de primitivas y Merge sort para arrays de objetos. En las últimas versiones de Java, el método Arrays.sort y Collection.sort() usan Timsort.
• ¿Qué orden de clasificación se realiza de forma predeterminada?  
  Por defecto se ordena en orden ascendente.
• ¿Cómo ordenar una array o una lista en orden descendente?  
  Se puede hacer con la ayuda de Collections.reverseOrder().
• ¿Cómo escribir mi propia función de clasificación en Java?  
  Consulte los programas Java para clasificación rápida , clasificación por fusión , clasificación por inserción , clasificación por selección , clasificación en montón , clasificación por burbujas