Kaip gauti skaičiavimo vertę iš eilutės reikšmės java?

Tarkime, kad turiu teisingą sąrašą

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

ir norėčiau rasti skaičiavimo eilutės reikšmę, pavyzdžiui, "A" , kuri bus Blah.A Kaip tai padaryti?

Ar reikalingas Enum.valueOf() metodas? Jei taip, kaip jį naudoti?

1714
03 марта '09 в 1:56 2009-03-03 01:56 Malachi yra nustatytas kovo 03 '09, 1:56 2009-03-03 01:56
@ 24 atsakymai

Taip, Blah.valueOf("A") duos jums Blah.A

Atkreipkite dėmesį, kad pavadinimas turi būti tikslus atitikmuo, įskaitant atvejį: Blah.valueOf("A") ir Blah.valueOf("A ") abu išmeta neteisėtąArgumentException.

Statiniai metodai valueOf() ir values() yra sukurti kompiliavimo metu ir nerodomi šaltinio kode. Tačiau jie pasirodo Javadok; Pavyzdžiui, Dialog.ModalityType rodo abu metodus.

1973 m
03 марта '09 в 1:57 2009-03-03 01:57 atsakė Michael Myers kovo 03 '09 at 1:57 2009-03-03 01:57

Kitas sprendimas, jei tekstas neatitinka skaičiavimo vertės:

 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; } } 
745
03 июня '10 в 13:57 2010-06-03 13:57 Atsakymą pateikė JoséMi birželio 03 d. 10 val. 13:57 2010-06-03 13:57

Čia yra naudinga programa, kurią naudoju:

  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; } 

Tada mano „enum“ klasėje paprastai rašau:

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

Jei jūsų sąrašai nėra visi antraštės, tiesiog pakeiskite eilutę Enum.valueOf .

Per blogai, negaliu T.class naudoti Enum.valueOf , nes T yra ištrintas.

105
12 нояб. Geoffrey Zheng atsakymas lapkričio 12 d 2009-11-12 18:52 '09, 18:52, 2009-11-12 18:52

Taip pat turėtumėte būti atsargūs. Leiskite paaiškinti: „ Blah.valueOf("A") veikia, bet „ Blah.valueOf("a") neveiks. Tada vėl bus „ Blah.valueOf("a".toUpperCase(Locale.ENGLISH)) .

redaguoti
Pakeistas toUpperCase į toUpperCase(Locale.ENGLISH) pagal tc. komentarai ir java dokumentai

edit2 „ Android“ turėtumėte naudoti „ Locale.US , kaip nurodė „sulay“ .

69
09 мая '09 в 19:33 2009-05-09 19:33 atsakymą pateikė João Portela gegužės 09, 09, 19:33 2009-05-09 19:33

Naudokite „Joshua Bloch“, „Efektyvus Java“ šabloną:

(supaprastinta trumpai)

 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); } } 

Taip pat žiūrėkite:

„Oracle Java“ pavyzdys naudojant „Enum“ ir instancijos žemėlapį

Statinių blokų vykdymo tvarka Enum tipo

Kaip peržiūrėti „Java enum“ iš savo eilutės reikšmės

51
15 июня '16 в 19:37 2016-06-15 19:37 atsakymas pateikiamas Darrell Teague , birželio 15 d. 16, 19:37 2016-06-15 19:37

Čia yra metodas, kuris gali tai padaryti bet kuriam „Enum“ ir yra nejautrus.

  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() )); } 
34
02 дек. Patrick Arnesen atsakymas 02 Gruodžio 2011-12-02 00:53 '11 prie 0:53 2011-12-02 00:53

Naudojant „ Blah.valueOf(string) geriausia, bet taip pat galite naudoti „ Enum.valueOf(Blah.class, string) .

28
09 мая '09 в 20:23 2009-05-09 20:23 atsakymą pateikė Peter Lawrey gegužės 09 '09, 20:23 2009-05-09 20:23

Jei nenorite parašyti savo naudingumo, naudokite „Google :

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

Skirtingai nuo integruotos java funkcijos, galite patikrinti, ar A yra Blaoje ir nesukuria išimties.

24
02 апр. Atsakymą pateikė Andrejs 02 Bal. 2014-04-02 23:12 '14, 23:12, 2014-04-02 23:12

Mano 2 centai čia: naudojant Java8 + siūlus, tikrinančius tikslią eilutę:

 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; }  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)); } } 

** EDIT **

