Cómo ordenar enteros array en orden ascendente y descendente usando lambda solo en java

Este post ha sido aprobado por nuestros expertos así se asegura la exactitud de nuestra esta división.

Solución:

Puede ordenar la entrada de tipo Integer[] como :

Integer[] arr2 = new Integer[] 54,432,53,21,43;
Arrays.sort(arr2, Comparator.reverseOrder());

o posiblemente con tipos primitivos como:

int[] arr2 = new int[]54, 432, 53, 21, 43;
int[] sortedArray = Arrays.stream(arr2)
        .boxed()
        .sorted(Comparator.reverseOrder()) // just use 'sorted()' for ascending order
        .mapToInt(Integer::intValue)
        .toArray();

o más usando un truco de una de las respuestas existentes (tenga en cuenta que debe usarse con precaución con los valores límite):

int[] sortedArray = Arrays.stream(arr2)
        .map(i -> -i).sorted().map(i -> -i) // just use 'sorted()' for ascending order
// Edit - use map(i -> ~i).sorted().map(i -> ~i) to be safe from the issue with Integer.MIN_VALUE
        .toArray();

Editar: Para una clasificación en orden ascendente en el lugar, solo necesita realizar:

int[] arr2 = new int[]54, 432, 53, 21, 43;
Arrays.sort(arr2);

Dado

int[] array = ... ;

Para ordenar ascendentemente, simplemente haga

Arrays.sort(array);

Aquí hay una bonita manera de ordenar descendente:

Arrays.setAll(array, i -> ~array[i]);
Arrays.sort(array);
Arrays.setAll(array, i -> ~array[i]);

Esto es un poco más lento que clasificar ascendente y luego invertir el array; tiene que hacer una pasada extra sobre el array. El tiempo de ejecución está dominado por la clasificación de un array de cualquier tamaño significativo, por lo que es poco probable que se note.

Esto funciona haciendo un complemento bit a bit de los valores int antes y después de la ordenación. Esto proporciona una inversión exacta y sin pérdidas del orden de cada valor int posible. Para ver esto, debe comprender que los enteros de Java usan la representación de complemento a dos. Considere si los enteros tuvieran solo tres bits. Todos los valores serían los siguientes:

         100  101  110  111  000  001  010  011
          -4   -3   -2   -1   0    1    2    3
MIN_VALUE ^

El operador de complemento bit a bit ~ invierte cada bit. Puede ver por inspección que esto refleja la tabla sobre un punto de pivote entre -1 y 0, por lo que -4 se convierte en 3, -3 se convierte en 2, etc. Además, otro complemento restaurará el valor original. Así, una ordenación ascendente sobre los valores complementados es una ordenación descendente sobre los valores originales.

Tenga en cuenta que esto difiere de la negación - que no hace lo correcto aquí. refleja la mesa en cero, entonces la negación de cero es cero, la negación de -1 es 1, etc. Esto es asimétrico, porque la negación de MIN_VALUE es MIN_VALUE. Por lo tanto, usar la negación en un intento de realizar una ordenación descendente no funciona.

Finalmente, el uso de cajas y Comparator funciona, pero es considerablemente más lento y asigna un objeto separado para (casi) cada valor int. Recomiendo evitar el boxeo.

Ordenar en orden ascendente:

1. int[] ascArr = Arrays.stream(arr2).boxed().sorted(Comparator.naturalOrder())
                                     .mapToInt(Integer::intValue).toArray();
   

2. int[] ascArr = IntStream.of(arr2).boxed().sorted((a, b) -> Integer.compare(a, b))
                                    .mapToInt(Integer::intValue).toArray();
   

3. int[] ascArr = Arrays.stream(arr2).sorted().toArray();

---

Ordenar en orden descendente:

1. int[] descArr = Arrays.stream(arr2).boxed().sorted(Comparator.reverseOrder())
                                      .mapToInt(Integer::intValue).toArray();
   

2. int[] descArr = IntStream.of(arr2).boxed().sorted((a, b) -> Integer.compare(b, a))
                                     .mapToInt(Integer::intValue).toArray();
   

Recuerda que tienes permiso de decir si diste con la solución.

---

---

Utiliza Nuestro Buscador