ජාවා හි නූල් අගයකින් enum අගයක් ලබා ගන්නේ කෙසේද?

මට සාධාරණ සංඛ්‍යාවක් ඇති බව කියන්න

public enum Blah {
    A, B, C, D
}

මම නූලක එනුම් අගය සොයා ගැනීමට කැමතියි, උදාහරණයක් "A"ලෙස Blah.A. මෙය කළ හැක්කේ කෙසේද?

යනු Enum.valueOf()මම අවශ්ය ක්රමය? එසේ නම්, මම මෙය භාවිතා කරන්නේ කෙසේද?

ඔව්, Blah.valueOf("A")ඔබට ලබා දෙනු Blah.Aඇත.

නම වන විය යුතු බව සටහන නිශ්චිත : නඩුව ඇතුළු තරගය Blah.valueOf("a")හා Blah.valueOf("A ")දෙකම විසිකිරීම IllegalArgumentException.

ස්ථිතික ක්‍රම valueOf()සහ values()ඒවා සම්පාදනය කරන වේලාවේදී නිර්මාණය කර ඇති අතර ප්‍රභව කේතවල නොපෙන්වයි. ඒවා ජාවඩොක්හි දක්නට ලැබේ. උදාහරණයක් ලෙස, Dialog.ModalityTypeක්‍රම දෙකම පෙන්වයි.

ගණනය කිරීමේ අගයට පෙළ සමාන නොවේ නම් තවත් විසඳුමක්:

public enum Blah {
    A("text1"),
    B("text2"),
    C("text3"),
    D("text4");

    private String text;

    Blah(String text) {
        this.text = text;
    }

    public String getText() {
        return this.text;
    }

    public static Blah fromString(String text) {
        for (Blah b : Blah.values()) {
            if (b.text.equalsIgnoreCase(text)) {
                return b;
            }
        }
        return null;
    }
}

මෙන්න මම භාවිතා කරන නව උපයෝගීතාවයක්:

/**
 * A common method for all enums since they can't have another base class
 * @param <T> Enum type
 * @param c enum type. All enums must be all caps.
 * @param string case insensitive
 * @return corresponding enum, or null
 */
public static <T extends Enum<T>> T getEnumFromString(Class<T> c, String string) {
    if( c != null && string != null ) {
        try {
            return Enum.valueOf(c, string.trim().toUpperCase());
        } catch(IllegalArgumentException ex) {
        }
    }
    return null;
}

මගේ enum පන්තියේදී සාමාන්‍යයෙන් ටයිප් කිරීම සුරැකීමට මෙය මා සතුව ඇත:

public static MyEnum fromString(String name) {
    return getEnumFromString(MyEnum.class, name);
}

ඔබේ එනූම්ස් සියල්ලම කැප් නොවේ නම්, Enum.valueOfරේඛාව වෙනස් කරන්න .

එතරම් නරක මම භාවිතා කළ නොහැකි T.classසඳහා Enum.valueOfලෙස Tමැකෙනු ඇත.

Java ලදායී ජාවා ජෝෂුවා බ්ලොච් වෙතින් රටාව භාවිතා කරන්න :

(සංක්ෂිප්තතාව සඳහා සරල කර ඇත)

enum MyEnum {
    ENUM_1("A"),
    ENUM_2("B");

    private String name;

    private static final Map<String,MyEnum> ENUM_MAP;

    MyEnum (String name) {
        this.name = name;
    }

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

    // Build an immutable map of String name to enum pairs.
    // Any Map impl can be used.

    static {
        Map<String,MyEnum> map = new ConcurrentHashMap<String, MyEnum>();
        for (MyEnum instance : MyEnum.values()) {
            map.put(instance.getName(),instance);
        }
        ENUM_MAP = Collections.unmodifiableMap(map);
    }

    public static MyEnum get (String name) {
        return ENUM_MAP.get(name);
    }
}

මෙයද බලන්න:

එනුම් සහ සිද්ධි සිතියම භාවිතා කරමින් ඔරකල් ජාවා උදාහරණය

එනුම් වර්ගයක ස්ථිතික කුට්ටි ක්‍රියාත්මක කිරීමේ අනුපිළිවෙල

