Java의 문자열 값에서 열거형 값을 얻는 방법은 무엇입니까?
https://stackoverflow.com/questions/604424
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
Russian문제
내가 다음과 같은 열거형을 가지고 있다고 가정해 보세요.
public enum Blah {
A, B, C, D
}
예를 들어 문자열의 열거형 값을 찾고 싶습니다. "A" 어느 것이 될 것인가? Blah.A.어떻게 이런 일이 가능할까요?
는 Enum.valueOf() 나에게 필요한 방법은?그렇다면 이것을 어떻게 사용할까요?
해결책
예, Blah.valueOf("A") 당신에게 줄 것입니다 Blah.A.
이름은 an이어야합니다 정확한 사례를 포함한 일치 : Blah.valueOf("a") 그리고 Blah.valueOf("A ") 둘 다 던져 IllegalArgumentException.
정적 방법 valueOf() 그리고 values() 컴파일 시간에 생성되며 소스 코드에 표시되지 않습니다. 그러나 그들은 Javadoc에 나타납니다. 예를 들어, 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;
}
그런 다음 열거 수업에서 나는 일반적으로 일부 타이핑을 저장하기 위해 이것을 가지고 있습니다.
public static MyEnum fromString(String name) {
return getEnumFromString(MyEnum.class, name);
}
열거가 모든 캡이 아닌 경우 Enum.valueOf 선.
너무 나쁘다 T.class ~을 위한 Enum.valueOf ~처럼 T 지워집니다.
당신은 또한 당신의 사건에주의해야합니다. 설명하겠습니다 : Blah.valueOf("A") 작동하지만 Blah.valueOf("a") 작동 안 할 것이다. 그런 다음 다시 Blah.valueOf("a".toUpperCase(Locale.ENGLISH)) 작동 할 것이다.
편집하다
변경 toUpperCase 에게 toUpperCase(Locale.ENGLISH) 기반 TC. 논평 그리고 자바 문서
edit2안드로이드에서 사용해야합니다 Locale.US, 처럼 술라이가 지적합니다.
Joshua Bloch의 패턴을 사용하십시오. 효과적인 자바:
(간결성을 위해 단순화)
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);
}
}
또한 참조 :
다음은 모든 열거에 대해 할 수있는 방법이며, 사례는 둔감합니다.
/**
* 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) 또한.
자신의 유틸리티를 쓰고 싶지 않다면 Google의 사용 구아바 도서관:
Enums.getIfPresent(Blah.class, "A")
내장 된 Java 함수와 달리 A가 Blah로 존재하고 예외를 던지지 않는지 확인할 수 있습니다.
내 2 센트 : Java8 스트림 사용 + 정확한 문자열 확인 :
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() 해당 컨벤션을 사용하여 이름을 지정하기 때문에 Java 언어 자체로부터 몇 가지 혜택을 얻을 수 있습니다. 예를 들어:
Java 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();
}
}
이것을 필요로 할 수 있습니다.
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;
}
이렇게하면 Fromenumname에서 "사람"을 제공하는 경우 예를 들어, 예를 들어, 예를 들어 값을 반환합니다. 즉, Enum "Person"의 가치를 반환합니다.
암시 적 정적 메소드를 사용 하여이 작업을 수행하는 또 다른 방법 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 자바의 열거의 예
Guava 라이브러리를 사용하는 솔루션. 메소드 getPlanet ()는 사례 둔감이므로 getPlanet ( "Mercury")은 Planet.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();
}
}
이전 답변에 추가하고 Nulls 및 NPE에 대한 논의 중 일부를 해결하기 위해 Guava 옵션을 사용하여 결석/유효하지 않은 사례를 처리합니다. 이것은 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();
}
}
}
모르는 사람들을 위해 다음은 선택 사항을 사용하여 NULL을 피하는 것에 대한 추가 정보입니다. https://code.google.com/p/guava-libraries/wiki/usingandavoidingnullexplained#optional
Java 8에서는 정적 맵 패턴이 훨씬 쉽고 미리 메소드입니다. Jackson과 함께 열거를 사용하려면 Tostring을 무시하고 이름 대신에 사용할 수 있습니다. @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;
}
o (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;
}
}
java.lang.Enum Java의 모든 열거 유형에 사용할 수있는 몇 가지 유용한 방법을 정의합니다.
- 당신이 사용할 수있는
name()에너지 상수의 이름을 얻는 방법. 열 상수를 쓰는 데 사용되는 문자열 문자는 그들의 이름입니다. - 비슷하게
values()방법을 사용하여 모든 열거 상수의 배열을 열고 유형으로부터 얻을 수 있습니다. - 그리고 질문에 대해서는 사용할 수 있습니다
valueOf()아래 그림과 같이 모든 문자열을 Java에서 열 상수로 변환하는 방법.
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".
아파치 커먼즈 라인 라이브러리에는 정적 기능이 있습니다 org.apache.commons.lang3.enumutils.getenum 스트링을 열거 형에 매핑합니다. 본질적으로 Geoffreys와 같은 대답이지만 이미 야생에있을 때 자신을 굴립니다.
유용한 유틸리티를 사용하여 최고 등급 답변에 추가...
valueOf() 입력이 마음에 들지 않는 경우 두 가지 다른 예외가 발생합니다.
IllegalArgumentExceptionNullPointerExeption
요구 사항이 문자열이 열거형 값과 확실히 일치한다는 보장이 없는 경우(예: 문자열 데이터가 데이터베이스에서 왔고 이전 버전의 열거형을 포함할 수 있는 경우) 이러한 항목을 처리해야 합니다. 자주...
그래서 여기에 우리가 전달한 문자열이 일치하지 않는 경우 반환될 기본 Enum을 정의할 수 있도록 제가 작성한 재사용 가능한 메서드가 있습니다.
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
}
는 어때?
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();
}
}
}
역전으로 캡처하는 또 다른 유틸리티. 이름이 아닌 그 열거를 식별하는 값을 사용합니다.
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 Foo의 최종적이지 않고 정적 방법이 아닌 독특한 대중 인 "Drei"와 일치합니다. FOO가 최종적이 아니라 정적 방법이 아닌 공개 이상의 경우 getTranslate "drei"를 반환하면 다른 방법을 사용할 수 있습니다. EnumUtil.from(Foo.class, "drei", "getTranslate").
A로 switch-버전은 아직 언급되지 않았지만 그것을 소개합니다 (OP의 열거 재사용) :
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 반환됩니다. 그러므로 우리는 a NullPointerException 이름이있는 경우 null 그리고 경우에 default 만약에 defaultValue ~이다 null. 그게 방법입니다 valueOfOrDefault 공장.
이 접근법은 디자인을 채택합니다 Map-메소드를 제공하는 인터페이스 Map.getOrDefault(Object key, V defaultValue) Java 8.
나는 이런 종류의 프로세스를 사용하여 명령을 열거 된 문자열로 구문 분석하고 싶습니다. 나는 일반적으로 열거 중 하나를 "알려지지 않은"것으로 보이므로 다른 사람이 발견되지 않을 때 (케이스 둔감 한 기준으로도)가 아닌 (가치가 없음)를 찾을 수 없을 때 반환하는 데 도움이됩니다 (가치가 없음). 따라서 나는이 접근법을 사용합니다.
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;
}
Enum의 이름을 얻는 가장 빠른 방법은 응용 프로그램이 시작될 때 열거 텍스트 및 값의 맵을 작성하고 이름을 얻는 것이 함수 blah.getenumname ()을 호출하는 것입니다.
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.toString());
}
}
public static String getEnumName(String text) {
return map.get(text.toLowerCase());
}
}
Enum은 매우 유용합니다. 저는 사용했습니다 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");
