web-dev-qa-db-fra.com

Trier une ArrayList par type booléen primitif

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

javasortingarraylistjava-collections-api
16
stud91

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);
        }
    });
31
Danilo

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.

14
soulcheck

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;
        }
    });
9
stud91

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

7
leonardo rey

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.

3
Jean-François Savard

Java 8:

 Collections.sort(abc, (abc1, abc2) ->
                  Boolean.compare(abc2.isClickable(), abc1.isClickable()));
1
bphilipnyc

C'est aussi possible de cette façon.

myList.sort((a, b) -> Boolean.compare(a.isSn_Principal(), b.isSn_Principal()));
1
davidddp