Quelle est la façon la plus acceptée de convertir un boolean
en un int
en Java?
Quelle est la façon la plus acceptée de convertir un boolean
en un int
en Java?
Réponses:
int myInt = myBoolean ? 1 : 0;
^^
PS: vrai = 1 et faux = 0
(foo && (!bar || baz)) ? 1 : 0
. Évidemment, s'il ne s'agit que d'un identifiant, les parens ne sont ni nécessaires ni souhaitables.
(boolean expression) ? 1 : 0;
serait plus compréhensible. Je pense que le my
préfixe l'a fait ressembler à une variable.
foo && (!bar || baz) ? 1 : 0
serait une erreur de syntaxe. (Je sais que ça fait 6 ans)
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 compareTo
méthode). Boolean#compareTo
est 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.compare()
et éviter l'autoboxing. 2. La documentation de Boolean.compareTo()
ne dit pas qu'elle renverra 1, seulement "une valeur positive si cet objet représente vrai et l'argument représente faux".
boolean b = ....;
int i = -("false".indexOf("" + b));
5 - b.toString().length
import org.apache.commons.lang3.BooleanUtils;
boolean x = true;
int y= BooleanUtils.toInteger(x);
BooleanUtils.toInteger
est implémenté comme juste return bool ? 1 : 0;
.
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;
}
}
?:
est que vous pouvez placer des points d'arrêt à l'intérieur des blocs if.
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);
toInteger
retourne 1 si boolean_expression
vrai, 0 sinon
BooleanUtils.toInteger
est implémenté comme juste return bool ? 1 : 0;
.
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 0
sinon -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 False
et 1 pourTrue
Boolean.compare(myBoolean, false)
conviendrait mieux à la description de la description
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;}
true
etfalse
respectivement?