por - Java Array Ordenar descendente?

ordenar palabras alfabeticamente metodo burbuja java

Question

¿Hay alguna forma FÁCIL de ordenar una matriz en orden descendente, como la forma en que tienen una clasificación ascendente en la clase Arrays ?

O tengo que dejar de ser perezoso y hacer esto yo mismo: [

Answer 1

Esto funcionó para mí:

package doublearraysort;
import java.util.Arrays;
import java.util.Collections;
public class Gpa {
public static void main(String[] args) {
// initializing unsorted double array
Double[] dArr = new Double[] {
new Double(3.2),
new Double(1.2),
new Double(4.7),
new Double(3.3),
new Double(4.6),
};
// print all the elements available in list
for (double number : dArr) {
System.out.println("GPA = " + number);
}
// sorting the array
Arrays.sort(dArr, Collections.reverseOrder());
// print all the elements available in list again
System.out.println("The sorted GPA Scores are:");
for (double number : dArr) {
System.out.println("GPA = " + number);
}
}
}

Salida:

GPA = 3.2
GPA = 1.2
GPA = 4.7
GPA = 3.3
GPA = 4.6
The sorted GPA Scores are:
GPA = 4.7
GPA = 4.6
GPA = 3.3
GPA = 3.2
GPA = 1.2

Answer 2

Java 8:

Arrays.sort(list, comparator.reversed());

Actualización: reversed() invierte el comparador especificado. Generalmente, los comparadores tienen un orden ascendente, por lo que esto cambia el orden a descendente

Answer 3

No sé cuál fue su caso de uso, sin embargo, además de otras respuestas aquí, otra opción (perezosa) es todavía ordenar en orden ascendente como usted lo indica, pero en su lugar, iterar en orden inverso .

Answer 4

Para una matriz que contiene elementos de primitivas si hay org.apache.commons.lang(3) a la disposición, una manera fácil de invertir la matriz (después de clasificarla) es usar:

ArrayUtils.reverse(array);

Answer 5

Podrías usar esto para ordenar todo tipo de objetos.

sort(T[] a, Comparator<? super T> c)
Arrays.sort(a, Collections.reverseOrder());

Arrays.sort() no se puede usar directamente para ordenar matrices primitivas en orden descendente. Si intenta llamar al método Arrays.sort() pasando el Comparador inverso definido por Collection.reverseOrder() , se generará el error

no se ha encontrado un método adecuado para ordenar (int [], comparador)

Eso funcionará bien con la matriz Integer pero no funcionará con una matriz int.

La única forma de ordenar una matriz primitiva en orden descendente es, primero ordenar la matriz en orden ascendente y luego invertir la matriz en su lugar. Esto también es cierto para matrices primitivas bidimensionales.

Answer 6

Primero necesitas ordenar tu matriz usando:

 Collections.sort(Myarray);

Entonces necesitas invertir el orden de ascender a descender usando:

 Collections.reverse(Myarray);

Answer 7

Puedes usar esto:

 Arrays.sort(data, Collections.reverseOrder());

Collections.reverseOrder() devuelve un Comparator utilizando el orden natural inverso. Puede obtener una versión invertida de su propio comparador utilizando Collections.reverseOrder(myComparator) .

Answer 8

Sé que este es un hilo bastante antiguo, pero aquí hay una versión actualizada para los enteros y Java 8:

Arrays.sort(array, (o1, o2) -> o2 - o1);

Tenga en cuenta que es "o1 - o2" para el orden ascendente normal (o Comparator.comparingInt ()).

Esto también funciona para cualquier otro tipo de objetos. Decir:

Arrays.sort(array, (o1, o2) -> o2.getValue() - o1.getValue());

Answer 9

para una lista

Collections.sort(list, Collections.reverseOrder());

para una matriz

Arrays.sort(array, Collections.reverseOrder());

Answer 10

sin comparador explícito:

Collections.sort(list, Collections.reverseOrder());

con comparador explícito:

Collections.sort(list, Collections.reverseOrder(new Comparator()));

Answer 11

una alternativa podría ser (para números !!!)

1. multiplica el Array por -1
2. ordenar
3. multiplicar una vez más con -1

Literalmente hablado:

array = -Arrays.sort(-array)

Answer 12

Otra solución es que si está utilizando la interfaz Comparable , puede cambiar los valores de salida que especificó en su compareTo (Object bCompared).

Por ejemplo :

public int compareTo(freq arg0)
{
int ret=0;
if(this.magnitude>arg0.magnitude)
ret= 1;
else if (this.magnitude==arg0.magnitude)
ret= 0;
else if (this.magnitude<arg0.magnitude)
ret= -1;
return ret;
}

Donde magnitud es un atributo con doble tipo de datos en mi programa. Esto fue ordenar mi frecuencia de clase definida en orden inverso por su magnitud. Así que para corregir eso, cambia los valores devueltos por < y > . Esto te da lo siguiente:

public int compareTo(freq arg0)
{
int ret=0;
if(this.magnitude>arg0.magnitude)
ret= -1;
else if (this.magnitude==arg0.magnitude)
ret= 0;
else if (this.magnitude<arg0.magnitude)
ret= 1;
return ret;
}

Para hacer uso de este compareTo, simplemente llamamos Arrays.sort(mFreq) que le dará la freq [] mFreq ordenada freq [] mFreq .

La belleza (en mi opinión) de esta solución es que se puede usar para ordenar las clases definidas por el usuario, e incluso más que eso, según un atributo específico. Si la implementación de una interfaz comparable le parece desalentadora, le recomiendo que no piense de esa manera, en realidad no lo es. Este enlace sobre cómo implementar cosas comparables me facilitó mucho las cosas. Las personas que esperan pueden hacer uso de esta solución, y que su alegría será incluso comparable a la mía.

Answer 13

array.sort(function(a, b) {return b - a;}); //descending

o

array.sort(function(a, b) {return a - b;}); //ascending

Answer 14

public double[] sortArrayAlgorithm(double[] array) { //sort in descending order
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array.length; j++) {
if (array[i] >= array[j]) {
double x = array[i];
array[i] = array[j];
array[j] = x;
}
}
}
return array;
}

simplemente use este método para ordenar una matriz de tipo doble en orden descendente, puede usarla para ordenar matrices de cualquier otro tipo (como int, float, etc.) simplemente cambiando el "tipo de retorno", el "tipo de argumento" y La variable "x" escribe al tipo correspondiente. también puede cambiar "> =" a "<=" en la condición if para hacer que el orden sea ascendente.