ජාවා එනුම් එකක් එහි සංගීත අගයෙන් සොයා ගන්නේ කෙසේද?

ඔබේ නඩුව ගැනද ඔබ සැලකිලිමත් විය යුතුය. මට පැහැදිලි කිරීමට ඉඩ දෙන්න: Blah.valueOf("A")වැඩ කිරීම, නමුත් Blah.valueOf("a")වැඩ නොකරනු ඇත. එවිට නැවතත් ක්‍රියාත්මක Blah.valueOf("a".toUpperCase(Locale.ENGLISH))වනු ඇත.

සංස්කරණය tc මත පදනම්ව
වෙනස් toUpperCaseකරන toUpperCase(Locale.ENGLISH)ලදි . අදහස් දැක්වීම සහ ජාවා ලියකියවිලි

edit2 සුලයි පෙන්වා දෙනLocale.US පරිදි ඇන්ඩ්‍රොයිඩ් මත ඔබ භාවිතා කළ යුතුය .

මෙන්න ඕනෑම එනුම් සඳහා එය කළ හැකි ක්‍රමයක් වන අතර එය සිද්ධි සංවේදී නොවේ.

/** 
 * Finds the value of the given enumeration by name, case-insensitive. 
 * Throws an IllegalArgumentException if no match is found.  
 **/
public static <T extends Enum<T>> T valueOfIgnoreCase(
        Class<T> enumeration, String name) {

    for (T enumValue : enumeration.getEnumConstants()) {
        if (enumValue.name().equalsIgnoreCase(name)) {
            return enumValue;
        }
    }

    throw new IllegalArgumentException(String.format(
        "There is no value with name '%s' in Enum %s",
        name, enumeration.getName()
    ));
}

භාවිතා Blah.valueOf(string)කිරීම වඩාත් සුදුසු නමුත් ඔබටද භාවිතා Enum.valueOf(Blah.class, string)කළ හැකිය.

ජාවා 8 හෝ ඊට පසු, ධාරා භාවිතා කරමින් :

public enum Blah
{
    A("text1"),
    B("text2"),
    C("text3"),
    D("text4");

    private String text;

    Blah(String text) {
        this.text = text;
    }

    public String getText() {
        return this.text;
    }

    public static Optional<Blah> fromText(String text) {
        return Arrays.stream(values())
          .filter(bl -> bl.text.equalsIgnoreCase(text))
          .findFirst();
    }
}

ඔබට ඔබේම උපයෝගීතාවයක් ලිවීමට අවශ්‍ය නැතිනම් ගූගල් භාවිතා කරන්න guava පුස්තකාලය:

Enums.getIfPresent(Blah.class, "A")

ජාවා ශ්‍රිතය තුළ මෙන් නොව, එය බ්ලහ් හි A තිබේදැයි පරීක්ෂා කර බලමු.

මගේ ශත 2 මෙහි: Java8 Streams + භාවිතා කරමින් නිශ්චිත නූලක් පරීක්ෂා කිරීම:

public enum MyEnum {
    VALUE_1("Super"),
    VALUE_2("Rainbow"),
    VALUE_3("Dash"),
    VALUE_3("Rocks");

    private final String value;

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

    /**
     * @return the Enum representation for the given string.
     * @throws IllegalArgumentException if unknown string.
     */
    public static MyEnum fromString(String s) throws IllegalArgumentException {
        return Arrays.stream(MyEnum.values())
                .filter(v -> v.value.equals(s))
                .findFirst()
                .orElseThrow(() -> new IllegalArgumentException("unknown value: " + s));
    }
}

** සංස්කරණය කරන්න **

කිරීමට කාර්යය නැවත නම් fromString()නොවන බව ද භාවිතා කර නම් සිට, ඔබ ජාවා පරිගණක භාෂාව යම් ප්රතිලාභ ලබා ඇත; උදාහරණයක් වශයෙන්:

1. HeaderParam විවරණයේදී වර්ග සෘජුවම පරිවර්තනය කිරීම

ඔබට මෙය අවශ්‍ය විය හැකිය:

public enum ObjectType {
    PERSON("Person");

