Uso di Boolean? in se espressione

Se ho un nullable Boolean b, posso fare il seguente confronto in Java:

Boolean b = ...;
if (b != null && b) {
   /* Do something */
} else {
   /* Do something else */
}

In Kotlin, posso ottenere lo stesso utilizzando l' !!operatore:

val b: Boolean? = ...
if (b != null && b!!) {
   /* Do something */
} else {
   /* Do something else */
}

Tuttavia, l'uso di mi !!sembra un po 'impreciso, aggirando il sistema di sicurezza nulla.

C'è un approccio più elegante per questo?

Modifica Sembra che ho semplificato un po '. Per le variabili locali, come mostra Banthar , funziona. Tuttavia, il mio booleano bè in realtà una "proprietà con un campo di supporto" (non sono ancora al passo con ciò che questo impone). Questo è il risultato:

È possibile confrontare booleana annullabile con true, falseo nullcon operatore di uguaglianza:

var b: Boolean? = null
if (b == true) {
    // b was not null and equal true
} 
if (b == false) {
   // b is false 
}
if (b != true) { 
   // b is null or false 
}

Se vuoi controllare in modo pulito se Boolean?è trueo falsepuoi fare:

when(b) {
    true -> {}
    false -> {}
}

Se vuoi controllare se è nullpossibile aggiungerlo (o else) come valore in when:

when(b) {
    true -> {}
    false -> {}
    null -> {}
}

when(b) {
    true -> {}
    false -> {}
    else-> {}
}

Kotlin analizzerà staticamente i tuoi assegni nulli. Questo va bene:

val b: Boolean? = null
if (b != null && b) {
    println(b)
}

Anche se questo non riesce con errore di tipo:

val b: Boolean? = null
if (b == null && b) {
    println(b)
}

Per ulteriori informazioni, vedere: http://kotlinlang.org/docs/reference/null-safety.html

Puoi anche usare "null coalescing operator" (che funzionerà per variabili mutabili):

val b: Boolean? = null
if (b ?: false) {
    println(b)
}

Da quello che ho visto il booleano? è il risultato di un metodo che restituisce Boolean su un oggetto che è nullable

val person: Person? = null
....
if(person?.isHome()) { //This won't compile because the result is Boolean?
  //Do something
}

La soluzione che ho utilizzato è utilizzare la letfunzione per rimuovere il possibile valore nullo restituito in questo modo

person?.let {
  if(it.isHome()) {
    //Do something
  }
}

In Kotlin, puoi fare così:

val b: Boolean? = true
if (b == true) { // if b is null, this should be null == true
    /* Do something */
} else {
    /* Do something else */
}

per prima cosa, aggiungi la funzione inline personalizzata di seguito:

inline fun Boolean?.ifTrue(block: Boolean.() -> Unit): Boolean? {
    if (this == true) {
        block()
    }
    return this
}

inline fun Boolean?.ifFalse(block: Boolean?.() -> Unit): Boolean? {
    if (null == this || !this) {
        block()
    }

    return this
}

quindi puoi scrivere codice come questo:

val b: Boolean? = ...
b.ifTrue {
   /* Do something in true case */
}

//or

b.ifFalse {
   /* Do something else in false case */
}

Per Kotlin quello che uso normalmente è

if (object?.booleanProperty ==true)
   { 
     //do stuff 
   }

questo funzionerebbe solo quando la proprietà è vera e l'oggetto non è nullo. Per il contrario:

if (!object?booleanProperty !=true)
   { 
     //do Stuff
   }

Usiamo if-elseun'istruzione con Elvis Operator:

val a: Boolean?
val b: Boolean?

a = true
b = null

if (a != null ?: b) { 
    println("One of them isn't nullable...")
} else {
    println("Both are nullables!")
}

// Risultato: "Uno di loro non è annullabile ..."

a = null
b = null

if (a != null ?: b) { 
    println("One of them isn't nullable...")
} else {
    println("Both are nullables!")
}

// Risultato: "Entrambi sono annullabili!"

È abbastanza facile aggiungere una funzione di estensione se questo ti aiuta.

fun Boolean?.orDefault(default: Boolean = false): Boolean {
    if (this == null)
        return default
    return this
}

var x: Boolean? = null

if(x.orDefault()) {
..
}

Nel caso in cui si desideri eseguire operazioni allo stesso modo containsu un, Stringè possibile utilizzare il controllo di uguaglianza come di seguito:

if (url?.contains("xxx") == true){
  return false;
}

Puoi farlo con Operatore sicuro "lascia"

val b: Boolean? = null
b?.let { flag ->
    if(flag){
        // true Block
    } else {
        // false Block
    }
}