¿Cuál es la forma más aceptada de convertir a boolean
a int
en Java?
¿Cuál es la forma más aceptada de convertir a boolean
a int
en Java?
Respuestas:
int myInt = myBoolean ? 1 : 0;
^^
PD: verdadero = 1 y falso = 0
(foo && (!bar || baz)) ? 1 : 0
. Obviamente, si es solo un identificador, los padres no son necesarios ni deseables.
(boolean expression) ? 1 : 0;
sería más comprensible. Creo que el my
prefijo lo hizo parecer una variable.
foo && (!bar || baz) ? 1 : 0
Sería un error de sintaxis. (Sé que han pasado 6 años)
Usar el operador ternario es la forma más simple, más eficiente y más legible de hacer lo que desea. Te animo a utilizar esta solución.
Sin embargo, no puedo resistirme a proponer una solución alternativa, artificial, ineficiente e ilegible.
int boolToInt(Boolean b) {
return b.compareTo(false);
}
¡A la gente le gusta votar por respuestas tan geniales!
Editar
Por cierto, a menudo vi conversiones de un booleano a un int con el único propósito de hacer una comparación de los dos valores (generalmente, en implementaciones de compareTo
método). Boolean#compareTo
es el camino a seguir en esos casos específicos.
Editar 2
Java 7 introdujo una nueva función de utilidad que funciona con tipos primitivos directamente, Boolean#compare
(Gracias shmosel )
int boolToInt(boolean b) {
return Boolean.compare(b, false);
}
Boolean.compare()
y evitar el autoboxing. 2. La documentación de Boolean.compareTo()
no dice que devolverá 1, solo "un valor positivo si este objeto representa verdadero y el argumento representa falso".
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
se implementa como justo return bool ? 1 : 0;
.
Eso depende de la situación. A menudo, el enfoque más simple es el mejor porque es fácil de entender:
if (something) {
otherThing = 1;
} else {
otherThing = 0;
}
o
int otherThing = something ? 1 : 0;
Pero a veces es útil usar una enumeración en lugar de una bandera booleana. Imaginemos que hay procesos sincrónicos y asincrónicos:
Process process = Process.SYNCHRONOUS;
System.out.println(process.getCode());
En Java, enum puede tener atributos y métodos adicionales:
public enum Process {
SYNCHRONOUS (0),
ASYNCHRONOUS (1);
private int code;
private Process (int code) {
this.code = code;
}
public int getCode() {
return code;
}
}
?:
es que puede poner puntos de interrupción dentro de los bloques if.
Si usa Apache Commons Lang (que creo que muchos proyectos lo usan), puede usarlo así:
int myInt = BooleanUtils.toInteger(boolean_expression);
toInteger
el método devuelve 1 si boolean_expression
es verdadero, 0 de lo contrario
BooleanUtils.toInteger
se implementa como justo return bool ? 1 : 0;
.
Si true -> 1
y el false -> 0
mapeo es lo que quieres, puedes hacer:
boolean b = true;
int i = b ? 1 : 0; // assigns 1 to i.
Si desea ofuscar, use esto:
System.out.println( 1 & Boolean.hashCode( true ) >> 1 ); // 1
System.out.println( 1 & Boolean.hashCode( false ) >> 1 ); // 0
Vamos a jugar con el truco Boolean.compare(boolean, boolean)
. Comportamiento predeterminado de la función: si ambos valores son iguales, devuelve lo 0
contrario -1
.
public int valueOf(Boolean flag) {
return Boolean.compare(flag, Boolean.TRUE) + 1;
}
Explicación : Como sabemos, el retorno predeterminado de Boolean.compare es -1 en caso de coincidencia incorrecta, por lo que +1 hace que el valor de retorno sea 0 para False
y 1 paraTrue
Boolean.compare(myBoolean, false)
encajaría mejor de acuerdo con la descripción citada
El hecho de que tenga que escribir un método de envoltorio alrededor de una declaración if para emitir un valor solo se suma a la ya enorme lista de razones por las que Java ya debería morir. Y al ver que el operador ternario ni siquiera está envuelto en una función, sino que simplemente copio pegado en todas partes, veo un molde booleano en int que me vuelve loco. Es una pérdida de ciclos de CPU y un insulto a la legibilidad del código.
Además, la mayoría de las respuestas aquí tienen cientos de votos a favor con cero explicaciones, lo que me hace adivinar que las malas prácticas son solo el resultado de estar tan expuestos a Java. Si escribiera un operador ternario para convertir booleano a int en cualquier idioma moderno, me despedirían al día siguiente de cualquier trabajo que pudiera tener. Así que hoy dejé de tratar de emplear la razón en mis tareas de Java y decidí aceptar la estupidez:
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
yfalse
respectivamente?