Zastąp valueof () i toString () w wyliczeniu Java

Wartości w moim enumto słowa, które muszą zawierać spacje, ale wyliczenia nie mogą mieć spacji w swoich wartościach, więc wszystko jest zebrane. Chcę nadpisać, toString()aby dodać te spacje tam, gdzie to powiem.

Chcę również, aby wyliczenie zapewniało prawidłowe wyliczenie, gdy używam valueOf()tego samego ciągu, do którego dodałem spacje.

Na przykład:

public enum RandomEnum
{
     StartHere,
     StopHere
}

Zaproszenie toString()na RandomEnumktórego wartość StartHerepowraca ciąg "Start Here". Wywołanie valueof()tego samego ciągu ( "Start Here") zwraca wartość wyliczenia StartHere.

W jaki sposób mogę to zrobić?

Możesz wypróbować ten kod. Ponieważ nie możesz przesłonić valueOfmetody, musisz zdefiniować niestandardową metodę ( getEnumw przykładowym kodzie poniżej), która zwraca potrzebną wartość i zmienić klienta, aby używał tej metody.

public enum RandomEnum {

    StartHere("Start Here"),
    StopHere("Stop Here");

    private String value;

    RandomEnum(String value) {
        this.value = value;
    }

    public String getValue() {
        return value;
    }

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

    public static RandomEnum getEnum(String value) {
        for(RandomEnum v : values())
            if(v.getValue().equalsIgnoreCase(value)) return v;
        throw new IllegalArgumentException();
    }
}

Spróbuj tego, ale nie jestem pewien, czy zadziała wszędzie :)

public enum MyEnum {
    A("Start There"),
    B("Start Here");

    MyEnum(String name) {
        try {
            Field fieldName = getClass().getSuperclass().getDeclaredField("name");
            fieldName.setAccessible(true);
            fieldName.set(this, name);
            fieldName.setAccessible(false);
        } catch (Exception e) {}
    }
}

Możesz użyć statycznej mapy w swoim wyliczeniu, która mapuje ciągi na stałe wyliczeniowe. Użyj go w metodzie statycznej „getEnum”. Pomija to potrzebę iteracji przez wyliczenia za każdym razem, gdy chcesz uzyskać jedną z jej wartości String.

public enum RandomEnum {

    StartHere("Start Here"),
    StopHere("Stop Here");

    private final String strVal;
    private RandomEnum(String strVal) {
        this.strVal = strVal;
    }

    public static RandomEnum getEnum(String strVal) {
        if(!strValMap.containsKey(strVal)) {
            throw new IllegalArgumentException("Unknown String Value: " + strVal);
        }
        return strValMap.get(strVal);
    }

    private static final Map<String, RandomEnum> strValMap;
    static {
        final Map<String, RandomEnum> tmpMap = Maps.newHashMap();
        for(final RandomEnum en : RandomEnum.values()) {
            tmpMap.put(en.strVal, en);
        }
        strValMap = ImmutableMap.copyOf(tmpMap);
    }

    @Override
    public String toString() {
        return strVal;
    }
}

Po prostu upewnij się, że statyczna inicjalizacja mapy następuje poniżej deklaracji stałych wyliczeniowych.

Przy okazji - ten typ „ImmutableMap” pochodzi z Google guava API i zdecydowanie polecam go w takich przypadkach.

EDYCJA - Zgodnie z komentarzami:

1. To rozwiązanie zakłada, że ​​każda przypisana wartość ciągu jest unikalna i różna od null. Biorąc pod uwagę, że twórca wyliczenia może to kontrolować i że ciąg odpowiada unikatowej i niezerowej wartości wyliczenia, wydaje się to bezpiecznym ograniczeniem.
2. Dodałem metodę „toSTring ()” zgodnie z pytaniem

A co z implementacją Java 8? (wartość null można zastąpić domyślnym wyliczeniem)

public static RandomEnum getEnum(String value) {
    List<RandomEnum> list = Arrays.asList(RandomEnum.values());
    return list.stream().filter(m -> m.value.equals(value)).findAny().orElse(null);
}

Lub możesz użyć:

...findAny().orElseThrow(NotFoundException::new);

Nie sądzę, żebyś osiągnął valueOf („Zacznij tutaj”) do pracy. Ale jeśli chodzi o spacje ... spróbuj następujących rzeczy ...

static private enum RandomEnum {
    R("Start There"), 
    G("Start Here"); 
    String value;
    RandomEnum(String s) {
        value = s;
    }
}

System.out.println(RandomEnum.G.value);
System.out.println(RandomEnum.valueOf("G").value);

Start Here
Start Here

Poniżej znajduje się ładna ogólna alternatywa dla valueOf ()

public static RandomEnum getEnum(String value) {
  for (RandomEnum re : RandomEnum.values()) {
    if (re.description.compareTo(value) == 0) {
      return re;
    }
  }
  throw new IllegalArgumentException("Invalid RandomEnum value: " + value);
}

Nadal masz możliwość zaimplementowania w swoim wyliczeniu tego:

public static <T extends Enum<T>> T valueOf(Class<T> enumType, String name){...}