[JAVA] La question de savoir quel est le meilleur, si ou changer

introduction

―― Combien de fois avez-vous écrit si depuis que vous avez codé? Lol ――Même si vous écrivez des dizaines de milliers de fois, vous vous demandez parfois s'il faut utiliser switch ou si, non? ?? (Je suis peut-être inquiet)

Mes critères de sélection actuels

-Lors du choix d'une instruction if:&&Et||Quand tu veux

• Lors du changement: quand il y a beaucoup de choix --Quand il n'y a pas besoin de changer: opérateur ternaire ――Le reste est un sentiment si vous êtes inquiet ――Je l'ai choisi avec un sentiment comme ça, mais un jour j'ai pensé

Lequel fonctionnera le mieux lorsque vous jouerez l'un ou l'autre?

――Si vous êtes intéressé, vous devriez le mesurer, non? je pense

• Maintenant, exécutez!

Ce que vous avez préparé

• Java1.8
• IntelliJ IDEA

Table des matières (ce qui est censé être fait au moment de la rédaction du tableau)

• Exécutez une branche dans une boucle d'environ 100 fois
• S'il n'y a pas de différence de performances après 100 fois, augmentez le nombre de chiffres un par un. ――Si vous êtes satisfait dans une certaine mesure, augmentez les conditions ――Si vous êtes satisfait d'augmenter les conditions, effectuez une chaîne de caractères et un modèle numérique ――Je vais le faire comme ça

Entraine toi

Exécutez la branche dans une boucle d'environ 100 fois

--Le code exécuté est ci-dessous

CheckPerformance.java

import java.util.stream.IntStream;

public class CheckPerformance {

    public static void main(String[] args) {
        Long start = System.currentTimeMillis();
        //si exécution
        IntStream.rangeClosed(0, 100).forEach(i -> {
            if (i % 2 == 0) {
                System.out.println("Est même");
            } else if (i % 2 == 1) {
                System.out.println("Est impair");
            } else {
                System.out.println("Autre");
            }
        });

        //Exécution du commutateur
        IntStream.rangeClosed(0, 100).forEach(i -> {
            switch (i % 2) {
                case 0:
                    System.out.println("Est même");
                    break;
                case 1:
                    System.out.println("Est impair");
                    break;
                default:
                    System.out.println("Autre");
                    break;
            }
        });
        Long end = System.currentTimeMillis();
        System.out.println(end - start + "ms");
    }
}

• Le résultat de l'exécution est le suivant

Vérification

«Je l'ai couru plusieurs fois, mais c'est devenu comme un jeu de chance, alors j'ai décidé qu'il serait difficile de vérifier la différence de performance avec 100 fois.

• Bref, c'est juste une erreur

Exécutez une branche dans une boucle de 1000 fois

--Source omise

• Le résultat de l'exécution est le suivant

Vérification

――Hmm, il est subtil de vérifier la différence de performance même 1000 fois «J'ai toujours le sentiment que c'est dans la catégorie de l'erreur ici.

Exécutez la branche en 10000 boucles

--La source est (ry

• Le résultat de l'exécution est le suivant

Vérification

――Hmm, même 10000 fois ... (ry

Exécutez la branche en 100 000 boucles

--La source est (ry

• Le résultat de l'exécution est le suivant

Vérification

«Je pense qu'il y avait une légère différence de performance après 100 000 fois. ――Le commutateur a dépassé 1 seconde 0 fois, mais il y a 2 ifs. ――Cependant, l'erreur peut être une erreur, et si vous ne regardez que la valeur moyenne, le changement peut être plus rapide? L'hypothèse est venue ――Mais je suis un peu inquiet, alors je vais ajouter un autre chiffre et l'exécuter.

Exécutez une branche dans une boucle de 1 000 000 fois

• s..(ry
• Le résultat de l'exécution est le suivant

Vérification

• Vous pouvez voir la différence de performance à 1 000 000 de fois. «Je pense que la vitesse de l'interrupteur n'a pas varié, et le résultat était qu'il était légèrement plus rapide. ――Cependant, il semble qu'il soit difficile de se rendre compte de la différence de performance dans une utilisation quotidienne car la différence de performance n'est que d'autant plus après avoir fait 1 million de cas.

Augmenter le nombre de succursales

«Donc, je suis satisfait dans une certaine mesure, donc je vais augmenter le nombre de succursales. «À partir de là, j'ai trouvé que cela n'a pas beaucoup de sens de faire 100 cas, donc je vais effectuer avec 1 million de cas.

Tout d'abord, faites trois branches

--Omettre la source

• Le résultat de l'exécution est le suivant

Vérification

――Vous pouvez voir la différence de performance après 3 branches. ――Lorsque vous regardez la valeur moyenne, le changement est un peu plus rapide, n'est-ce pas? ――Cependant, cela peut être une erreur, alors augmentez le nombre de branches.

Faire 5 branches

«J'en ai choisi cinq en raison de la commodité du calcul et de mon humeur.

• Le résultat de l'exécution est le suivant

Vérification

• Vous pouvez voir la différence de performance après 5 branches. ――Hmm, est-ce dans la plage d'erreur?

Conclusion

Il n'y a pratiquement aucune différence de performances entre if et switch!

C'est une question d'attraper le titre, mais c'est ma conclusion «Je n'ai exécuté qu'un million de dossiers, mais je suis conscient que cela peut changer si d'autres sont ajoutés. Cependant, il semble que les performances ne changent pas de manière significative entre if et switch en fonction du nombre de branches et du nombre de processus, donc je pense qu'il est correct de choisir une implémentation plus facile à lire en fonction du temps. ――Si quelque chose ne va pas, ou si vous devriez le vérifier plus comme ça, veuillez laisser un commentaire ou une demande de modification!

Postscript

--Dans le commentaire, vous avez souligné que println est trop lourd, j'ai donc essayé de le réparer.

Main.java

import java.util.HashMap;
import java.util.Map;
import java.util.stream.IntStream;

public class Main {

    public static void main(String[] args) {

        long start = System.currentTimeMillis();

        IntStream.rangeClosed(0, 10000000).forEach(
                num -> {
                    if (num % 2 == 0) {
                        int num2 = 2;
                    } else if (num % 2 == 1){
                        int num3 = 2;
                    } else {
                        int num4 = 2;
                    }
                }
        );
        IntStream.rangeClosed(0, 10000000).forEach(
                num -> {
                    switch (num % 2) {
                        case 0:
                            int num2 = 2;
                            break;
                        case 1:
                            int num3 = 2;
                            break;
                        default:
                            int num4 = 2;
                            break;
                    }
                }
                        );
        long end = System.currentTimeMillis();
        System.out.println((end - start)  + "ms");

    }
}

• Le traitement des E / S étant lourd, je viens de déclarer des variables dans l'instruction for pour le moment. ――Veuillez me dire s'il y a une meilleure façon

Résultat d'exécution

«Il y avait une différence de performance d'environ 20 ms après avoir tourné 10 millions de caisses, mais je me demande s'il n'y a pas de problème avec la conclusion qu'il n'y a presque pas de différence. ――La validation du code d'octet se fera à une date ultérieure!