java - validar - Usando los valores de Enum como literales de cadena

obtener valor de un enum java

Question

¿Cuál es la mejor manera de usar los valores almacenados en un Enum como literales de cadena? Por ejemplo:

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

Luego, más tarde, podría usar Mode.mode1 para devolver su representación de cadena como mode1 . Sin tener que seguir llamando Mode.mode1.toString() .

Answer 1

Cada enumeración tiene un método name () y valueOf (String). El primero devuelve el nombre de la cadena de la enumeración, y el segundo da el valor de enumeración cuyo nombre es la cadena. ¿Esto es lo que estás buscando?

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

También hay un valueOf (Class, String) estático en Enum, por lo que también podría usar

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

Answer 2

Como lo menciona Benny Neugebauer, puede sobrescribir el toString (). Sin embargo, en lugar de eso, sobrescribiendo el toString para cada campo de enumeración me gusta más algo como esto:

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

También puede agregar un método estático para recuperar todos los campos, imprimirlos todos, etc. Simplemente llame a getValue para obtener la cadena asociada a cada elemento Enum

Answer 3

Después de muchos intentos he venido con esta solución.

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

Answer 4

Enum es una clase un poco especial. Las enumeraciones pueden almacenar campos adicionales, implementar métodos, etc. Por ejemplo

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

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

Ahora puedes decir:

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

y ver salida: a

Answer 5

Este método debería funcionar con cualquier 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();
    }
}

Answer 6

Mi solución para tu 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!");

    }
}

Answer 7

Para mis enums no me gusta mucho pensar que se asignen con 1 String cada uno. Así es como implemento un método toString () en enumeraciones.

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

Answer 8

Podría anular el método toString() para cada valor de enumeración.

Ejemplo:

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
}

Answer 9

Por lo que sé, la única forma de obtener el nombre sería

Mode.mode1.name();

Si realmente lo necesitas de esta manera, sin embargo, podrías hacer:

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

    private String name;       

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

Answer 10

Puede usar Mode.mode1.name() sin embargo, a menudo no necesita hacer esto.

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

Answer 11

Puedes probar esto:

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

}

Answer 12

Simplemente puede utilizar:

""+ Modes.mode1

Answer 13

Usted no puede Creo que tienes cuatro opciones aquí. Los cuatro ofrecen una solución pero con un enfoque ligeramente diferente ...

Opción uno: use el name() incorporado name() en una enumeración. Esto está perfectamente bien si no necesita ningún formato de nombre especial.

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

Opción dos: agregue propiedades de anulación a sus enumeraciones si desea más control

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

Opción tres: usar finales estáticos en lugar de enumeraciones:

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

Opción Cuatro: las interfaces tienen todos los campos público, estático y final:

public interface Modes {

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

Answer 14

mode1.name() o String.valueOf(mode1) . No hay nada mejor que eso, me temo

Answer 15

Modes.MODE1.toString();

Es una manera fácil sin crear configuradores de interfaz, clase o get

Answer 16

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



};

Answer 17

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

Se imprimirá:

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

Este diseño para enumerar constantes de cadena funciona en la mayoría de los casos.

Answer 18

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

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

puede realizar una llamada como la siguiente en cualquier lugar donde desee obtener el valor como una cadena de la enumeración.

Modes.MODE1.getvalue();

Esto devolverá "Mode1" como una cadena.