Java: Si vs Commutateur

Ne vous inquiétez pas des performances; utilisez la syntaxe qui exprime le mieux ce que vous faites. Seulement après avoir (a) démontré un déficit de performance; et (b) localisé à la routine en question, alors seulement devriez-vous vous soucier de la performance. Pour mon argent, la syntaxe de cas est plus appropriée ici.

Il semble que vous ayez énuméré les valeurs, donc peut-être qu'une énumération est en ordre?

enum BRANCH {
  A,B, ... Y,Z;
}

, Puis dans votre code :

BRANCH branch = BRANCH.valueOf( WORD[ INDEX ] );

De plus, il y a un bogue possible dans votre code où "A" == "A" peut être faux en fonction de l'identité de l'objet des "A".

Pas tout à fait une réponse à votre question, mais il y a en fait un bug dans votre code, vous devriez avoir une pause après chaque cas:

switch ( WORD[ INDEX ] ) {
    case 'A' : branch = BRANCH.A; break;
    /* B through to Y */
    case 'Z' : branch = BRANCH.Z; break;
}

Je ne pense pas que les différences de performances seront trop importantes ici, mais si vous vous souciez vraiment des performances, et si ce code est exécuté très fréquemment, voici une autre option:

// Warning, untested code.
BRANCH[] branchLookUp = {BRANCH.A, BRANCH.B, ..., BRANCH.Z};

branch = branchLookUp[WORD[INDEX] - 'A'];

Assurez-vous d'encapsuler cela et de bien le documenter.

Honnêtement, je ne pense pas que la performance compte dans ce cas. C'est vraiment au compilateur et à son optimisation.

Si vous avez une instruction switch avec des valeurs intégrales consécutives, selon la langue, elle peut être optimisée en une table de branches, ce qui est très rapide. Ce n'est pas plus lent, de toute façon!

De plus, l'utilisation de if/else if serait une amélioration par rapport à if, pour des cas tels que celui-ci dans lesquels vos cas sont mutuellement exclusifs. Pas de sens de faire 25 contrôles supplémentaires après avoir fait correspondre A.

, Mais, fondamentalement, toute différence de performances est négligeable, et vous devez utiliser la syntaxe, qui dans ce cas est l'instruction switch. Assurez-vous de séparer vos cas avec des pauses cependant.

Voici un moyen d'éviter toutes les déclarations de cas.

import java.util.HashMap;

public class Dictionary {
    private static Dictionary                       ROOT;
    private boolean                                 terminus;
    private final HashMap<Character, Dictionary>    dictionaries    = new HashMap<Character, Dictionary>();

    private void ensureBranch(char c) {
        if (getBranch(c) != null)
            return;
        dictionaries.put(c, new Dictionary());
    }

    private Dictionary getBranch(char c) {
        return dictionaries.get(c);
    }

    public static boolean is(final String string) {
        ensureRoot();
        return is(chars(string), ROOT, 0, string.length() - 1);
    }

    public static void add(final String... strings) {
        ensureRoot();
        for (final String string : strings)
            add(chars(string), ROOT, 0, string.length() - 1);
    }

    private static void ensureRoot() {
        if (ROOT == null)
            ROOT = new Dictionary();
    }

    private static char[] chars(final String string) {
        return string.toUpperCase().toCharArray();
    }

    private Dictionary() {
        this.terminus = false;
    }

    private static void add(final char[] word, final Dictionary dictionary, final int index, final int limit) {
        Dictionary branch = getBranch(word, dictionary, index);
        if (index == limit)
            branch.terminus = true;
        else
            add(word, branch, index + 1, limit);
    }

    private static Dictionary getBranch(final char[] word, final Dictionary dictionary, final int index) {
        final char c = word[index];
        dictionary.ensureBranch(c);
        return dictionary.getBranch(c);
    }

    private static boolean is(final char[] word, final Dictionary dictionary, final int index, final int limit) {
        Dictionary branch = dictionary.getBranch(word[index]);
        if (branch == null)
            return false;
        if (index == limit)
            return branch.terminus;
        return is(word, branch, index + 1, limit);
    }
}

Je sais que ce n'est pas du tout ce que vous demandez, mais n'êtes-vous pas en train de faire cela?

public class Dictionary {
    private static final Set<String> WORDS = new HashSet<String>();

    public static void add(final String... STRINGS) {
        for (String str : STRINGS) {
            WORDS.add(str.toUpperCase());
        }
    }

    public static boolean is(final String STRING) {
        return WORDS.contains(STRING.toUpperCase());
    }
}

Cherchez-vous simplement quelque chose d'un peu plus efficace en mémoire?

L'instruction switch doit utiliser un hachage pour sélectionner la casse à laquelle aller. À partir de là, chaque cas suivant sera également exécuté s'il n'y a pas d'instructions break. Par exemple, avec votre code, si vous activez X, il passera immédiatement à X, puis Y, puis Z. Voir le Tutoriel Java.

Le switch devrait être logarithmique et le if linéaire, en supposant que le compilateur ne trouve rien d'intelligent. Mais les longs switchsont difficiles à lire et aussi sujets aux bogues-comme indiqué, le commutateur que vous avez ci-dessus n'a pas de pauses, et il va tomber dans tous les cas.

Pourquoi ne pas prépeupler un Map à la place, et utiliser simplement Map.get()?

private static final Map<Char, Whatever> BRANCHES = Collections.unmodifiableMap(new HashMap<Char, Whatever>() {{
    put('A', BRANCH.A);
    ...
    put('Z', BRANCH.Z);
}}

public void getBranch(char[] WORD, int INDEX) {
    return BRANCHES.get(WORD[INDEX]);
}

Comme indiqué ci-dessus, si BRANCH est un Enum, ce comportement doit être correctement dans le Enum.

(Ce sont WORD, INDEX et BRANCH ici, de toute façon? D'après les noms, ils devraient être des constantes, mais vous ne pouvez pas vraiment avoir de tableaux constants-le contenu est modifiable; il n'y aurait pas beaucoup d'intérêt à créer une "structure" constante; et il n'y aurait certainement pas beaucoup d'intérêt à changer ou à changer en fonction des constantes....)

Je pense que c'est plus une question de style que de performance. Je pense que dans ce cas, l'instruction switch est plus appropriée que si. Je ne suis pas sûr qu'il y ait beaucoup de différence dans les performances.