Converti booleano in int in Java

Qual è il modo più accettato per convertire un booleanin intin Java?

int myInt = myBoolean ? 1 : 0;

^^

PS: true = 1 e false = 0

int val = b? 1 : 0;

L'uso dell'operatore ternario è il modo più semplice, più efficiente e più leggibile per fare ciò che desideri. Ti incoraggio a usare questa soluzione.

Tuttavia, non posso resistere a proporre una soluzione alternativa, inventata, inefficiente, illeggibile.

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

Ehi, alla gente piace votare per risposte così interessanti!

modificare

A proposito, ho visto spesso conversioni da un booleano a un int al solo scopo di fare un confronto tra i due valori (generalmente, nelle implementazioni del compareTometodo).Boolean#compareToè la strada da percorrere in quei casi specifici.

Modifica 2

Java 7 ha introdotto una nuova funzione di utilità che funziona direttamente con i tipi primitivi, Boolean#compare(grazie 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;
}

semplice

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

Dipende dalla situazione. Spesso l'approccio più semplice è il migliore perché è facile da capire:

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

o

int otherThing = something ? 1 : 0;

Ma a volte è utile usare un Enum invece di una bandiera booleana. Immaginiamo che ci siano processi sincroni e asincroni:

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

In Java, enum può avere attributi e metodi aggiuntivi:

public enum Process {

    SYNCHRONOUS (0),
    ASYNCHRONOUS (1);

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

    public int getCode() {
        return code;
    }
}

Se usi Apache Commons Lang (che penso che molti progetti lo utilizzino), puoi semplicemente usarlo in questo modo:

int myInt = BooleanUtils.toInteger(boolean_expression); 

toIntegeril metodo restituisce 1 se boolean_expressionè vero, 0 altrimenti

Se true -> 1e la false -> 0mappatura è ciò che vuoi, puoi fare:

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

Se vuoi offuscare, usa questo:

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

Consente di giocare con Boolean.compare(boolean, boolean). Comportamento predefinito della funzione: se entrambi i valori sono uguali, 0altrimenti restituisce -1.

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

Spiegazione : Come sappiamo, il ritorno predefinito di Boolean.compare è -1 in caso di errata corrispondenza, quindi +1 porta il valore di ritorno a 0 per Falsee 1 perTrue

Il fatto che devo scrivere un metodo wrapper attorno a un'istruzione if per il cast di un valore si aggiunge alla già vasta lista di motivi per cui Java dovrebbe già morire. E vedendo l'operatore ternario non impacchettato nemmeno in una funzione, ma solo copiato incollato ovunque vedo un cast booleano che mi fa impazzire. È uno spreco di cicli di CPU e un insulto alla leggibilità del codice.

Inoltre la maggior parte delle risposte qui hanno centinaia di voti senza spiegazioni, il che mi fa supporre che le cattive pratiche siano solo il risultato dell'esposizione a java così tanto. Se avessi scritto un operatore ternario per aver lanciato il booleano in un linguaggio moderno, sarei stato licenziato il giorno successivo da qualsiasi lavoro avrei potuto avere. Quindi oggi ho smesso di provare a impiegare la ragione con i miei compiti di java e ho deciso di abbracciare 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;
}

Quindi utilizzare:

convBool(aBool);