Je veux trier ma ArrayList
en utilisant un type booléen. En gros, je veux afficher les entrées avec true
en premier. Voici mon code ci-dessous:
Abc.Java
public class Abc {
int id;
bool isClickable;
Abc(int i, boolean isCl){
this.id = i;
this.isClickable = iCl;
}
}
Main.Java
List<Abc> abc = new ArrayList<Abc>();
//add entries here
//now sort them
Collections.sort(abc, new Comparator<Abc>(){
@Override
public int compare(Abc abc1, Abc abc2){
boolean b1 = abc1.isClickable;
boolean b2 = abc2.isClickable;
if (b1 == !b2){
return 1;
}
if (!b1 == b2){
return -1;
}
return 0;
}
});
Ordre avant le tri: vrai vrai vrai faux faux faux faux vrai faux faux
Commande après tri: False faux vrai vrai vrai vrai faux faux faux faux
Une autre façon de faire est:
Collections.sort(abc, new Comparator<Abc>() {
@Override
public int compare(Abc abc1, Abc abc2) {
return Boolean.compare(abc2.isClickable,abc1.isClickable);
}
});
Dans ce cas, l’une des solutions les plus simples consiste à convertir les booléens en entiers, où false
est 0
et true
est 1
. Puis retourne la différence du deuxième et du premier.
Alors:
int b1 = abc1.isClickable ? 1 : 0;
int b2 = abc2.isClickable ? 1 : 0;
return b2 - b1
devrait le faire.
Je veux que les éléments avec la valeur true
apparaissent en premier. Ma solution serait:
Collections.sort(m_mall, new Comparator<Mall>(){
@Override
public int compare(Mall mall1, Mall mall2){
boolean b1 = mall1.isClickable;
boolean b2 = mall2.isClickable;
return (b1 != b2) ? (b1) ? -1 : 1 : 0;
}
});
pourquoi ne pas utiliser quelque chose comme ça, c'est plus facile et Java 8
listOfABCElements = {true, false, false, true, true};
listOfABCElements.stream().sorted(Comparator.comparing(Abc::isClickable,Comparator.reverseOrder()).collect(Collectors.toList());
sortie: true, true, true, false, false
reverseOrder est pour l'ordre premier vrai et après faux, sinon falses va d'abord
listOfABCElements.stream().sorted(Comparator.comparing(Abc::isClickable).collect(Collectors.toList());
sortie: false, false, true, true, true
Une simple suggestion serait d'utiliser l'objet Boolean
au lieu de boolean et d'utiliser Collections.sort
.
Cependant, vous devez savoir que la false
sera avant la true
car true est représenté par 1
et false en tant que 0
. Mais alors, vous pouvez simplement changer votre algorithme et accéder en ordre inverse.
Edit : Comme soulscheck l’a déclaré, vous pouvez utiliser Collections.reverseOrder
pour inverser l’ordre imposé par le comparateur.
Java 8:
Collections.sort(abc, (abc1, abc2) ->
Boolean.compare(abc2.isClickable(), abc1.isClickable()));
C'est aussi possible de cette façon.
myList.sort((a, b) -> Boolean.compare(a.isSn_Principal(), b.isSn_Principal()));