    public String parameterName;

    ObjectType(String parameterName) {
        this.parameterName = parameterName;
    }

    public String getParameterName() {
        return this.parameterName;
    }

    //From String method will return you the Enum for the provided input string
    public static ObjectType fromString(String parameterName) {
        if (parameterName != null) {
            for (ObjectType objType : ObjectType.values()) {
                if (parameterName.equalsIgnoreCase(objType.parameterName)) {
                    return objType;
                }
            }
        }
        return null;
    }
}

තවත් එක් එකතු කිරීමක්:

   public static String fromEnumName(String parameterName) {
        if (parameterName != null) {
            for (DQJ objType : DQJ.values()) {
                if (parameterName.equalsIgnoreCase(objType.name())) {
                    return objType.parameterName;
                }
            }
        }
        return null;
    }

මෙය ඔබට අගය එනුම් නාමයකින් ලබා දෙනු ඇත. උදා: ඔබ "පුද්ගලයාව" සිට එනම් නම් වලින් ලබා දෙන්නේ නම් එය ඔබට එනුම් අගය ලබා දෙනු ඇත, එනම් "පුද්ගලයා"

name()එනූම් හි ස්ථිතික ක්‍රමවේදය භාවිතා කරමින් මෙය කළ හැකි තවත් ක්‍රමයක් . නම මඟින් එම එනූම් සෑදීම සඳහා භාවිතා කරන ලද නිවැරදි නූල නැවත ලබා දෙනු ඇත.

public enum Blah {

    A, B, C, D;

    public static Blah getEnum(String s){
        if(A.name().equals(s)){
            return A;
        }else if(B.name().equals(s)){
            return B;
        }else if(C.name().equals(s)){
            return C;
        }else if (D.name().equals(s)){
            return D;
        }
        throw new IllegalArgumentException("No Enum specified for this string");
    }
}

පරීක්ෂා කිරීම:

System.out.println(Blah.getEnum("B").name());

//it will print B  B

දේවානුභාවයෙන්: ජාවා හි එනුම් සඳහා උදාහරණ 10 ක්

ගුවා පුස්තකාල භාවිතා කරමින් විසඳුම. GetPlanet () ක්‍රමය සංවේදී නොවන බැවින් getPlanet ("MerCUrY") විසින් ප්ලැනට් නැවත ලබා දෙනු ඇත. MERCURY.

package com.universe.solarsystem.planets;
import org.apache.commons.lang3.StringUtils;
import com.google.common.base.Enums;
import com.google.common.base.Optional;

//Pluto and Eris are dwarf planets, who cares!
public enum Planet {
   MERCURY,
   VENUS,
   EARTH,
   MARS,
   JUPITER,
   SATURN,
   URANUS,
   NEPTUNE;

   public static Planet getPlanet(String name) {
      String val = StringUtils.trimToEmpty(name).toUpperCase();
      Optional <Planet> possible = Enums.getIfPresent(Planet.class, val);
      if (!possible.isPresent()) {
         throw new IllegalArgumentException(val + "? There is no such planet!");
      }
      return possible.get();
   }
}

පෙර පිළිතුරු වලට එකතු කිරීම සඳහා, සහ ශුන්‍යයන් සහ එන්පීඊ වටා ඇති සමහර සාකච්ඡා සඳහා ආමන්ත්‍රණය කිරීම, නොපැමිණෙන / අවලංගු අවස්ථා හැසිරවීමට මම ගුවා විකල්ප භාවිතා කරමි. URI / පරාමිති විග්‍රහ කිරීම සඳහා මෙය විශිෂ්ට ලෙස ක්‍රියා කරයි.

public enum E {
    A,B,C;
    public static Optional<E> fromString(String s) {
        try {
            return Optional.of(E.valueOf(s.toUpperCase()));
        } catch (IllegalArgumentException|NullPointerException e) {
            return Optional.absent();
        }
    }
}

නොදන්නා අය සඳහා, විකල්ප සමඟ ශුන්‍ය වීම වළක්වා ගැනීම පිළිබඳ තවත් තොරතුරු මෙන්න: https://code.google.com/p/guava-libraries/wiki/UsingAndAvoidingNullExplained#Optional

