Convertir booleano a int en Java

¿Cuál es la forma más aceptada de convertir a booleana inten Java?

int myInt = myBoolean ? 1 : 0;

^^

PD: verdadero = 1 y falso = 0

int val = b? 1 : 0;

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 compareTométodo). Boolean#compareToes 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 b = ....; 
int i = -("false".indexOf("" + b));

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

simple

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

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;
    }
}

Si usa Apache Commons Lang (que creo que muchos proyectos lo usan), puede usarlo así:

int myInt = BooleanUtils.toInteger(boolean_expression); 

toIntegerel método devuelve 1 si boolean_expressiones verdadero, 0 de lo contrario

Si true -> 1y el false -> 0mapeo 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 0contrario -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 Falsey 1 paraTrue

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;}

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

Luego use:

convBool(aBool);