El uso de booleano? en la expresión if

Si tengo un nulo Boolean b, puedo hacer la siguiente comparación en Java:

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

En Kotlin, puedo lograr lo mismo usando el !!operador:

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

Sin embargo, el uso de me !!parece un poco incompleto, eludiendo el sistema de seguridad nulo.

¿Hay un enfoque más elegante para esto?

Editar Parece que me sobreexpliqué un poco. Para las variables locales, como muestra Banthar , funciona. Sin embargo, mi booleano bes en realidad una "propiedad con un campo de respaldo" (todavía no estoy al tanto de lo que esto impone). Este es el resultado:

Puede comparar booleanos anulables con true, falseo nullusando el operador de igualdad:

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 
}

Si desea verificar limpiamente si Boolean?es trueo falsepuede hacer:

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

Si desea verificar si es así, nullpuede agregar eso (o else) como un valor en when:

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

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

Kotlin analizará estáticamente sus cheques nulos. Esto esta bien:

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

Aunque esto falla con el error de tipo:

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

Para obtener más información, consulte: http://kotlinlang.org/docs/reference/null-safety.html

También puede usar el "operador de fusión nula" (que funcionará para variables mutables):

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

Por lo que he visto el booleano? es el resultado de un método que devuelve un valor booleano en un objeto que puede anularse

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

La solución que he estado usando es usar la letfunción para eliminar el posible valor nulo devuelto de esta manera

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

En Kotlin, puedes hacer así:

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

primero, agregue la función en línea personalizada a continuación:

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
}

entonces puedes escribir código como este:

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

//or

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

Para Kotlin lo que normalmente uso es

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

esto solo funcionaría cuando la propiedad sea verdadera y el objeto no sea nulo. Por el reverso:

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

Usemos una if-elsedeclaración con un 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!")
}

// Resultado: "Uno de ellos no es anulable ..."

a = null
b = null

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

// Resultado: "¡Ambos son anulables!"

Es bastante fácil agregar una función de extensión si eso te ayuda.

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

var x: Boolean? = null

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

En caso de que desee realizar operaciones por igual containen una String, puede usar la verificación de igualdad como se muestra a continuación:

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

Puede hacerlo con el operador seguro "let"

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