ජාවා 8 හි ස්ථිතික සිතියම් රටාව ඊටත් වඩා පහසු වන අතර එය මගේ මනාප ක්‍රමයයි. ඔබට ජැක්සන් සමඟ එනූම් භාවිතා කිරීමට අවශ්‍ය නම්, ඔබට ස්ට්‍රිං වෙත අභිබවා ගොස් නම වෙනුවට එය භාවිතා කළ හැකිය, ඉන්පසු විවරණය කරන්න@JsonValue

public enum MyEnum {
    BAR,
    BAZ;
    private static final Map<String, MyEnum> MAP = Stream.of(MyEnum.values()).collect(Collectors.toMap(Enum::name, Function.identity()));
    public static MyEnum fromName(String name){
        return MAP.get(name);
    }
}

public enum MyEnumForJson {
    BAR("bar"),
    BAZ("baz");
    private static final Map<String, MyEnumForJson> MAP = Stream.of(MyEnumForJson.values()).collect(Collectors.toMap(Object::toString, Function.identity()));
    private final String value;

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

    @JsonValue
    @Override
    public String toString() {
        return value;
    }

    public static MyEnumForJson fromValue(String value){
        return MAP.get(value);
    }
}

public static MyEnum getFromValue(String value) {
    MyEnum resp = null;
    MyEnum nodes[] = values();
    for(int i = 0; i < nodes.length; i++) {
        if(nodes[i].value.equals(value)) {
            resp = nodes[i];
            break;
        }
    }
    return resp;
}

ඕ (1) හැෂ්මැප් භාවිතා කරන සකසුරුවම් ජනනය කළ කේතයෙන් දේවානුභාවයෙන්.

public enum USER {
        STUDENT("jon",0),TEACHER("tom",1);

        private static final Map<String, Integer> map = new HashMap<>();

        static {
                for (USER user : EnumSet.allOf(USER.class)) {
                        map.put(user.getTypeName(), user.getIndex());
                }
        }

        public static int findIndexByTypeName(String typeName) {
                return map.get(typeName);
        }

        private USER(String typeName,int index){
                this.typeName = typeName;
                this.index = index;
        }
        private String typeName;
        private int index;
        public String getTypeName() {
                return typeName;
        }
        public void setTypeName(String typeName) {
                this.typeName = typeName;
        }
        public int getIndex() {
                return index;
        }
        public void setIndex(int index) {
                this.index = index;
        }

}

එනුම් ඉතා ප්‍රයෝජනවත් වේ, Enumපහත දැක්වෙන උදාහරණය ලෙස විවිධ ක්ෂේත්‍රවල සමහර ක්ෂේත්‍ර සඳහා විස්තරයක් එක් කිරීමට මම බොහෝ දේ භාවිතා කර ඇත්තෙමි .

public enum Status {

    ACT(new String[] { "Accepted", "مقبول" }),
    REJ(new String[] { "Rejected", "مرفوض" }),
    PND(new String[] { "Pending", "في الانتظار" }),
    ERR(new String[] { "Error", "خطأ" }),
    SNT(new String[] { "Sent", "أرسلت" });

    private String[] status;

    public String getDescription(String lang) {
        return lang.equals("en") ? status[0] : status[1];
    }

    Status(String[] status) {
        this.status = status;
    }
}

getDescription(String lang)ක්‍රමයට සම්මත කළ භාෂා කේතය මත පදනම්ව ඔබට ගතිකව විස්තරය ලබා ගත හැකිය , උදාහරණයක් ලෙස:

String statusDescription = Status.valueOf("ACT").getDescription("en");

කුමක් ගැනද?

public enum MyEnum {
    FIRST,
    SECOND,
    THIRD;

    public static Optional<MyEnum> fromString(String value){
        try{
            return Optional.of(MyEnum.valueOf(value));
        }catch(Exception e){
            return Optional.empty();
        }
    }
}

java.lang.Enum ජාවා හි සියලුම ගණන් කිරීමේ වර්ග සඳහා ලබා ගත හැකි ප්‍රයෝජනවත් ක්‍රම කිහිපයක් නිර්වචනය කරයි:

