Convertir booléen en int en Java

Quelle est la façon la plus acceptée de convertir un booleanen un inten Java?

int myInt = myBoolean ? 1 : 0;

^^

PS: vrai = 1 et faux = 0

int val = b? 1 : 0;

L'utilisation de l'opérateur ternaire est la façon la plus simple, la plus efficace et la plus lisible de faire ce que vous voulez. Je vous encourage à utiliser cette solution.

Cependant, je ne peux pas résister à proposer une solution alternative, artificielle, inefficace et illisible.

int boolToInt(Boolean b) {
    return b.compareTo(false);
}

Hé, les gens aiment voter pour des réponses aussi cool!

Éditer

Soit dit en passant, j'ai souvent vu des conversions d'un booléen en un int dans le seul but de faire une comparaison des deux valeurs (généralement, dans les implémentations de compareTométhode). Boolean#compareToest la voie à suivre dans ces cas spécifiques.

Modifier 2

Java 7 a introduit une nouvelle fonction utilitaire qui fonctionne directement avec les types primitifs Boolean#compare(merci shmosel )

int boolToInt(boolean b) {
    return Boolean.compare(b, false);
}

boolean b = ....; 
int i = -("false".indexOf("" + b));

public int boolToInt(boolean b) {
    return b ? 1 : 0;
}

Facile

import org.apache.commons.lang3.BooleanUtils;
boolean x = true;   
int y= BooleanUtils.toInteger(x);

Cela dépend de la situation. Souvent, l'approche la plus simple est la meilleure car elle est facile à comprendre:

if (something) {
    otherThing = 1;
} else {
    otherThing = 0;
}

ou

int otherThing = something ? 1 : 0;

Mais il est parfois utile d'utiliser un Enum au lieu d'un drapeau booléen. Imaginons qu'il existe des processus synchrones et asynchrones:

Process process = Process.SYNCHRONOUS;
System.out.println(process.getCode());

En Java, enum peut avoir des attributs et des méthodes supplémentaires:

public enum Process {

    SYNCHRONOUS (0),
    ASYNCHRONOUS (1);

    private int code;
    private Process (int code) {
        this.code = code;
    }

    public int getCode() {
        return code;
    }
}

Si vous utilisez Apache Commons Lang (que je pense que beaucoup de projets l'utilisent), vous pouvez simplement l'utiliser comme ceci:

int myInt = BooleanUtils.toInteger(boolean_expression); 

toIntegerretourne 1 si boolean_expressionvrai, 0 sinon

Si true -> 1et la false -> 0cartographie est ce que vous voulez, vous pouvez faire:

boolean b = true;
int i = b ? 1 : 0; // assigns 1 to i.

Si vous voulez masquer, utilisez ceci:

System.out.println( 1 & Boolean.hashCode( true ) >> 1 );  // 1
System.out.println( 1 & Boolean.hashCode( false ) >> 1 ); // 0

Permet de jouer avec Boolean.compare(boolean, boolean). Comportement par défaut de la fonction: si les deux valeurs sont égales, elle renvoie 0sinon -1.

public int valueOf(Boolean flag) {
   return Boolean.compare(flag, Boolean.TRUE) + 1;
}

Explication : Comme nous le savons, le retour par défaut de Boolean.compare est -1 en cas de mauvaise correspondance, donc +1 donne une valeur de retour à 0 pour Falseet 1 pourTrue

Le fait que je doive écrire une méthode wrapper autour d'une instruction if pour convertir une valeur ne fait qu'ajouter à la liste déjà énorme des raisons pour lesquelles java devrait simplement mourir. Et voir l'opérateur ternaire même pas enveloppé dans une fonction mais juste copier-coller partout où je vois une distribution booléenne en int me rend fou. C'est un gaspillage de cycles CPU et une insulte à la lisibilité du code.

De plus, la plupart des réponses ici contiennent des centaines de votes positifs sans aucune explication, ce qui me fait deviner que les mauvaises pratiques sont simplement le résultat de l'exposition à Java. Si j'écrivais un opérateur ternaire pour lancer un booléen en int dans n'importe quelle langue moderne, je serais viré le lendemain de n'importe quel travail que j'aurais. Aujourd'hui, j'ai renoncé à essayer d'utiliser la raison avec mes missions Java et j'ai décidé d'embrasser la stupidité:

public static int booltoint(boolean nonsense) {
                                // Let's start with indenting using spaces, 16 of them to be precise
                                String[] ____int = new String[500];
                                ____int[0] = Boolean.toString(nonsense);
                                try {
                                                Thread.sleep(100); 
                                } catch (Exception e) {    }
                                Random rand = new Random();
                                int n = rand.nextInt((int)1e9);
                                int result = 0;
                                int other_Result = 1;
                                for (int i = -5; i < 2; i++) {
                                                try {
                                                                if (n == 35467247) return 5; // let's just fail with one in a billion chance
                                                                if ((5 - ____int[i].length()) == 1) {
                                                                                return ++result;
                                                                } else if(____int[i] == "false") {
                                                                                return --other_Result;
                                                                }
                                                } catch (Exception e) {
                                                                // This method will throw an exception 5 times every single time I 
                                                                // cast a boolean to int before returning an integer
                                                }
                                }
                                return (int)1e35;}

public static int convBool(boolean b)
{
int convBool = 0;
if(b) convBool = 1;
return convBool;
}

Utilisez ensuite:

convBool(aBool);