java - usage - spring boot string to enum




Usando valores Enum como literais de string (12)

Qual é a melhor maneira de usar os valores armazenados em um Enum como literais de string? Por exemplo:

public enum Modes {
    some-really-long-string,
    mode1,
    mode2,
    mode3
}

Então mais tarde eu poderia usar Mode.mode1 para retornar sua representação de string como mode1 . Sem ter que continuar chamando Mode.mode1.toString() .


Cada enum tem um método name () e um valueOf (String). O primeiro retorna o nome da string do enum e o segundo fornece o valor enum cujo nome é a string. Isso é como o que você está procurando?

String name = Modes.mode1.name();
Modes mode = Modes.valueOf(name);

Há também um valorOf (Class, String) estático no próprio Enum, então você também pode usar

Modes mode = Enum.valueOf(Modes.class, name);

Como Benny Neugebauer menciona, você pode sobrescrever o toString (). No entanto, ao invés de sobrescrever o toString para cada campo enum, eu gosto mais de algo assim:

public enum Country{
    SPAIN("España"),
    ITALY("Italia"),
    PORTUGAL("Portugal");


    private String value;

    Country(final String value) {
        this.value = value;
    }

    public String getValue() {
        return value;
    }

    @Override
    public String toString() {
        return this.getValue();
    }
}

Você também pode adicionar um método estático para recuperar todos os campos, para imprimi-los todos, etc. Basta chamar getValue para obter a seqüência de caracteres associada a cada item Enum


Este método deve funcionar com qualquer enum :

public enum MyEnum {
    VALUE1,
    VALUE2,
    VALUE3;

    public int getValue() {
        return this.ordinal();
    }

    public static DataType forValue(int value) {
        return values()[value];
    }

    public String toString() {
        return forValue(getValue()).name();
    }
}

Para minhas enums, eu realmente não gosto de pensar nelas sendo alocadas com 1 String cada. É assim que eu implemento um método toString () em enums.

enum Animal
{
    DOG, CAT, BIRD;
    public String toString(){
        switch (this) {
            case DOG: return "Dog";
            case CAT: return "Cat";
            case BIRD: return "Bird";
        }
        return null;
    }
}

Você não pode. Eu acho que você tem quatro opções aqui. Todos os quatro oferecem uma solução, mas com uma abordagem ligeiramente diferente ...

Opção 1: use o name() interno name() em um enum. Isso é perfeitamente correto se você não precisar de nenhum formato de nomenclatura especial.

    String name = Modes.mode1.name(); // Returns the name of this enum constant, exactly as declared in its enum declaration.

Opção dois: adicione propriedades de substituição às suas enums se você quiser mais controle

public enum Modes {
    mode1 ("Fancy Mode 1"),
    mode2 ("Fancy Mode 2"),
    mode3 ("Fancy Mode 3");

    private final String name;       

    private Modes(String s) {
        name = s;
    }

    public boolean equalsName(String otherName) {
        // (otherName == null) check is not needed because name.equals(null) returns false 
        return name.equals(otherName);
    }

    public String toString() {
       return this.name;
    }
}

Opção Três: use finais estáticos em vez de enums:

public final class Modes {

    public static final String MODE_1 = "Fancy Mode 1";
    public static final String MODE_2 = "Fancy Mode 2";
    public static final String MODE_3 = "Fancy Mode 3";

    private Modes() { }
}

Opção Quatro: as interfaces têm todos os campos públicos, estáticos e finais:

public interface Modes {

    String MODE_1 = "Fancy Mode 1";
    String MODE_2 = "Fancy Mode 2";
    String MODE_3 = "Fancy Mode 3";  
}

Você pode simplesmente usar:

""+ Modes.mode1

Você pode tentar isto:

public enum Modes {
    some-really-long-string,
    mode1,
    mode2,
    mode3;

    public String toString(){
        switch(this) {
            case some-really-long-string:
                return "some-really-long-string";
            case mode2:
                return "mode2";
            default: return "undefined";
        }
    }

}


Você pode usar Mode.mode1.name() no entanto, muitas vezes você não precisa fazer isso.

Mode mode =
System.out.println("The mode is "+mode);

minha solução para o seu problema!

import java.util.HashMap;
import java.util.Map;

public enum MapEnumSample {
    Mustang("One of the fastest cars in the world!"), 
    Mercedes("One of the most beautiful cars in the world!"), 
    Ferrari("Ferrari or Mercedes, which one is the best?");

    private final String description;
    private static Map<String, String> enumMap;

    private MapEnumSample(String description) {
        this.description = description;
    }

    public String getEnumValue() {
        return description;
    }

    public static String getEnumKey(String name) {
        if (enumMap == null) {
            initializeMap();
        }
        return enumMap.get(name);
    }

    private static Map<String, String> initializeMap() {
        enumMap = new HashMap<String, String>();
        for (MapEnumSample access : MapEnumSample.values()) {
            enumMap.put(access.getEnumValue(), access.toString());
        }
        return enumMap;
    }

    public static void main(String[] args) {

        // getting value from Description
        System.out.println(MapEnumSample.getEnumKey("One of the fastest cars in the world!"));

        // getting value from Constant
        System.out.println(MapEnumSample.Mustang.getEnumValue());

        System.out.println(MapEnumSample.getEnumKey("One of the most beautiful cars in the world!"));
        System.out.println(MapEnumSample.Mercedes.getEnumValue());

        // doesnt exist in Enum
        System.out.println("Mustang or Mercedes, which one is the best?");
        System.out.println(MapEnumSample.getEnumKey("Mustang or Mercedes, which one is the best?") == null ? "I don't know!" : "I believe that "
                + MapEnumSample.getEnumKey("Ferrari or Mustang, which one is the best?") + " is the best!.");

        // exists in Enum
        System.out.println("Ferrari or Mercedes, wich one is the best?");
        System.out.println(MapEnumSample.getEnumKey("Ferrari or Mercedes, which one is the best?") == null ? "I don't know!" : "I believe that "
                + MapEnumSample.getEnumKey("Ferrari or Mercedes, which one is the best?") + " is the best!");

    }
}

mode1.name() ou String.valueOf(mode1) . Não fica melhor que isso, tenho medo


public enum Environment
{
    PROD("https://prod.domain.com:1088/"),
    SIT("https://sit.domain.com:2019/"),
    CIT("https://cit.domain.com:8080/"),
    DEV("https://dev.domain.com:21323/");

    private String url;

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

    public String getUrl() {
        return url;
    }
}

String prodUrl = Environment.PROD.getUrl();

Ele irá imprimir:

https://prod.domain.com:1088/

Este projeto para constantes de string enum funciona na maioria dos casos.


public enum Modes {
  MODE1("Mode1"),
  MODE2("Mode2"),
  MODE3("Mode3");

 private String value;
 public String getValue() {
    return value;
   }
 private Modes(String value) {
  this.value = value;
 } 
}

Você pode fazer uma chamada como abaixo, sempre que quiser obter o valor como uma string do enum.

Modes.MODE1.getvalue();

Isso retornará "Mode1" como uma String.







enums