Usando valores Enum como literais String

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

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

Mais tarde, eu poderia usar Mode.mode1para retornar sua representação de string como mode1. Sem ter que continuar ligando Mode.mode1.toString().

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 um: use o built-in name()em uma enumeração. Isso é perfeitamente bom se você não precisar de nenhum formato de nomeação especial.

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

Opção 2: adicione propriedades de substituição às suas enumerações, se 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 enumerações:

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";  
}

Cada enumeração possui um método name () e um método valueOf (String). O primeiro retorna o nome da seqüência de caracteres da enumeração e o último fornece o valor da enumeração cujo nome é a sequência. É assim que você está procurando?

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

Há também um valor estáticoOf (Class, String) no próprio Enum, para que você também possa usar

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

Você pode substituir o toString()método para cada valor de enumeração.

Exemplo:

public enum Country {

  DE {
    @Override
    public String toString() {
      return "Germany";
    }
  },
  IT {
    @Override
    public String toString() {
      return "Italy";
    }
  },
  US {
    @Override
    public String toString() {
      return "United States";
    }
  }

}

Uso:

public static void main(String[] args) {
  System.out.println(Country.DE); // Germany
  System.out.println(Country.IT); // Italy
  System.out.println(Country.US); // United States
}

Como Benny Neugebauer menciona, você pode sobrescrever o toString (). No entanto, em vez de sobrescrever o toString para cada campo de 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, imprimi-los, etc. Simplesmente chame getValue para obter a sequência associada a cada item do Enum

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

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 ligação como abaixo, sempre que quiser obter o valor como uma sequência da enumeração.

Modes.MODE1.getvalue();

Isso retornará "Mode1" como uma String.

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

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

Até onde eu sei, a única maneira de obter o nome seria

Mode.mode1.name();

Se você realmente precisar dessa maneira, no entanto, poderá fazer:

public enum Modes {
    mode1 ("Mode1"),
    mode2 ("Mode2"),
    mode3 ("Mode3");

    private String name;       

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

Para meus enums, não gosto de pensar neles sendo alocados com 1 String cada. É assim que eu implemento um método toString () em enumerações.

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ê pode simplesmente usar:

""+ Modes.mode1

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!");

    }
}

Enum é apenas uma classe especial. Enums podem armazenar campos adicionais, implementar métodos etc. Por exemplo

public enum Modes {
    mode1('a'),
    mode2('b'),
    mode3('c'),
    ;
    char c;

    private Modes(char c) {
        this.c = c;
    }
    public char character() {
        return c;
    }
}

Agora você pode dizer:

System.out.println(Modes.mode1.character())

e veja a saída: a

package com.common.test;

public  enum Days {


    monday(1,"Monday"),tuesday(2,"Tuesday"),wednesday(3,"Wednesday"),
    thrusday(4,"Thrusday"),friday(5,"Friday"),saturday(6,"Saturday"),sunday(7,"Sunday");

    private int id;
    private String desc;


    Days(int id,String desc){
        this.id=id;
        this.desc=desc;
    }

    public static String getDay(int id){

        for (Days day : Days.values()) {
            if (day.getId() == id) {
                return day.getDesc();
            }
        }
        return null;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }



};

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();
    }
}

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();

Irá imprimir:

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

Esse design para constantes de seqüência de caracteres enum funciona na maioria dos casos.

depois de muitas tentativas eu vim com esta solução

public static enum Operation {

    Addition, Subtraction, Multiplication, Division,;

    public String getUserFriendlyString() {
        if (this==Addition) {
            return " + ";
        } else if (this==Subtraction) {
            return " - ";
        } else if (this==Multiplication) {
            return " * ";
        } else if (this==Division) {
            return " / ";
        }
        return "undefined";
       }
}

Você pode tentar isso:

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";
        }
    }

}

Eu encontrei este é mais fácil para evitar erro de tipo:

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

    String str;

    Modes(){
        this.str = super.name();
    }

    @Override
    @NonNull
    public String toString() {
        return str;
    }

no entanto - isso pode funcionar quando você precisar usar uma String em um log / println ou sempre que o Java compilar o método toString () automaticamente, mas em uma linha de código como esta ->

// sample method that require (string,value)
intent.putExtra(Modes.mode1 ,shareElement.getMode()); // java error
// first argument enum does not return value

em vez disso, como mencionado acima, você ainda precisará estender a enumeração e usá-la .name() em casos como este:

intent.putExtra(Modes.mode1.name() ,shareElement.getMode());