어떻게 자바 의 문자열 값 에서 매 거 진 값 을 가 져 옵 니까?
public enum Blah {
A, B, C, D
}
문자열 의 매 거 진 값 을 찾 고 싶 습 니 다. 예 를 들 어
"A" 이 바로 Blah.A 입 니 다. 어떻게 이 점 을 할 수 있 습 니까?Enum.valueOf() 제 가 필요 한 방법 인가요?만약 그렇다면, 나 는 그것 을 어떻게 사용 할 것 인가?\# 1 층
이것 은 내 가 사용 하 는 예 쁜 실 용적 인 프로그램 이다.
/**
* A common method for all enums since they can't have another base class
* @param Enum type
* @param c enum type. All enums must be all caps.
* @param string case insensitive
* @return corresponding enum, or null
*/
public static > T getEnumFromString(Class 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 삭제 되 었 기 때문에 Enum.valueOf 나 는 Enum.valueOf 에 사용 할 수 없다 T.class.2 층
유 틸 리 티 프로그램 을 만 들 지 않 으 려 면 Google 의 guava 라 이브 러 리 를 사용 하 십시오.
Enums.getIfPresent(Blah.class, "A")
내 장 된 자바 함수 와 달리 Bl 에 A 가 있 고 이상 이 없 는 지 확인 하 라 고 합 니 다.
3 층
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 possible = Enums.getIfPresent(Planet.class, val);
if (!possible.isPresent()) {
throw new IllegalArgumentException(val + "? There is no such planet!");
}
return possible.get();
}
}
4 층
이전의 답 을 늘 리 고 null 과 NPE 에 관 한 토론 을 해결 하기 위해 저 는 Guava Optionals 를 사용 하여 결석/무효 안건 을 처리 합 니 다.이것 은 URI/매개 변수 분석 에 매우 적합 합 니 다.
public enum E {
A,B,C;
public static Optional fromString(String s) {
try {
return Optional.of(E.valueOf(s.toUpperCase()));
} catch (IllegalArgumentException|NullPointerException e) {
return Optional.absent();
}
}
}
모 르 는 사람들 에 게 는 optional 을 사용 하여 null 을 피 하 는 더 많은 정보 가 있 습 니 다. https:/code. google. com/p/guava - libraries/wiki/UsingAndAvoiding Null Explained\# Optional
5 층
java.lang.Enum 몇 가지 유용 한 방법 을 정 의 했 습 니 다. 이 방법 들 은 자바 의 모든 매 거 진 유형 에 사용 할 수 있 습 니 다.name() 사용 할 수 있 습 니 다.상수 문자열 문 자 를 쓰 는 것 은 이름 입 니 다.values() 방법 은 Enum 유형 에서 모든 Enum 상수 의 배열 을 얻 는 데 사용 할 수 있다.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() 방법 은 Enum 상수 Gender. MALE 를 되 돌려 주 고 호출 된 이름 을 되 돌려 줍 니 다 "MALE".6 층
만약 텍스트 가 매 거 진 값 과 다르다 면, 다른 해결 방안 은:
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;
}
}
7 층
당신 은 이렇게 해 야 할 수도 있 습 니 다.
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;
}
이것 은 문자열 화 된 매 거 진 이름 을 통 해 값 을 되 돌려 줍 니 다.예 를 들 어 from EnumName 에서 "PERSON"을 제공 하면 매 거 진 값 인 "Person"을 되 돌려 줍 니 다.
8 층
O (1) 방법의 영감 은 해시 표 의 절약 으로 생 성 된 코드 에서 나온다.
public enum USER {
STUDENT("jon",0),TEACHER("tom",1);
private static final Map 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;
}
}
9 층
Apache 의 comons - lang 라 이브 러 리 에는 정적 함수 org. apache. comons. lang 3. EnumUtils. getEnum 이 있 습 니 다. Enum 형식 에 String 을 표시 합 니 다.답 은 기본적으로 Geoffreys 와 같 지만 왜 야외 에 나 타 났 을 때 스스로 해 야 하 는 지.
\# 10 층
반대 방식 으로 캡 처 된 또 다른 유 틸 리 티 프로그램이름 이 아 닌 Enum 의 값 을 표시 합 니 다.
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.EnumSet;
public class EnumUtil {
/**
* Returns the Enum of type enumType whose a
* public method return value of this Enum is
* equal to valor.
* 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 from(Class enumType, Object value) {
String methodName = getMethodIdentifier(enumType);
return from(enumType, value, methodName);
}
/**
* Returns the Enum of type enumType whose
* public method methodName return is
* equal to value.
*
* @param enumType
* @param value
* @param methodName
* @return
*/
public static > E from(Class enumType, Object value, String methodName) {
EnumSet 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 "drei"와 일치 하 는 getValue 를 사용 하기 때문에 유일한 공공 방법 입 니 다. Foo 의 final 과 static 방법 이 아 닙 니 다.만약 에 Foo 가 가지 고 있 는 것 이 공개 적 이지 않 고 최종 적 이지 않 으 며 정태 적 인 방법 이 아니다. 예 를 들 어 getTranslate 'drei' 로 돌아 가면 다른 방법 을 사용 할 수 있다. EnumUtil.from(Foo.class, "drei", "getTranslate")\# 11 층유효한 자바 의 Joshua Bloch 가 제공 하 는 모드 를 사용 합 니 다:
(간소화 하기 위해)
enum MyEnum {
ENUM_1("A"),
ENUM_2("B");
private String name;
private static final Map 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 map = new ConcurrentHashMap();
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);
}
}
참고 하 시기 바 랍 니 다:
인 스 턴 스 매 거 진 과 매 핑 을 사용 하 는 Oracle Java 예제
Enum 형식의 정적 블록 실행 순서
어떻게 String 값 에서 자바 매 거 진 을 찾 습 니까?
\# 12 층
나 는 이 과정 을 사용 하여 명령 을 문자열 로 매 거 진 것 으로 해석 하 는 것 을 좋아한다.나 는 보통 그 중의 하 나 를 '알 수 없 음' 이 라 고 부 르 기 때문에 null (값 이 없다 는 뜻) 이 아 닌 다른 매 거 진 을 찾 지 못 한 상태 에서 되 돌려 주 는 것 이 도움 이 될 것 이다.그래서 나 는 이런 방법 을 사용한다.
static > Enum getEnumValue(String what, Class enumClass) {
Enum unknown=null;
for (Enum enumVal: enumClass.getEnumConstants()) {
if (what.compareToIgnoreCase(enumVal.name()) == 0) {
return enumVal;
}
if (enumVal.name().compareToIgnoreCase("unknown") == 0) {
unknown=enumVal;
}
}
return unknown;
}
\# 13 층
평 점 이 가장 높 은 답 을 더 해 유용 한 유 틸 리 티 를 제공 합 니 다.
valueOf() 입력 을 좋아 하지 않 으 면 두 개의 서로 다른 Exception 을 일 으 킬 수 있다.IllegalArgumentException NullPointerExeption 만약 당신 의 요구 가 당신 의 String 이 매 거 진 값 과 일치 할 것 이 라 고 보장 할 수 없다 면, 예 를 들 어 String 데이터 가 데이터베이스 에서 왔 고, 이전 버 전의 매 거 진 것 을 포함 할 수 있다 면, 이러한 것들 을 자주 처리 해 야 합 니 다...
따라서 이것 은 제 가 다시 사용 할 수 있 는 방법 입 니 다. 이 방법 은 기본 Enum 을 정의 할 수 있 습 니 다. (우리 가 전달 하 는 String 이 일치 하지 않 으 면 되 돌아 갑 니 다.)
private static > 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
}
\# 14 층
자바 8 에 서 는 정적 맵 모드 가 더 간단 합 니 다. 이것 이 제 첫 번 째 방법 입 니 다.Jackson 과 함께 Enum 을 사용 하려 면 이름 대신 toString 을 덮어 쓰 고
@JsonValue 주석 을 사용 할 수 있 습 니 다.public enum MyEnum {
BAR,
BAZ;
private static final Map 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 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);
}
}
\# 15 층
내 가 여기 있 는 2 센트: 자바 8 흐름 + 정확 한 문자열 검사:
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() 로 바 꾸 면 자바 언어 자체 에서 좋 은 점 을 얻 을 수 있 습 니 다.예 를 들 면:자바 8 또는 더 높 은 버 전에 서 Streams 사용 하기:
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 fromText(String text) {
return Arrays.stream(values())
.filter(bl -> bl.text.equalsIgnoreCase(text))
.findFirst();
}
}
\# 17 층
무엇 에 관 하여?
public enum MyEnum {
FIRST,
SECOND,
THIRD;
public static Optional fromString(String value){
try{
return Optional.of(MyEnum.valueOf(value));
}catch(Exception e){
return Optional.empty();
}
}
}
\# 18 층
아직 언급 되 지 않 았 기 때문에
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) 의 약속 을 유지 합 니 다. 어떠한 상황 에서 도 돌아 오지 않 습 니 다 null 방식 으로 IllegalArgumentException.이에 따라 명칭 null 이 라면 던 지기 NullPointerException default null defaultValue 는 던 지기 NullPointerException 다.이것 이 바로 valueOfOrDefault 작업 방식 이다.이 방법 은
Map Map.getOrDefault(Object key, V defaultValue) 의 디자인 을 사용 하고 이 인 터 페 이 스 는 자바 8 부터 Map.getOrDefault(Object key, V defaultValue) 방법 을 제공한다.19 층
매 거 진 이름 을 가 져 오 는 가장 빠 른 방법 은 프로그램 이 시 작 될 때 매 거 진 텍스트 와 값 의 맵 을 만 들 고 함수 Blah. getEnumName () 을 통 해 이름 을 가 져 오 는 것 입 니 다.
public enum Blah {
A("text1"),
B("text2"),
C("text3"),
D("text4");
private String text;
private HashMap map;
Blah(String text) {
this.text = text;
}
public String getText() {
return this.text;
}
static{
createMapOfTextAndName();
}
public static void createMapOfTextAndName() {
map = new HashMap();
for (Blah b : Blah.values()) {
map.put(b.getText(),b.toString());
}
}
public static String getEnumName(String text) {
return map.get(text.toLowerCase());
}
}
20 층
매 거 진 것 이 매우 유용 합 니 다. 저 는 자주
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");
21 층
네,
Blah.valueOf("A") 드 리 겠 습 니 다 Blah.A대소 문자 Blah.valueOf("a") 와 Blah.valueOf("A ") 를 모두 던 지 는 것 을 포함 하여 이름 이 완전히 일치 해 야 합 니 다 IllegalArgumentException.정적 방법
valueOf() 과 values() 은 컴 파일 할 때 만 들 고 소스 코드 에 나타 나 지 않 습 니 다.하지만 자바 doc 에 나타 난 것 은 사실이다.예 를 들 어 Dialog.ModalityType 두 가지 방법 을 나타 낸다.22 층
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;
}
23 층
Enum 의 암시 적 정적 방법
name() 을 사용 하 는 또 다른 방법.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
영감: 자바 의 Enum 예시 10 개
24 층
이것 은 대소 문 자 를 구분 하지 않 고 모든 것 을 실행 할 수 있 는 방법 이다.
/**
* Finds the value of the given enumeration by name, case-insensitive.
* Throws an IllegalArgumentException if no match is found.
**/
public static > T valueOfIgnoreCase(
Class 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()
));
}
25 층
당신 은 또한 자신의 상황 을 신중하게 대해 야 합 니 다.설명 하 겠 습 니 다.
Blah.valueOf("A") 하면 되 지만 Blah.valueOf("a") 안 됩 니 다.그리고 다시 사용 Blah.valueOf("a".toUpperCase(Locale.ENGLISH)).편집 변경
toUpperCase 에서 toUpperCase(Locale.ENGLISH) TC 기반 으로 변경 합 니 다.주석 과 자바 문서EDIT 2 는 Android 에서 sulai 로 사용 해 야 합 니 다
Locale.US.26 층
사용
Blah.valueOf(string) 이 좋 지만 사용 Enum.valueOf(Blah.class, string) 도 가능 합 니 다.
이 내용에 흥미가 있습니까?
현재 기사가 여러분의 문제를 해결하지 못하는 경우 AI 엔진은 머신러닝 분석(스마트 모델이 방금 만들어져 부정확한 경우가 있을 수 있음)을 통해 가장 유사한 기사를 추천합니다:
Is Eclipse IDE dying?In 2014 the Eclipse IDE is the leading development environment for Java with a market share of approximately 65%. but ac...
텍스트를 자유롭게 공유하거나 복사할 수 있습니다.하지만 이 문서의 URL은 참조 URL로 남겨 두십시오.
CC BY-SA 2.5, CC BY-SA 3.0 및 CC BY-SA 4.0에 따라 라이센스가 부여됩니다.
좋은 웹페이지 즐겨찾기
