Formulaire abrégé pour l'instruction Java If Else

Question

J'ai une méthode qui vérifie les valeurs nulles. Existe-t-il un moyen de réduire le nombre de lignes dans la méthode? Actuellement, le code semble "sale":

 private int similarityCount (String one, String two) {

    if (one == null && two == null) {
        return 1;
    } else if (one == null && two != null) {
        return 2;
    } else if (one != null && two == null) {
        return 3;
    } else {
        if(isMatch(one, two))
             return 4;
        return 5;
    }

}
 

Answer 1

private int similarityCount (String one, String two) {

    if (one == null && two == null) {
        return 1;
    } 

    if (one == null) {
        return 2;
    } 

    if (two == null) {
        return 3;
    } 

    if (isMatch(one, two)) {
        return 4;
    }
    return 5;
}

Answer 2

Je préfère les conditions imbriquées dans de tels cas:

 private int similarityCount (String one, String two) {
    if (one==null) {
        if (two==null) {
            return 1;
        } else {
            return 2;
        }
    } else {
        if (two==null) {
            return 3;
        } else {
            return isMatch(one, two) ? 4 : 5;
        }
    }
}
 

Bien sûr, vous pouvez obtenir une version plus courte en utilisant des opérateurs conditionnels plus ternaires.

 private int similarityCount (String one, String two) {  
    if (one==null) {
        return (two==null) ? 1 : 2;
    } else {
        return (two==null) ? 3 : isMatch(one, two) ? 4 : 5;
    }
}
 

Ou même (maintenant cela devient moins lisible):

 private int similarityCount (String one, String two) {  
    return (one==null) ? ((two==null) ? 1 : 2) : ((two==null) ? 3 : isMatch(one, two) ? 4 : 5);
}
 

Answer 3

Car le véritable but de la fonction semble être de gérer les non-null objets par correspondance, je ferais de gérer toute la null des contrôles dans un garde énoncé au début.

Ensuite, une fois que vous avez établi qu'aucun argument n'est - null, vous pouvez gérer la logique réelle:

private int similarityCount(String a, String b) {
    if (a == null || b == null) {
        return a == b ? 1 : a == null ? 2 : 3;
    }

    return isMatch(a, b) ? 4 : 5;
}

C'est à la fois plus concis et plus lisible que les autres options.

Cela dit, les véritables fonctions ne serait pas généralement retourner ces codes numériques. À moins que votre méthode a été simplifié pour illustrer le problème, j'aimerais vous invite fortement à revenir sur la logique et au lieu d'écrire quelque chose de semblable à ce qui suit:

private boolean similarityCount(String a, String b) {
    if (a == null || b == null) {
        throw new NullPointerException();
    }

    return isMatch(a, b);
}

Ou:

private boolean similarityCount(String a, String b) {
    if (a == null) {
        throw new IllegalArgumentException("a");
    }
    if (b == null) {
        throw new IllegalArgumentException("b");
    }

    return isMatch(a, b);
}

Ces approches plus classiques. Sur le revers de la médaille, ils peuvent déclencher une exception. On peut éviter cela en retournant un java.util.Optional<Boolean> dans Java 8:

private Optional<Boolean> similarityCount(String a, String b) {
    if (a == null || b == null) {
        return Optional.empty();
    }

    return Optional.of(isMatch(a, b));
}

À première vue, cela peut sembler être pas mieux que de retourner null mais les options sont en fait de loin supérieure.

Answer 4

Le code me semble assez clair. Vous pouvez le raccourcir avec les opérateurs d'imbrication et ternaires:

 if(one==null) {
    return two==null ? 1 : 2;
}
if(two==null) {
    return 3;
} 
return isMatch(one,two) ? 4 : 5;
 

Answer 5

Cela peut être fait sur une seule ligne en utilisant l'opérateur conditionnel Java:

 return (one==null?(two==null?1:2):(two==null?3:(isMatch(one,two)?4:5)));