web-dev-qa-db-fra.com

Comment comparer booléen?

Prenez ceci par exemple (extrait de le vérificateur de regex Java ne fonctionne pas ):

while(!checker) {
    matcher = pattern.matcher(number);
    if(matcher.find())
        checker = true;
    else
        year++;
}

Est-ce important si .equals(false) était utilisé pour vérifier la valeur de Boolean checker?

Je sais qu'il y a this qui est assez similaire. Cependant, évidemment, la question concerne la primitive boolean et non le wrapper d'objet, Boolean; ainsi, .equals() ne serait pas applicable.

De plus, Boolean devrait-il être traité différemment de boolean?

javaboolean
29
ylun.ca

D'après vos commentaires, il semble que vous recherchiez les "meilleures pratiques" pour l'utilisation de la classe wrapper Boolean. Mais il n'y a pas vraiment de bonnes pratiques, car c'est une mauvaise idée d'utiliser cette classe pour commencer. La seule raison d'utiliser le wrapper d'objet est dans les cas où vous devez absolument (comme lorsque vous utilisez Generics , c'est-à-dire, stocker un boolean dans un HashMap<String, Boolean> ou similaire). L'utilisation de l'encapsuleur n'a aucun avantage ni inconvénient, notamment qu'il vous ouvre jusqu'à NullPointerExceptions.

Est-ce important si '!' est utilisé à la place de .equals () pour Boolean?

Les deux techniques seront sujettes à un NullPointerException, donc peu importe à cet égard. Dans le premier scénario, le Boolean sera décompressé dans sa valeur respective boolean et comparé normalement. Dans le second scénario, vous appelez une méthode de la classe Boolean, qui est la suivante :

public boolean equals(Object obj) {
    if (obj instanceof Boolean) {
        return value == ((Boolean)obj).booleanValue();
    }
    return false;
}

De toute façon, les résultats sont les mêmes.

Est-il important que .equals (false) soit utilisé pour vérifier la valeur du vérificateur booléen?

Par dessus, non.

Question secondaire: faut-il traiter le booléen différemment du booléen?

Si vous devez absolument utiliser la classe Boolean, vérifiez toujours null avant d'effectuer des comparaisons. par exemple.,

Map<String, Boolean> map = new HashMap<String, Boolean>();
//...stuff to populate the Map
Boolean value = map.get("someKey");
if(value != null && value) {
    //do stuff
}

Cela fonctionnera car Java circuits courts = évaluations conditionnelles. Vous pouvez également utiliser l'opérateur ternaire.

boolean easyToUseValue = value != null ? value : false;

Mais sérieusement ... utilisez simplement le type primitif, à moins que vous ne soyez obligé de ne pas le faire.

18
asteri

Essaye ça:

if (Boolean.TRUE.equals(yourValue)) { ... }

Comme avantage supplémentaire, c'est null-safe.

51
yglodt

L'utilisation de conditions directes (telles que ==,! =,! Condition) améliorera légèrement les performances par rapport à .equals (condition), car dans un cas, vous appelez la méthode à partir d'un objet alors que les comparaisons directes sont effectuées directement.

2
ucsunil

En ce qui concerne la performance des opérations directes et la méthode .equals(). La méthode .equals() semble être approximativement 4 fois plus lente que ==.

J'ai couru les tests suivants ..

Pour la performance de ==:

public class BooleanPerfCheck {

    public static void main(String[] args) {
        long frameStart;
        long elapsedTime;

        boolean heyderr = false;

        frameStart = System.currentTimeMillis();

        for (int i = 0; i < 999999999; i++) {
            if (heyderr == false) {
            }
        }

        elapsedTime = System.currentTimeMillis() - frameStart;
        System.out.println(elapsedTime);
    }
}

et pour l'exécution de .equals():

public class BooleanPerfCheck {

    public static void main(String[] args) {
        long frameStart;
        long elapsedTime;

        Boolean heyderr = false;

        frameStart = System.currentTimeMillis();

        for (int i = 0; i < 999999999; i++) {
            if (heyderr.equals(false)) {
            }
        }

        elapsedTime = System.currentTimeMillis() - frameStart;
        System.out.println(elapsedTime);
    }
}

Le temps système total pour == Était de 1

Le temps système total pour .equals() variait de 3 - 5

Ainsi, il est prudent de dire que .equals() nuit aux performances et que == Est préférable dans la plupart des cas pour comparer Boolean.

2
ylun.ca

Tant que checker n'est pas null, vous pouvez utiliser !checker tel que posté. Ceci est possible depuis Java 5, car cette variable Boolean sera automatiquement sélectionnée à la valeur primivite boolean.

2
Luiggi Mendoza

.equals(false) sera plus lent parce que vous appelez une méthode virtuelle sur un objet plutôt que d'utiliser une syntaxe plus rapide et plutôt inattendu pour la plupart des programmeurs car les normes de code généralement utilisées ne supposent pas vraiment que vous devriez le faire. vérifier via la méthode .equals(false).

1
Migol

Comme objet?

égal

public boolean equals (Object obj)

Renvoie true si et seulement si l'argument n'est pas null et est un objet booléen qui représente la même valeur booléenne que cet objet.

Substitue: est égal à la classe Object

Paramètres: obj - l'objet à comparer.

Retourne: true si les objets booléens représentent la même valeur; false sinon. 

boolean a = true;
boolean b = false;

System.out.println("a.equals(b):" + ((Object)a).equals( ((Object)b) ));

Sortie: a.equals (b): false

1
CamelTM