• name()ඕනෑම එනුම් නියතයන්ගේ නම ලබා ගැනීමට ඔබට ක්‍රමයක් භාවිතා කළ හැකිය . එනූම් නියතයන් ලිවීමට භාවිතා කරන නූල් වචනාර්ථයෙන් ඔවුන්ගේ නම වේ.
• එලෙසම values()සියලු එනූම් නියතයන්ගේ පෙළක් එනූම් වර්ගයකින් ලබා ගත හැකිය.
• අසන ලද ප්‍රශ්නය සඳහා, valueOf()පහත දැක්වෙන පරිදි, ජාවා හි ඕනෑම නූල් නියතයක් බවට පරිවර්තනය කිරීමට ඔබට ක්‍රමයක් භාවිතා කළ හැකිය .

public class EnumDemo06 {
    public static void main(String args[]) {
        Gender fromString = Gender.valueOf("MALE");
        System.out.println("Gender.MALE.name() : " + fromString.name());
    }

    private enum Gender {
        MALE, FEMALE;
    }
}

Output:
Gender.MALE.name() : MALE

මෙම කේත valueOf()ස්නිපටයේ, ක්‍රමය මඟින් නියත ස්ත්‍රී පුරුෂ භාවය ලබා දෙයි "MALE". MALE, එම ප්‍රතිලාභයේ නම අමතන්න .

Apache හි කාටත් පොදු-lang පුස්තකාල ස්ථිතික සේවයක් org.apache.commons.lang3.EnumUtils.getEnum ඔබගේ නිඛිල වර්ගය සඳහා සංගීත සිතියම්ගත වනු ඇත. ජෙෆ්රීස් මෙන් එකම පිළිතුරක් ඇති නමුත් එය දැනටමත් වනාන්තරයේ නොමැති විට ඔබේම දෑ පෙරළන්නේ ඇයි?

ප්‍රයෝජනවත් උපයෝගීතාවයක් සහිතව, ඉහළම ශ්‍රේණිගත කළ පිළිතුරට එකතු කිරීම ...

valueOf() එහි ආදානයට අකමැති අවස්ථාවන්හිදී වෙනස් ව්‍යතිරේක දෙකක් විසි කරයි.

• IllegalArgumentException
• NullPointerExeption

ඔබේ අවශ්‍යතාවයන් නම්, ඔබේ සංගීත භාණ්ඩය අනිවාර්යයෙන්ම enum අගයකට ගැලපෙන බවට කිසිදු සහතිකයක් නොමැති නම්, උදාහරණයක් ලෙස String දත්ත දත්ත ගබඩාවකින් පැමිණ එනුමයේ පැරණි අනුවාදයක් අඩංගු විය හැකි නම්, ඔබට මේවා හැසිරවිය යුතුය බොහෝ විට...

ඉතින් මම ලියූ නැවත භාවිතා කළ හැකි ක්‍රමයක් මෙන්න, අප පසුකර යන නූලට නොගැලපේ නම් පෙරනිමි එනූම් එකක් ආපසු ලබා දීමට අපට ඉඩ ලබා දේ.

private static <T extends Enum<T>> T valueOf( String name , T defaultVal) {
        try {
            return Enum.valueOf(defaultVal.getDeclaringClass() , name);
        } catch (IllegalArgumentException | NullPointerException e) {
            return defaultVal;
        }
    }

එය මේ ආකාරයට භාවිතා කරන්න:

public enum MYTHINGS {
    THINGONE,
    THINGTWO
}

public static void main(String [] asd) {
  valueOf("THINGTWO" , MYTHINGS.THINGONE);//returns MYTHINGS.THINGTWO
  valueOf("THINGZERO" , MYTHINGS.THINGONE);//returns MYTHINGS.THINGONE
}

ලෙස switch-version තවමත් සඳහන් කර නොමැත මම එය හඳුන්වා (විශ්රාම වැටුප් ගේ නිඛිල නැවත භාවිතා කරමින්):

  private enum Blah {
    A, B, C, D;

    public static Blah byName(String name) {
      switch (name) {
        case "A":
          return A;
        case "B":
          return B;
        case "C":
          return C;
        case "D":
          return D;
        default:
          throw new IllegalArgumentException(
            "No enum constant " + Blah.class.getCanonicalName() + "." + name);
      }
    }
  }