Pervadinant funkciją fromString() kadangi fromString() yra pavadinimas, naudojant šią konvenciją, jūs gausite tam tikrų privalumų iš pačios Java kalbos; pavyzdžiui:

  1. Tiesioginio tipo konvertavimas „HeaderParam“ anotacijose
17
13 июля '17 в 16:38 2017-07-13 16:38 atsakymą pateikė Manu liepos 13 d. 17, 16:38 2017-07-13 16:38

„Java 8“ arba naujesnėje versijoje , naudojant srautus :

 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 fromText(String text) { return Arrays.stream(values()) .filter(bl -> bl.text.equalsIgnoreCase(text)) .findFirst() .orElse(null); } } 
15
01 авг. Hans Schreuder atsakymas, rugpjūčio 1 d. 2017-08-01 13:17 '17, 13:17 pm 2017-08-01 13:17

Jums gali prireikti:

 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; } } 

Kitas papildymas:

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

Tai, pvz., Grąžins jums vertę naudodamiesi užregistruotu pavadinimu. jei iš „EnumName “pateikiate„ PERSON “, jis grąžins„ Enum “vertę, ty„ Asmuo “

13
02 июля '15 в 14:54 2015-07-02 14:54 atsakymas duotas Murtaza Kanchwala 02 liepos 15 d. 14:54 2015-07-02 14:54

Kitas būdas tai padaryti yra naudojant netiesioginį „Enum“ metodą. Vardas grąžina tikslią eilutę, naudojamą kuriant šį sąrašą, kurį galima naudoti tikrinant su pateikta eilute:

 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"); } } 

Testavimas:

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

 //it will print BB 

įkvėpimas: 10 „Enum“ pavyzdžių „Java“

10
29 нояб. Atsakymą pateikė Vikramas lapkričio 29 d. 2011-11-29 08:02 '11 at 8:02 2011-11-29 08:02

Sprendimas naudojant Guavos bibliotekas. „GetPlanet“ () metodas yra nejautrus, todėl getPlanet („MerCUrY“) grąžins Planet.MERCURY.

 package com.universe.solarsystem.planets; import org.apache.commons.> 
7
22 авг. javabrew atsakė 22 rugpjūtis 2014-08-22 23:07 '14, 23:07 2014-08-22 23:07

Jei norite pridėti ankstesnius atsakymus ir kreiptis į kai kurias diskusijas apie nulius ir NPE, naudoju Guava parinktis trūkstamų / negaliojančių atvejų tvarkymui. Tai puikiai tinka analizuojant URI / parametrus.

 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(); } } } 

Tiems, kurie nežino, yra papildomos informacijos apie nulinio panaikinimo parinktį: https://code.google.com/p/guava-libraries/wiki/UsingAndAvoidingNullExplained#Optional

6
10 окт. atsakymas pateikiamas 10 val. 2014-10-10 13:10 '14, 13:10 2014-10-10 13:10
 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; } 
5
09 нояб. Atsakymas pateikiamas Prasobh.K 09.11 . 2011-11-09 12:50 '11, 12:50, 2011-11-09 12:50

„Java 8“ statinis žemėlapio šablonas yra dar paprastesnis ir mano pageidaujamas metodas. Jei norite naudoti „Enum“ su „Jackson“, galite iš naujo apibrėžti „ToString“ ir naudoti ją vietoj vardo, o tada @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); } } 
5
27 апр. Atsakymas pateikiamas Novaterata balandžio 27 d. 2017-04-27 20:10 '17 at 8:10 pm 2017-04-27 20:10

O (1) metodas, pagrįstas išgautu generuotu kodu, kuriame naudojamas maišos žemėlapis.

 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; } } 
4
23 сент. atsakymas pateikiamas Sisyphus 23 rugsėjis 2015-09-23 12:08 '15 , 12:08 2015-09-23 12:08

java.> apibrėžia keletą naudingų metodų, taikomų visiems „Java“ sąrašų tipams:

  • Galite naudoti name() metodą, kad gautumėte bet kurio Enum konstantos pavadinimą. Jų pavadinime yra įrašų konstantų rašymo eilutė.
  • Panašiai, values() metodas gali būti naudojamas visų Enum tipo Enum konstantų masyvui gauti.
  • Ir tam tikru klausimu galite naudoti valueOf() metodą, norėdami paversti String pastovumą į „Enum“ „Java“, kaip parodyta žemiau.
 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 

