Comment trier une liste de tableaux?

Collections.sort(testList);
Collections.reverse(testList);

Qui permettra de faire ce que vous voulez. N'oubliez pas d'importer Collections si!

Voici la documentation de Collections.

Utilisation util méthode de java.util.Collections classe, j'.e

Collections.sort(list)

En fait, si vous voulez trier objet personnalisé vous pouvez utiliser

Collections.sort(List<T> list, Comparator<? super T> c) 

voir les collections de l'api

À l'aide de lambda (Java8), et à la déshabiller pour le plus strict de la syntaxe (la JVM va conclure beaucoup dans ce cas), vous obtenez:

Collections.sort(testList, (a, b) -> b.compareTo(a));

Une version plus détaillée:

//Implement a reverse-order Comparator by lambda function
Comparator<Double> comp = (Double a, Double b) -> {
    return b.compareTo(a);
};

Collections.sort(testList, comp);

L'utilisation d'un lambda est possible parce que le Comparateur interface n'a qu'une seule méthode à mettre en œuvre, de sorte que la VM peut en déduire la méthode est mise en œuvre. Depuis les types de paramètres peuvent être déduits, ils n'ont pas besoin d'être déclaré (c'est à dire (a, b) au lieu de (Double a, Double b). Et puisque le corps de lambda n'a qu'une seule ligne, et la méthode est censée renvoyer une valeur, la return est déduit et les accolades ne sont pas nécessaires.

Vous pouvez utiliser Collections.sort(list) pour trier list si votre list contient Comparable éléments. Sinon, je vous recommande de mettre en œuvre cette interface comme ici:

public class Circle implements Comparable<Circle> {}

et bien sûr de fournir votre propre réalisation de compareTo méthode comme ici:

@Override
    public int compareTo(Circle another) {
        if (this.getD()<another.getD()){
            return -1;
        }else{
            return 1;
        }
    }

Et puis vous pouvez à nouveau utiliser Colection.sort(list) que maintenant la liste contient des objets de type Comparable et peuvent être triées. L'ordre dépend de compareTo méthode. Cochez cette https://docs.oracle.com/javase/tutorial/collections/interfaces/order.html pour de plus amples informations.

//Here is sorted List alphabetically with syncronized
package com.mnas.technology.automation.utility;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import org.apache.log4j.Logger;
/**
* @author manoj.kumar
*/
public class SynchronizedArrayList {
static Logger log = Logger.getLogger(SynchronizedArrayList.class.getName());
@SuppressWarnings("unchecked")
public static void main(String[] args) {
List<Employee> synchronizedList = Collections.synchronizedList(new ArrayList<Employee>());
synchronizedList.add(new Employee("Aditya"));
synchronizedList.add(new Employee("Siddharth"));
synchronizedList.add(new Employee("Manoj"));
Collections.sort(synchronizedList, new Comparator() {
public int compare(Object synchronizedListOne, Object synchronizedListTwo) {
//use instanceof to verify the references are indeed of the type in question
return ((Employee) synchronizedListOne).name
.compareTo(((Employee) synchronizedListTwo).name);
}
}); 
/*for( Employee sd : synchronizedList) {
log.info("Sorted Synchronized Array List..."+sd.name);
}*/
//when iterating over a synchronized list, we need to synchronize access to the synchronized list
synchronized (synchronizedList) {
Iterator<Employee> iterator = synchronizedList.iterator();
while (iterator.hasNext()) {
log.info("Sorted Synchronized Array List Items: " + iterator.next().name);
}
}
}
}
class Employee {
String name;
Employee(String name) {
this.name = name;
}
}

|*| Tri d'une Liste :

import java.util.Collections;

|=> Tri Asc Ordre :

Collections.sort(NamAryVar);

|=> Trier Dsc Ordre :

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

|*| Inverser l'ordre de la Liste :

Collections.reverse(NamAryVar);

Par exemple, j'ai une Personne de la classe: String nom, int age ==>Constructeur new Personne(nom,age)

import java.util.Collections;
import java.util.ArrayList;
import java.util.Arrays;
public void main(String[] args){
Person ibrahima=new Person("Timera",40);
Person toto=new Person("Toto",35);
Person alex=new Person("Alex",50);
ArrayList<Person> myList=new ArrayList<Person>
Collections.sort(myList, new Comparator<Person>() {
@Override
public int compare(Person p1, Person p2) {
//return p1.age+"".compareTo(p2.age+""); //sort by age
return p1.name.compareTo(p2.name); //if you want to short by name
}
});
System.out.println(myList.toString());
//[Person [name=Alex, age=50], Person [name=Timera, age=40], Person [name=Toto, age=35]]
Collections.reverse(myList);
System.out.println(myList.toString());
//[Person [name=Toto, age=35], Person [name=Timera, age=40], Person [name=Alex, age=50]]
}

Dans JAVA 8 son beaucoup plus facile maintenant.

List<String> alphaNumbers = Arrays.asList("one", "two", "three", "four");
List<String> alphaNumbersUpperCase = alphaNumbers.stream()
.map(String::toUpperCase)
.sorted()
.collect(Collectors.toList());
System.out.println(alphaNumbersUpperCase); //[FOUR, ONE, THREE, TWO]

-- Pour inverser utiliser cette

.sorted(Comparator.reverseOrder())

La ligne suivante doit faire l'épaisse

testList.sort(Collections.reverseOrder());