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（＆quot; A＆quot;）は Blah.A を提供します。
名前は、大文字と小文字を含めて exact 一致である必要があることに注意してください： Blah.valueOf（＆quot; a＆quot;）および Blah.valueOf（＆quot; A ＆quot;）は両方とも 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;
}
次に、enumクラスでは、通常、これを使用して入力を節約します。
public static MyEnum fromString(String name) {
return getEnumFromString(MyEnum.class, name);
}
列挙型がすべて大文字でない場合は、 Enum.valueOf 行を変更するだけです。
T が消去されるため、 Enum.valueOf に T.class を使用できないのは残念です。
ケースにも注意する必要があります。説明してみましょう： Blah.valueOf（＆quot; A＆quot;）は機能しますが、 Blah.valueOf（＆quot; a＆quot;）は機能しません。その後、再び Blah.valueOf（＆quot; a＆quot; .toUpperCase（Locale.ENGLISH））が機能します。
編集
tcに基づいて、 toUpperCase を toUpperCase（Locale.ENGLISH）に変更しました。コメントおよび Javaドキュメント
edit2
Androidでは、 Locale.US 、 sulaiが指摘する。
Joshua Blochのパターンを使用します、 Effective 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);
}
}
次も参照してください：
これは、任意のEnumに対して実行できるメソッドであり、大文字と小文字を区別しません。
/**
* 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の guava ライブラリ：
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;
}
}
もう 1 つ追加:
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 に「PERSON」を指定すると、Enum の値が返されます。"人"
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（＆quot; B＆quot;）。name（））;
//it will print B B
inspiration： JavaでのEnumの10個の例
Guavaライブラリを使用したソリューション。メソッドgetPlanet（）は大文字と小文字を区別しないため、 getPlanet（＆quot; MerCUrY＆quot;）は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();
}
}
前の回答に追加し、nullおよびNPEに関する議論のいくつかに対処するために、Guava Optionalsを使用して不在/無効なケースを処理しています。これは、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では、静的なMapパターンはさらに簡単で、私の好みの方法です。 JacksonでEnumを使用する場合は、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;
}
ハッシュマップを利用するrif約生成コードからヒントを得た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（）メソッドを使用して、Enum定数の名前を取得できます。 enum定数の記述に使用される文字列リテラルは、その名前です。 - 同様に
values（）メソッドを使用して、Enum型からすべてのEnum定数の配列を取得できます。 - また、質問に対しては、
valueOf（）メソッドを使用して、以下に示すように、JavaでStringをEnum定数に変換できます。
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を返し、その名前を呼び出すと＆quot; MALE＆quot; が返されます。
Apacheの commons-lang ライブラリには静的関数 org.apache.commons.lang3.EnumUtils.getEnum は、StringをEnum型にマップします。基本的にGeoffreysと同じ答えですが、すでに世の中に出ているのになぜ自分で転がすのか。
有用なユーティリティを使用して、上位の回答に追加...
valueOf（）は、入力が気に入らない場合に2つの異なる例外をスローします。
-
IllegalArgumentException -
NullPointerExeption
たとえば、文字列データがデータベースから取得され、古いバージョンの列挙を含む可能性がある場合など、文字列が列挙値と完全に一致するという保証がないという要件がある場合は、これらを頻繁に処理するには...
だから、ここで私が書いた再利用可能なメソッドを使って、渡した文字列が一致しない場合に返されるデフォルトの列挙を定義できるようにします。
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();
}
}
}
逆の方法でキャプチャする別のユーティリティ。名前からではなく、そのEnumを識別する値を使用します。
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、＆quot; drei＆quot;）は、 getValue を使用して＆quotと一致するため、 Foo.THREE を返します。 ; drei＆quot;は、Fooの静的メソッドではなく、finalではなく、一意のパブリックです。
Fooにfinalではなくpublicメソッド以外のメソッドがあり、「drei」を返す getTranslate などの静的メソッドではない場合、他のメソッドを使用できます： EnumUtil.from（Foo。クラス、＆quot; drei＆quot;、＆quot; getTranslate＆quot;）。
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 は返されません。したがって、名前が null の場合は NullPointerException をスローし、 defaultValue が nullの場合は。それが default の場合 valueOfOrDefault の仕組みです。
このアプローチでは、Java 8以降の Map.getOrDefault（Object key、V defaultValue）メソッドを提供する Map -Interfaceの設計を採用しています。
この種のプロセスを使用して、コマンドを文字列として列挙に解析します。私は通常、「不明」として列挙の1つを持っています。そのため、null（値が存在しないことを意味する）ではなく、（大文字と小文字を区別しない場合でも）他のものが見つからない場合にそれを返すことが役立ちます。したがって、このアプローチを使用します。
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の名前を取得する最も速い方法は、アプリケーションの起動時に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");