Šiame kodo fragmente valueOf() metodas grąžina Enum Gender.MALE konstanta, kurio skambinančiojo vardas grąžina "MALE" .

3
29 окт. Atsakymas pateikiamas KNU 29 okt. 2014-10-29 15:22 '14, 15:22 2014-10-29 15:22

„Apache commons-> bibliotekoje yra statinė org.apache.commons.> funkcija, kuri susieja eilutę su jūsų „Enum“ tipu. Atsakymas iš esmės yra toks pat, kaip ir „Geoffreys“, bet kodėl susivienykite, kai jis jau yra laukinių.

2
22 окт. atsakymas, kurį pateikė pjklauser 22 spalis. 2015-10-22 09:46 '15 at 9:46 2015-10-22 09:46

Įtraukus į aukštą reitingo atsakymą naudinga priemone ...

valueOf() išmeta dvi skirtingas išimtis tais atvejais, kai jam nepatinka jo įvestis.

  • IllegalArgumentException
  • NullPointerExeption

Jei jūsų reikalavimai yra tokie, kad jūs neturite jokių garantijų, kad jūsų eilutė tikrai atitiks skaičiavimo vertę, pavyzdžiui, jei eilutės duomenys yra gaunami iš duomenų bazės ir jame gali būti senas versijos sąrašas, tada reikės apdoroti šiuos dažnai ...

Taigi čia mes naudojame pakartotinai naudojamą metodą, kuris leidžia nustatyti numatytąją „Enum“, jei einantis eilutė nesutampa.

 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; } } 

Naudokite jį taip:

 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 } 
2
26 янв. atsakymą pateikė lance.dolan 26 jan. 2017-01-26 23:30 '17, 11.30 val. 2017-01-26 23:30

Kitas įrankis, kuris atlieka grįžimo kelią. Naudojant vertę, kuri identifikuoja šį Enum, o ne jo pavadinimą.

 import java.> 

Pavyzdys:

 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") grąžina „ Foo.THREE , nes jis naudos Foo.THREE , kad atitiktų „drei“, kuris yra unikalus viešasis metodas, o ne baigtinis, o ne statinis metodas „Foo“. Jei „Foo“ turi daugiau nei viešąjį metodą, o ne galutinį ir getTranslate metodą, pavyzdžiui, getTranslate , kuris grąžina „drei“, galite naudoti kitą būdą: „ EnumUtil.from(Foo.class, "drei", "getTranslate") .

1
24 февр. Atsakymą Moesio pateikė vasario 24 d. 2016-02-24 14:23 '16 at 14:23 pm 2016-02-24 14:23

Kaip apie

 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(); } } } 
1
30 дек. Atsakymas pateiktas DC 30 d. 2017-12-30 10:38 '17 10:38 am 2017-12-30 10:38

Kadangi switch -version dar nepaminėtas, aš jį įvedu (pakartotinai naudoti OP skaičiavimą):

  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); } } } 

Kadangi ji nepateikia jokios papildomos vertės „ valueOf(String name) metodui, tik tikslinga apibrėžti papildomą metodą, jei norime turėti kitokį elgesį. Jei nenorime kelti „ IllegalArgumentException , galime pakeisti įgyvendinimą:

  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; } } } 

Pateikdami numatytąją vertę, mes išsaugome „ Enum.valueOf(String name) sutartį, nesukeliant „ IllegalArgumentException , kad jokiu būdu nebūtų grąžintas. Todėl, jei pavadinimas yra null ir default atveju, jei defaultValue yra null , mesti NullPointerException . Kaip veikia „ valueOfOrDefault .

Šis metodas naudoja „ Map Interface“ schemą, kuri suteikia „ Map.getOrDefault(Object key, V defaultValue) su „Java 8“.

1
02 авг. atsakymą pateikė LuCio 02 rug . 2018-08-02 22:57 '18, 10:57 pm 2018-08-02 22:57

Norėčiau naudoti šį procesą komandų analizavimui kaip eilutės enumoje. Paprastai turiu vieną iš sąrašų kaip „nežinoma“, todėl ji padeda ją grąžinti, kai kiti nerandami (net ir nejautrus atveju), o ne nuliu (tai reiškia, kad nėra vertės). Todėl naudoju šį požiūrį.

 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; } 
0
30 авг. John Hemming atsakymas rugpjūčio 30 d 2016-08-30 12:11 '16 at 12:11 pm 2016-08-30 12:11

Peržiūrėkite kitus klausimus apie arba Užduoti klausimą