Quelle construction "if" est la plus rapide - déclaration ou opérateur ternaire ?

Question

Il existe deux types de if déclarations en java - classique : if {} else {} et la sténographie : exp ? value1 : value2 . L'un est-il plus rapide que l'autre ou sont-ils identiques ?

déclaration :

int x;
if (expression) {
  x = 1;
} else {
  x = 2;
}

opérateur ternaire :

int x = (expression) ? 1 : 2;

Answer 1

Il n'y a qu'un seul type d'instruction "si". L'autre est une expression conditionnelle. Quant à savoir laquelle sera la plus performante : elles pourraient être compilées dans le même bytecode, et je m'attendrais à ce qu'elles se comportent de manière identique - ou si proche que vous ne voudriez certainement pas choisir l'une plutôt que l'autre en termes de performances.

Parfois, un if sera plus lisible, parfois l'opérateur conditionnel sera plus lisible. En particulier, je recommanderais d'utiliser l'opérateur conditionnel lorsque les deux opérandes sont simples et sans effet secondaire, alors que si le but principal des deux branches est leurs effets secondaires, j'utiliserais probablement un if déclaration.

Voici un exemple de programme et de bytecode :

public class Test {
    public static void main(String[] args) {
        int x;
        if (args.length > 0) {
            x = 1;
        } else {
            x = 2;
        }
    }

    public static void main2(String[] args) {
        int x = (args.length > 0) ? 1 : 2;
    }
}

Bytecode décompilé avec javap -c Test :

public class Test extends java.lang.Object {
  public Test();
    Code:
       0: aload_0
       1: invokespecial #1
       4: return

  public static void main(java.lang.String[]
    Code:
       0: aload_0
       1: arraylength
       2: ifle          10
       5: iconst_1
       6: istore_1
       7: goto          12
      10: iconst_2
      11: istore_1
      12: return

  public static void main2(java.lang.String[
    Code:
       0: aload_0
       1: arraylength
       2: ifle          9
       5: iconst_1
       6: goto          10
       9: iconst_2
      10: istore_1
      11: return
}

Comme vous pouvez le voir, il y a un léger différence dans le bytecode ici - si le istore_1 se produit à l'intérieur de la brance ou non (contrairement à ma tentative précédente très défectueuse :) mais je serais très surpris que le JITter aboutisse à un code natif différent.

Answer 2

Vos deux exemples seront probablement compilés dans un bytecode identique ou presque identique, il ne devrait donc pas y avoir de différence de performance.

S'il y avait une différence dans la vitesse d'exécution, vous devriez quand même utiliser la version la plus idiomatique (qui serait la deuxième pour assigner une seule variable basée sur une condition simple et deux sous-expressions simples, et la première pour faire des opérations plus complexes ou des opérations qui ne tiennent pas sur une seule ligne).

Answer 3

Ce sont les mêmes. Les deux sont assez rapides, typiquement autour de 10-30 nano-secondes. (selon le mode d'utilisation) Ce laps de temps est-il important pour vous ?

Vous devez faire ce qui vous semble le plus clair.

Answer 4

Juste pour ajouter à toutes les autres réponses :

La deuxième expression est souvent appelée opérateur/état tertiaire/ternaire. Elle peut être très utile car elle renvoie une expression. Parfois, elle rend le code plus clair pour les instructions courtes typiques.

Answer 5

Ni l'un ni l'autre - ils seront compilés à l'identique.