Java, Mutliple/Comparable différents implenetations de méthode compareTo()

Question

J'ai cette classe:

public class Sample implements Comparable<Sample> { 
public String a; 
public String b; 
public String c; 

public int compareTo (Sample sampleToCompare) { 
int compResult = this.a.compareTo(sampleToCompare.a); 
     return (compResult != 0 ? compResult : 
        this.b.compareTo(sampleToCompare.b));  
    } 
} 

Je veux compareTo() à son comportement ou trier en utilisant différentes propriétés de classe en fonction si un indicateur est défini.

Donc, si flag == 1 je voudrais compareTo() à l'utilisation de la propriété c, est par ailleurs flag == 0, tout ce qui est actuellement dans la méthode. En d'autres termes, triez la même classe de différentes manières.

Je ne sais pas comment y parvenir. S'il vous plaît aider.

Aussi, s'il vous plaît laissez-moi savoir si plus d'informations sont nécessaires de mon côté.

Answer 1

Que diriez-vous:

public int compareTo(Sample sampleToCompare) { 
    if (flag == 1) { 
     return this.c.compareTo(sampleToCompare.c); 
    } 
    if (flag == 0) { 
     // current stuff 
    } 
    ... 
} 

Ce n'est pas une façon très orientée objet pour le faire, cependant. Probablement, vous devriez avoir deux comparateurs différents et un moyen de les sélectionner en fonction de votre valeur "drapeau". Quelque chose comme:

class Sample { 
    private String a; 
    private String b; 
    private String c; 
} 

class ASampleComparator implements Comparator<Sample> { 
    public int compare(Sample o1, Sample o2) { 
     return o1.a.compareTo(o2.a); 
    } 
} 

class BSampleComparator implements Comparator<Sample> { 
    public int compare(Sample o1, Sample o2) { 
     return o1.b.compareTo(o2.b); 
    } 
} 

class CSampleComparator implements Comparator<Sample> { 
    public int compare(Sample o1, Sample o2) { 
     return o1.c.compareTo(o2.c); 
    } 
} 

public Comparator<Sample> pickComparator(int flag) { 
    switch (flag) { 
     case 0: 
      return new ASampleComparator(); 
     case 1: 
      return new BSampleComparator(); 
     case 2: 
      return new CSampleComparator(); 
     default: 
      throw new IllegalArgumentException("Bad flag value: " + flag); 
    } 
} 

Answer 2

Vous devriez faire votre drapeau statique de sorte que la comparaison sera conforme (tel que décrit dans Effective Java, item 12), sinon, vous pourriez obtenir que a.compareTo(b) rendements a > b, mais b.compareTo(a) rendements b > a. Ainsi, la simple mise en œuvre que je peux penser est:

public class Sample implements Comparable<Sample> { 
public String a; 
public String b; 
public String c; 
public static boolean my_flag = false; 

public int compareTo (Sample sampleToCompare) { 
    if (flag) { 
     return this.c.compareTo(sampleToCompare.c); 
    } 
    int compResult = this.a.compareTo(sampleToCompare.a); 
     return (compResult != 0 ? compResult : 
        this.b.compareTo(sampleToCompare.b));  
    } 
} 

Answer 3

Si vous souhaitez implémenter différents types de tri, vous devriez jeter un oeil à l'interface java.util.Comparator.

public class SampleComparatorA implement Comparator<Sample> { 

    public int compare(Sample a, Sample b) { 
     // Your sorting 
    } 
} 

Et utiliser java.util.Collections.sort() méthode avec le paramètre comme Comparator secound à la place.

Collections.sort(aSampleList, new SampleComparatorA());