මෙය valueOf(String name)ක්‍රමයට අමතර වටිනාකමක් ලබා නොදෙන බැවින් , අපට වෙනත් හැසිරීමක් අවශ්‍ය නම් අතිරේක ක්‍රමයක් නිර්වචනය කිරීම අර්ථවත් කරයි. අපට මතු කිරීමට අවශ්‍ය නැතිනම් IllegalArgumentExceptionඅපට එය ක්‍රියාත්මක කිරීම වෙනස් කළ හැකිය:

  private enum Blah {
    A, B, C, D;

    public static Blah valueOfOrDefault(String name, Blah defaultValue) {
      switch (name) {
        case "A":
          return A;
        case "B":
          return B;
        case "C":
          return C;
        case "D":
          return D;
        default:
          if (defaultValue == null) {
            throw new NullPointerException();
          }
          return defaultValue;
      }
    }
  }

පෙරනිමි අගය සැපයීම මගින් අපි තබා කොන්ත්රාත්තුව ක Enum.valueOf(String name)ක වීසි තොරව IllegalArgumentException කිසිම අවස්ථාවකදී බව ආකාරයට nullආපසු එවනු ලැබේ. ඒ නිසා අපි විසි NullPointerExceptionනම නම් nullහා නඩුවේ defaultනම් defaultValueවේ null. කොහොමද ඒක valueOfOrDefaultවැඩ.

මෙම ප්‍රවේශය ජාවා 8 Mapහි ක්‍රමවේදයක් සපයන -ඉන්ටර්ෆේස් හි සැලසුම අනුගමනය කරයි Map.getOrDefault(Object key, V defaultValue).

ප්‍රතිලෝම ආකාරයෙන් අල්ලා ගන්නා තවත් උපයෝගීතාවයක්. එම නාමය හඳුනාගත හැකි අගයක් භාවිතා කිරීම මිස එහි නම නොවේ.

import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.EnumSet;

public class EnumUtil {

    /**
     * Returns the <code>Enum</code> of type <code>enumType</code> whose a 
     * public method return value of this Enum is 
     * equal to <code>valor</code>.<br/>
     * Such method should be unique public, not final and static method 
     * declared in Enum.
     * In case of more than one method in match those conditions
     * its first one will be chosen.
     * 
     * @param enumType
     * @param value
     * @return 
     */
    public static <E extends Enum<E>> E from(Class<E> enumType, Object value) {
        String methodName = getMethodIdentifier(enumType);
        return from(enumType, value, methodName);
    }

    /**
     * Returns the <code>Enum</code> of type <code>enumType</code> whose  
     * public method <code>methodName</code> return is 
     * equal to <code>value</code>.<br/>
     *
     * @param enumType
     * @param value
     * @param methodName
     * @return
     */
    public static <E extends Enum<E>> E from(Class<E> enumType, Object value, String methodName) {
        EnumSet<E> enumSet = EnumSet.allOf(enumType);
        for (E en : enumSet) {
            try {
                String invoke = enumType.getMethod(methodName).invoke(en).toString();
                if (invoke.equals(value.toString())) {
                    return en;
                }
            } catch (Exception e) {
                return null;
            }
        }
        return null;
    }

    private static String getMethodIdentifier(Class<?> enumType) {
        Method[] methods = enumType.getDeclaredMethods();
        String name = null;
        for (Method method : methods) {
            int mod = method.getModifiers();
            if (Modifier.isPublic(mod) && !Modifier.isStatic(mod) && !Modifier.isFinal(mod)) {
                name = method.getName();
                break;
            }
        }
        return name;
    }
}

උදාහරණයක්:

public enum Foo {
    ONE("eins"), TWO("zwei"), THREE("drei");

    private String value;

    private Foo(String value) {
        this.value = value;
    }

    public String getValue() {
        return value;
    }
}

