Conversion d'une énumération en chaîne

Aujourd'hui, nous allons parler de l'utilisation d'énumérations de chaînes, et plus particulièrement des enumclasses qui organisent l'interaction avec les constantes de chaîne. Conversion d'une énumération en chaîne - 1

Utilisation d'énumérations de chaînes

Lors du développement d'applications, vous devez périodiquement opérer sur un ensemble fixe de valeurs de chaîne. Cela pourrait être n'importe quoi. Par exemple, une liste de codes couleurs pris en charge par l'application, ou une liste d'appareils avec lesquels notre application peut interagir, les saisons, etc. Tout cela est un ensemble prédéfini de constantes de chaîne avec une structure commune, avec laquelle il est nécessaire d'établir une interaction de programme au niveau du code Java. Lorsque vous devez interagir avec un ensemble prédéfini de constantes de chaîne (et autres), la meilleure solution consiste à écrire votre propre enumclasse. Ci-dessous, nous examinerons des exemples de conversion enumen string.

Création d'énumérations de chaînes

Créons enumune classe qui stocke une liste des différents environnements pour déployer l'application, ainsi que l'URL de chaque environnement :

public enum Environment {
    PROD("https://release.application.com/"),
    TEST("https://test.application.com/"),
    AUTO_TEST("https://autotest.application.com/"),
    DEV("http://localhost:8080");

    private final String url;

    Environment(String url) {
        this.url = url;
    }

    public String getUrl() {
        return url;
    }
}

Dans cette classe nous avons défini 4 environnements :

PROD- libérer
TEST— pour les tests manuels
AUTO_TEST— environnement pour les autotests
DEV— local pour le développement et le débogage

Et aussi 4 URL pour chacun de ces environnements. Faisons attention à quelques points importants.

Chaque URL est une constante chaîne dans notre énumération : elles sont définies entre parenthèses à côté de chaque enumconstante.
Il doit y avoir un constructeur qui prend un argument du même type que chaque enumconstante.
La portée du constructeur est privatesoit package private.
Il est nécessaire de définir une variable - un champ de classe qui stockera les constantes chaîne que nous avons définies. Vous devez créer une méthode getter pour ce champ afin d'utiliser les valeurs des constantes chaîne en externe.

Itération sur les énumérations de chaînes

À ce stade, nous pouvons déjà parcourir toutes enumles valeurs disponibles, ainsi qu'obtenir les constantes de chaîne qui leur sont associées. Pour obtenir toutes les valeurs d'une enumclasse, vous devez utiliser la méthode values():

public class Main {
    public static void main(String[] args) {
        for (Environment env : Environment.values()) {
            System.out.println(env + " : " + env.getUrl());
        }
    }
}

Conclusion:


PROD : https://release.application.com/
TEST : https://test.application.com/
AUTO_TEST : https://autotest.application.com/
DEV : http://localhost:8080

Comme le montre l'exemple, pour imprimer le nom de enumla constante, nous l'avons passé à la méthode System.out.println, et pour imprimer l'url associée à cette constante, nous avons utilisé le getter que nous avons défini.

Obtenir une constante de chaîne à partir d'une énumération

Pour obtenir la valeur d’une constante chaîne, nous pouvons également appeler un getter sur n’importe quelle enumconstante :

public class Main {
    public static void main(String[] args) {

        String prodUrl = Environment.PROD.getUrl();
        String devUrl = Environment.DEV.getUrl();

        System.out.println("Production url is: " + prodUrl);
        System.out.println("Development url is: " + devUrl);

    }
}

Conclusion:


Production url is: https://release.application.com/
Development url is: http://localhost:8080

Obtenir une constante enum par nom

Parfois, il est nécessaire d'obtenir enumune constante par son nom de chaîne. Cela se fait à l'aide de la méthode valueOf(String), qui renvoie une constante par son nom :

public class Main {
    public static void main(String[] args) {

        Environment prod = Environment.valueOf("PROD");
        Environment dev = Environment.valueOf("DEV");

        System.out.println("Production url is: " + prod.getUrl());
        System.out.println("Development url is: " + dev.getUrl());

    }
}

Conclusion:


Production url is: https://release.application.com/
Development url is: http://localhost:8080

Mais la prudence est de mise ici. Si la méthode ne trouve pas enumde constante portant le nom spécifié, une exception sera levée java.lang.IllegalArgumentException.

Conversion d'une chaîne en énumération

