comment trier cette liste?

Question

J'ai une liste de chaînes

ArrayList<String> list = new ArrayList<String>(); 

à chaque élément:

list.add(week+" "+year); 

où week et year sont des nombres entiers.

Comment faire pour trier cette liste dans un ordre croissant?

Answer 1

List<String> weeks = new ArrayList<String>(); 
weeks.add(1 + " " + 1958); 
weeks.add(32 + " " + 2007); 
weeks.add(32 + " " + 1999); 

Collections.sort(weeks, new Comparator<String>() 
{ 
    public int compare(String o1, String o2) 
    { 
    int y1 = Integer.parseInt(o1.substring(o1.indexOf(" ") + 1)); 
    int y2 = Integer.parseInt(o2.substring(o2.indexOf(" ") + 1)); 
    if (y1 == y2) 
    { 
     int w1 = Integer.parseInt(o1.substring(0, o1.indexOf(" "))); 
     int w2 = Integer.parseInt(o2.substring(0, o2.indexOf(" "))); 
     return w1 - w2; 
    } 
    return y1 - y2; 
    } 
}); 

System.out.println("weeks = " + weeks); 

Answer 2

Arrays.sort(list); 

ou Arrays.sort (liste, Collections.reverseOrder());

Answer 3

Si vous voulez simplement trier par la valeur de chaîne (qui sera l'ordre alphabétique):

Collections.sort(list); 

Si vous vouliez trier par ordre chronologique, vous pouvez mettre en œuvre une coutume Comparator et le transmettre à la méthode de tri:

public class MyComparator implements Comparator<String> { 
    public int compare(String first, String second) { 
     // Split the string and compare the ints here 
    } 

    public bool equals(Object o) { 
     return this == o; 
    } 
} 

Et puis:

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

Answer 4

Collections.sort(list, new Comparator<String>() { 
    public int compare(String a, String b) { 
    // Your string ordering logic here. (I won't write that for you.) 
    } 
}); 

Answer 5

Vous devez écrire un comparateur qui divise la semaine et l'année, compare l'année avant la semaine (si les champs de l'année sont égaux). BTW Vous devriez mettre la semaine et l'année dans un objet pour éviter le fractionnement.

Answer 6

Si vous voulez trier par ordre chronologique, vous allez devoir soit échanger l'année et la semaine afin qu'il soit year+" "+week alors faire un simple tri alphanumérique, ou écrire votre propre Comparator qui accepte deux articles de la list et rapports qui vient en premier.

En outre, envisagez de créer une classe avec des attributs semaine et année. Utilisez les objets de cette classe pour stocker les valeurs de votre semaine/année, puis vous pouvez les afficher de la manière que vous voulez, en plus d'en faciliter le tri.

Answer 7

Implémentez un comparateur pour comparer les valeurs de semaine et d'année reconstituées. Utilisez ce comparateur pour trier la liste. Cela devrait fonctionner. la mise en œuvre échantillon est fourni ci-dessous

class WeekYearComparator implements Comparator throws NumberFormatException{ 
public int compare(Object weekYr1, Object weekYr2){ 

String[] tokens1 = ((String)weekYr1).split(" "); 
int week1 = Integer.parseInt(tokens1[0].trim()); 
int year1 = Integer.parseInt(tokens1[1].trim()); 

String[] tokens2 = ((String)weekYr2).split(" "); 
int week2 = Integer.parseInt(tokens2[0].trim()); 
int year2 = Integer.parseInt(tokens2[1].trim()); 

if(year1 > year2) 
    return 1; 
else if(year1 < year2) 
    return -1; 
else if(year1 = year2){ 
    if(week1 > week2) 
    return 1; 
    if(week1 < week2) 
    return -1; 
    if(week1 == week2) 
    return 0; 
} 

} 

Arrays.sort(list, new WeekYearComparator); 

Answer 8

Créer une liste d'objets à l'aide du calendrier YEAR et WEEK_OF_YEAR. Triez cela, puis convertissez le résultat en une liste de chaînes.

Answer 9

Je vous recommande de créer une structure de données contenant les données que vous souhaitez et implémente.

class WeekOfYear implements Comparable<WeekOfYear> { 
    private int week ; 
    private int year ; 
    public WeekOfYear(int week, int year) { 
     this.week = week ; 
     this.year = year ; 
    } 
    /** 
    * ... 
    */ 
    public int compareTo(WeekOfYear other) { 
     int delta = this.year - other.year ; 

     return (int)Math.signum(
       delta != 0 ? delta : (this.week - other.week)); 
    } 

    @Override 
    public String toString() { 
     StringBuilder builder = new StringBuilder() ; 
     builder.append(week > 9 ? "" : "0") ; 
     builder.append(week).append(" ") ; 
     builder.append(year) ; 

     return builder.toString(); 
    } 
} 

List<WeekOfYear> weeks ; 
weeks = new ArrayList<WeekOfYear>(); 
Collections.sort(weeks) ; 

Answer 10

Solution générale:

public static <T> void sort(List<T> list, final List<Comparator<T>> comparatorList) { 
     if (comparatorList.isEmpty()) {//Always equals, if no Comparator. 
      throw new IllegalArgumentException("comparatorList is empty."); 
     } 
     Comparator<T> comparator = new Comparator<T>() { 
     public int compare(T o1, T o2) { 
       for (Comparator<T> c:comparatorList) { 
        if (c.compare(o1, o2) > 0) { 
        return 1; 
        } else if (c.compare(o1, o2) < 0) { 
        return -1; 
        } 
       } 
       return 0; 
     } 
     }; 
     Collections.sort(list, comparator); 
    }