EnumUtil.from(Foo.class, "drei")ප්‍රතිලාභ Foo.THREE, මන්ද එය getValue"ඩ්‍රයි" හා සැසඳීමට භාවිතා කරනු ඇත , එය අද්විතීය මහජනතාවකි, ෆූ හි අවසාන සහ ස්ථිතික ක්‍රමය නොවේ. ෆූට පොදු දේට වඩා වැඩි යමක් තිබේ නම්, අවසාන හා ස්ථිතික නොවේ, උදාහරණයක් ලෙස, getTranslate“ඩ්‍රයි” ආපසු ලබා දෙන විට, අනෙක් ක්‍රමය භාවිතා කළ හැකිය : EnumUtil.from(Foo.class, "drei", "getTranslate").

විධාන ගණනය කිරීම්වලට නූල් ලෙස විග්‍රහ කිරීම සඳහා මෙවැනි ක්‍රියාවලියක් භාවිතා කිරීමට මම කැමතියි. මට සාමාන්‍යයෙන් එක් ගණනය කිරීමක් "නොදන්නා" ලෙස ඇත, එබැවින් අනෙක් ඒවා සොයා නොගත් විට (එය සංවේදී නොවන පදනමක් මත වුවද) ශුන්‍යයට වඩා ආපසු ලබා ගැනීමට උපකාරී වේ (එහි අර්ථය වටිනාකමක් නැත). එබැවින් මම මෙම ප්‍රවේශය භාවිතා කරමි.

static <E extends Enum<E>> Enum getEnumValue(String what, Class<E> enumClass) {
    Enum<E> unknown=null;
    for (Enum<E> enumVal: enumClass.getEnumConstants()) {  
        if (what.compareToIgnoreCase(enumVal.name()) == 0) {
            return enumVal;
        }
        if (enumVal.name().compareToIgnoreCase("unknown") == 0) {
            unknown=enumVal;
        }
    }  
    return unknown;
}

කොට්ලින් විසඳුම

දිගුවක් සාදා ඉන්පසු අමතන්න valueOf<MyEnum>("value"). වර්ගය අවලංගු නම්, ඔබට එය අහෝසි වී එය හැසිරවීමට සිදුවේ

inline fun <reified T : Enum<T>> valueOf(type: String): T? {
    return try {
        java.lang.Enum.valueOf(T::class.java, type)
    } catch (e: Exception) {
        null
    }
}

විකල්පයක් ලෙස, ඔබට පෙරනිමි අගයක් සැකසිය හැකිය, ඇමතීම valueOf<MyEnum>("value", MyEnum.FALLBACK)සහ ශුන්‍ය ප්‍රතිචාරයක් වළක්වා ගත හැකිය. පෙරනිමිය ස්වයංක්‍රීය වීමට ඔබට ඔබේ විශේෂිත එනුම් දිගු කළ හැකිය

inline fun <reified T : Enum<T>> valueOf(type: String, default: T): T {
    return try {
        java.lang.Enum.valueOf(T::class.java, type)
    } catch (e: Exception) {
        default
    }
}

නැතහොත් ඔබට මේ දෙකම අවශ්‍ය නම්, දෙවැන්න කරන්න:

inline fun <reified T : Enum<T>> valueOf(type: String, default: T): T = valueOf<T>(type) ?: default

එනුම් නම් ලබා ගැනීම සඳහා වේගවත්ම ක්‍රමය නම් යෙදුම ආරම්භ වන විට එනුම් පෙළ සහ අගය පිළිබඳ සිතියමක් නිර්මාණය කිරීම සහ නම ලබා ගැනීම සඳහා බ්ලාහ්.ජෙට් එනුම් නේම් () ශ්‍රිතය අමතන්න:

public enum Blah {
    A("text1"),
    B("text2"),
    C("text3"),
    D("text4");

    private String text;
    private HashMap<String, String> map;
    Blah(String text) {
    this.text = text;
    }

    public String getText() {
      return this.text;
    }

    static{
      createMapOfTextAndName();
    }

    public static void createMapOfTextAndName() {
        map = new HashMap<String, String>();
        for (Blah b : Blah.values()) {
             map.put(b.getText(),b.name());
        }
    }
    public static String getEnumName(String text) {
        return map.get(text.toLowerCase());
    } 
}