Parfois, le besoin inverse surgit. Connaissant la valeur enum, obtenez enumla constante elle-même. Ceux. dans notre exemple, connaissant une certaine adresse, vous devez obtenir la Environmentconstante correspondante. Il existe plusieurs options pour ce faire. Et tous nécessitent une amélioration dans enumla classe elle-même. Option 1. Énumération à l'intérieur de la classe. Vous devez créer une méthode qui acceptera une chaîne et la comparera avec toutes les valeurs enumde la classe. S'il y a une correspondance, la méthode renverra l'énumération souhaitée. Pour notre exemple, nous devons Environmentcréer la méthode suivante dans la classe :

public static Environment getEnvByUrl(String url) {
    for (Environment env : values()) {
        // либо equalsIgnoreCase, на ваше усмотрение
        if (env.getUrl().equals(url)) {
            return env;
        }
    }

    // Либо просто вернуть null
    throw new IllegalArgumentException("No enum found with url: [" + url + "]");
}

Ensuite, nous pouvons obtenir enumde la chaîne comme ceci :

public class Main {
    public static void main(String[] args) {
        String url = "http://localhost:8080";
        Environment env = Environment.getEnvByUrl(url);

        System.out.println("Environment name for url=[" + url + "] is: " + env);
    }
}

Conclusion:


Environment name for url=[http://localhost:8080] is: DEV

Cette approche a ses inconvénients. A chaque fois, pour obtenir enumune constante, il faudra parcourir toutes les valeurs et faire un certain nombre de comparaisons. La pénalité de performance dans ce cas sera déterminée par le nombre de constantes et le nombre d'opérations similaires. La deuxième méthode pour résoudre ce problème ne pose pas ce problème. Code de classe completEnum :

public enum Environment {

    PROD("https://release.application.com/"),
    TEST("https://test.application.com/"),
    AUTO_TEST("https://autotest.application.com/"),
    DEV("http://localhost:8080");

    private final String url;

    Environment(String url) {
        this.url = url;
    }

    public String getUrl() {
        return url;
    }

    public static Environment getEnvByUrl(String url) {
        for (Environment env : values()) {
            if (env.getUrl().equals(url)) {
                return env;
            }
        }
        throw new IllegalArgumentException("No enum found with url: [" + url + "]");
    }
}

Option 2 : Utilisation HashMap Dans ce cas, nous créons une carte à l'intérieur de notre énumération et la remplissons une fois au moment de la compilation, puis en extrayons les valeurs :

public enum Environment {

    PROD("https://release.application.com/"),
    TEST("https://test.application.com/"),
    AUTO_TEST("https://autotest.application.com/"),
    DEV("http://localhost:8080");

    private final String url;

    Environment(String url) {
        this.url = url;
    }

    public String getUrl() {
        return url;
    }

    // Создаем static final карту
    private static final Map<String, Environment> LOOKUP_MAP = new HashMap<>();

    // Заполняем её всеми значениями
    static {
        for (Environment env : values()) {
            LOOKUP_MAP.put(env.getUrl(), env);
        }
    }

    // Возвращаем Environment по строковому url
    public static Environment getEnvByUrl(String url) {
        return LOOKUP_MAP.get(url);
    }
}

En termes d'utilisation, les deux options sont identiques :

public class Main {
    public static void main(String[] args) {
        String url = "http://localhost:8080";
        Environment env = Environment.getEnvByUrl(url);

        System.out.println("Environment name for url=[" + url + "] is: " + env);
    }
}

Conclusion:


Environment name for url=[http://localhost:8080] is: DEV

Mais cette méthode présente aussi des inconvénients. Premièrement, il y a beaucoup plus de code. Et deuxièmement, HashMaptoutes enumles valeurs seront stockées en permanence dans la mémoire de l'application. Comme vous pouvez le constater, tout a des avantages et des inconvénients. Mais étant donné que enumles classes stockent généralement moins de valeurs, les inconvénients seront presque invisibles. Il y a une mise en garde : si une telle opération (obtention d'une valeur Java Enum by String) est effectuée fréquemment, il est préférable d'utiliser la deuxième option. Vous pouvez en apprendre davantage sur ce sujet et Enumsur les cours en général dans le cours JavaRush. Les étudiants apprennent JavaRush Enumdès le premier cours du cinquième niveau .

Conversion d'une énumération en chaîne - 2

Commentaires

TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION