¿Hay alguna manera FÁCIL de ordenar una matriz en orden descendente, por ejemplo, cómo tienen una ordenación en orden ascendente en el Arrays class?Java Array Orden descendente?
O tengo que dejar de ser perezoso y hacer esto a mí mismo: [
Usted podría utilizar esta
sort(T[] a, Comparator<? super T> c)
Arrays.sort(a, Collections.reverseOrder());
Se puede utilizar esta:
Arrays.sort(data, Collections.reverseOrder());
Collections.reverseOrder() devuelve un Comparator usando el orden natural inverso. Puede obtener una versión invertida de su propio comparador usando Collections.reverseOrder(myComparator).
para una lista
Collections.sort(list ,Collections.reverseOrder());
para una matriz
Arrays.sort(array, Collections.reverseOrder());
int [] array = {2,4,3,6,8,7}; Arrays.sort (array, Collections.reverseOrder()); me está dando un error! Error: "El método sort (int []) en el tipo Arrays no es aplicable para los argumentos (int [], comparador
int no es un objeto. Intenta usar Integer [] en su lugar. – Ornithopter
¿Por qué Integer [] funciona y no int []? – OpMt
Para matriz que contiene elementos de primitivas si hay org.apache.commons.lang(3) a disposición de manera fácil de revertir array (después de la clasificación IT) es utilizar :
ArrayUtils.reverse(array);
No sé cuál era su caso de uso, sin embargo, además de o Aquí hay otra opción (lazy) para ordenar en orden ascendente como lo indica pero luego iterar en el orden inverso en su lugar.
Una alternativa podría ser (para números !!!)
Literalmente hablados:
array = -Arrays.sort(-array)
' {__________ lol ________} ' –
Este método es realmente creativo si estamos ordenando números, aunque no es genérico y podría causar problemas de desbordamiento ... – hackjutsu
Esta es una muy buena respuesta para tipos primitivos . Eres un genio. –
sin contenido explícito R:
Collections.sort(list, Collections.reverseOrder());
con el comparador explícita:
Collections.sort(list, Collections.reverseOrder(new Comparator()));
Java 8:
Arrays.sort(list, comparator.reversed());
Actualización: reversed() invierte el comparador especificado. Por lo general, los comparadores ordenan de forma ascendente, por lo que esto cambia el orden de descender.
primer lugar usted necesita para ordenar la matriz usando:
Collections.sort(Myarray);
Luego hay que invertir el orden de ascendente a descendente usando:
Collections.reverse(Myarray);
Otra solución es que si estás haciendo uso de la interfaz Comparable puede cambiar los valores de salida que había especificado en su compareTo (Objeto 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;
}
Dónde magnitud es un atributo con el tipo de datos doble en mi programa. Esto fue ordenar mi clase definida freq en orden inverso por su magnitud. Por lo tanto, para corregir eso, cambie los valores devueltos por < y >. Esto le da la 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 matriz ordenada freq [] mFreq.
La belleza (en mi opinión) de esta solución es que se puede utilizar para clasificar las clases definidas por el usuario, e incluso más que eso, ordenarlas por un atributo específico. Si la implementación de una interfaz Comparable te parece desalentadora, te animo a no pensar de esa manera, en realidad no es así. Este link on how to implement comparable hizo las cosas mucho más fáciles para mí. Esperando personas pueden hacer uso de esta solución, y que su alegría será comparable a la mía.
array.sort(function(a, b) {return b - a;}); //descending
o
array.sort(function(a, b) {return a - b;}); //ascending
sé que este es un hilo bastante viejo, pero aquí es una versión actualizada de números enteros y Java 8:
Arrays.sort(array, (o1, o2) -> o2 - o1);
Tenga en cuenta que se trata de "o1 - o2 "para el orden ascendente normal (o Comparator.comparingInt()).
Esto también funciona para cualquier otro tipo de Objetos. Diga:
Arrays.sort(array, (o1, o2) -> o2.getValue() - o1.getValue());
No puede ordenar matrices de primitivas –
Convierta sus primitivos a sus objetos respectivos. Entero para int, doble para doble, booleano para booleano, etc. – Ishmael
si aún desea usar su [comparador] personalizado (http://docs.oracle.com/javase/7/docs/api/java/util/Comparator .html): 'Collections.reverseOrder (this)' –