Come ordinare una collezione <T>?

Question

Ho un generico Collection e sto cercando di capire come posso ordinare gli oggetti contenuti al suo interno. Ho provato alcune cose ma non riesco a far funzionare nessuno di loro.

Answer 1

Collezioni di per sé non hanno un ordine predefinito, pertanto è necessario convertirli in un java.util.List. Quindi è possibile utilizzare una forma di java.util.Collections.sort

Collection<T> collection = ...; 

List<T> list = new ArrayList<T>(collection); 

Collections.sort(list); 
// or 
Collections.sort(list, new Comparator<T>(){...}); 

// list now is sorted 

Answer 2

Ecco un esempio. (Sto usando CompareToBuilder classe da Apache per comodità, anche se questo può essere fatto senza utilizzarlo.)

import java.util.ArrayList; 
import java.util.Calendar; 
import java.util.Collections; 
import java.util.Comparator; 
import java.util.Date; 
import java.util.HashMap; 
import java.util.List; 
import org.apache.commons.lang.builder.CompareToBuilder; 

public class Tester { 
    boolean ascending = true; 

    public static void main(String args[]) { 
     Tester tester = new Tester(); 
     tester.printValues(); 
    } 

    public void printValues() { 
     List<HashMap<String, Object>> list = 
      new ArrayList<HashMap<String, Object>>(); 
     HashMap<String, Object> map = 
      new HashMap<String, Object>(); 

     map.put("actionId", new Integer(1234)); 
     map.put("eventId", new Integer(21) ); 
     map.put("fromDate", getDate(1)  ); 
     map.put("toDate", getDate(7)  ); 
     list.add(map); 

     map = new HashMap<String, Object>(); 
     map.put("actionId", new Integer(456)); 
     map.put("eventId", new Integer(11) ); 
     map.put("fromDate", getDate(1)  ); 
     map.put("toDate", getDate(1)  ); 
     list.add(map); 

     map = new HashMap<String, Object>(); 
     map.put("actionId", new Integer(1234)); 
     map.put("eventId", new Integer(20) ); 
     map.put("fromDate", getDate(4)  ); 
     map.put("toDate", getDate(16)  ); 
     list.add(map); 

     map = new HashMap<String, Object>(); 
     map.put("actionId", new Integer(1234)); 
     map.put("eventId", new Integer(22) ); 
     map.put("fromDate", getDate(8)  ); 
     map.put("toDate", getDate(11)  ); 
     list.add(map); 


     map = new HashMap<String, Object>(); 
     map.put("actionId", new Integer(1234)); 
     map.put("eventId", new Integer(11) ); 
     map.put("fromDate", getDate(1)  ); 
     map.put("toDate", getDate(10)  ); 
     list.add(map); 

     map = new HashMap<String, Object>(); 
     map.put("actionId", new Integer(1234)); 
     map.put("eventId", new Integer(11) ); 
     map.put("fromDate", getDate(4)  ); 
     map.put("toDate", getDate(15)  ); 
     list.add(map); 

     map = new HashMap<String, Object>(); 
     map.put("actionId", new Integer(567)); 
     map.put("eventId", new Integer(12) ); 
     map.put("fromDate", getDate(-1)  ); 
     map.put("toDate", getDate(1)  ); 
     list.add(map); 

     System.out.println("\n Before Sorting \n "); 
     for(int j = 0; j < list.size(); j++) 
      System.out.println(list.get(j)); 

     Collections.sort(list, new HashMapComparator2()); 

     System.out.println("\n After Sorting \n "); 
     for(int j = 0; j < list.size(); j++) 
      System.out.println(list.get(j)); 
    } 

    public static Date getDate(int days) { 
     Calendar cal = Calendar.getInstance(); 
     cal.setTime(new Date()); 
     cal.add(Calendar.DATE, days); 
     return cal.getTime(); 
    } 

    public class HashMapComparator2 implements Comparator { 
     public int compare(Object object1, Object object2) { 
      if(ascending) { 
       return new CompareToBuilder() 
        .append(
         ((HashMap)object1).get("actionId"), 
         ((HashMap)object2).get("actionId") 
        ) 
        .append(
         ((HashMap)object2).get("eventId"), 
         ((HashMap)object1).get("eventId") 
        ) 
       .toComparison(); 
      } else { 
       return new CompareToBuilder() 
        .append(
         ((HashMap)object2).get("actionId"), 
         ((HashMap)object1).get("actionId") 
        ) 
        .append(
         ((HashMap)object2).get("eventId"), 
         ((HashMap)object1).get("eventId") 
        ) 
       .toComparison(); 
      } 
     } 
    } 
} 

Se si dispone di un codice specifico che si sta lavorando e stanno avendo problemi, è possibile pubblicare il tuo codice di pseudo e possiamo provare ad aiutarti!

Answer 3

Non si può se T è tutto ciò che si ottiene. Bisogna avere l'esso iniettata dal provider attraverso:

Collection<T extends Comparable> 

o passare in Confronto tramite il metodo Collections.sort (...)

Answer 4

Un Collection non ha un ordinamento, così volendo ordinarlo non ha senso. È possibile ordinare List istanze e gli array, ei metodi per farlo sono Collections.sort() e Arrays.sort()

Answer 5

Sono disponibili due opzioni di base forniti da java.util.Collections:

• <T extends Comparable<? super T>> void sort(List<T> list)
  • Utilizzare questo se T implements Comparable e stai bene con quella ordinamento naturale
• <T> void sort(List<T> list, Comparator<? super T> c)
  • Utilizzare questo se si desidera fornire il proprio Comparator.

A seconda di ciò che il Collection è, si può anche guardare SortedSet o SortedMap.

Answer 6

Se l'oggetto delle raccolte è un elenco, utilizzerei il metodo di ordinamento, come proposto nelle altre risposte.

Tuttavia, se non è una lista, e non mi importa di quello che tipo di oggetto Collection viene restituito, penso che sia più veloce di creare un TreeSet invece di una lista:

TreeSet sortedSet = new TreeSet(myComparator); 
sortedSet.addAll(myCollectionToBeSorted); 

Answer 7

Supponendo di aver un elenco di oggetti di tipo persona, usando l'espressione lambda, è possibile ordinare gli ultimi nomi degli utenti, per esempio nel modo seguente:

import java.util.Arrays; 
import java.util.Collections; 
import java.util.Comparator; 
import java.util.List; 

class Person { 
     private String firstName; 
     private String lastName; 

     public Person(String firstName, String lastName){ 
      this.firstName = firstName; 
      this.lastName = lastName; 
     } 

     public String getLastName(){ 
      return this.lastName; 
     } 

     public String getFirstName(){ 
      return this.firstName; 
     } 

     @Override 
     public String toString(){ 
      return "Person: "+ this.getFirstName() + " " + this.getLastName(); 
     } 
    } 

    class TestSort { 
     public static void main(String[] args){ 
      List<Person> people = Arrays.asList(
            new Person("John", "Max"), 
            new Person("Coolio", "Doe"), 
            new Person("Judith", "Dan") 
      ); 

      //Making use of lambda expression to sort the collection 
      people.sort((p1, p2)->p1.getLastName().compareTo(p2.getLastName())); 

      //Print sorted 
      printPeople(people); 
     } 

     public static void printPeople(List<Person> people){ 
      for(Person p : people){ 
       System.out.println(p); 
      } 
     } 
    }