Conversione da stringa a enum Java con una grande quantità di valori

Question

Diciamo che ho un enum con 100 valori. Per semplicità, prendere il seguente esempio:

public enum code 
{ 
    CODE_1("string1"), 
    CODE_2("string2"), 
    CODE_3("string3"), 
    CODE_4("string4"), 
    ... 
} 

Voglio creare un metodo pubblico per convertire stringhe con un formato noto (come "stringa1", "stringa2" ...) al appropriata CODE_1 valore enum, CODE_2 ... In genere ciò avviene ripetendo tutti i valori e, se viene trovata una corrispondenza, restituisce tale valore enum. (I dettagli possono essere trovati in this question.)

Tuttavia, sono interessato al ciclo regolare su tutti i valori. Questo potrebbe potenzialmente essere un enorme collo di bottiglia? E se invece di 100 elementi, ce ne fossero 1000?

Come esercizio per me stesso, ho cercato di ottimizzare questa ricerca con una mappa statica, che può assicurare O (1) tempo di ricerca dato qualsiasi stringa. Mi piace questo trucco extra, ma voglio solo includerlo nel mio codice se è effettivamente necessario. Quali sono i tuoi pensieri e le tue conclusioni sull'uso del metodo iterativo rispetto al metodo della mappa?

public enum Code 
{ 
    ... 
    //enum values 
    ... 


    //The string-to-Code map 
    private static final Map<String,Code> CODE_MAP = populateMap(); 

    private static Map<String,Code> populateMap() 
    { 
     Map<String,Code> map = new HashMap<String,Code>(); 

     for(Code c : Code.values()) 
     { 
      map.put(c.getCode(), c); 
     } 

     return map; 
    } 


    private String code; 

    private Code(String code) 
    { 
     this.code = code; 
    } 

    public String getCode() 
    { 
     return this.code; 
    } 

    public Code convertFromString(String code) 
    { 
     //assume that the given string is actually a key value in the map 

     return (Code) CODE_MAP.get(code); 
    } 
} 

Answer 1

Si desidera un Map<String, Code>, ma come popolarlo ordinatamente? Enums non consentono di inizializzare un campi statici prima che le istanze enum vengono inizializzati, ma c'è un piccolo trucco accurato, chiamato Initialization-on-demand holder idiom, che rende utilizzando una mappa inizializzata staticamente necessaria per questa funzionalità facile da implementare:

public enum Code { 
    CODE_1("string1"), 
    CODE_2("string2"), 
    CODE_3("string3"), 
    // etc 
    ; 

    private static class Holder { 
     static Map<String, Code> CODE_MAP = new HashMap<>(); 
    } 

    private final String code; 

    private Code(String code) { 
     this.code = code; 
     Holder.CODE_MAP.put(code, this); 
    } 

    public String getCode() { 
     return this.code; 
    } 

    public Code convertFromString(String code) { 
     return CODE_MAP.get(code); 
    } 
} 

Funziona perché il programma di caricamento classi inizializza le classi statiche interne prima di inizializzando la classe enum, quindi la mappa viene assegnata pronta per essere caricata durante l'inizializzazione dell'istanza dell'enum.

Nessun anello. Nessun codice speciale per caricare la mappa (fatto nel costruttore). Codice minimo

Answer 2

Map è buona opzione: codice più pulito e O(1). Se si utilizza for-loop, il meglio che si ottiene è O(n)

Answer 3

La soluzione fornita è una corretta implementazione.

Come si dovrà esporre solo un metodo ed è più leggibile.

Ed è sempre bene utilizzare Map anziché iterating it manually.

E anche come hai menzionato la complessità è O(1).

+1 to your question, in quanto fornisce a cleaner approach to use enum in some usecases.

Answer 4

Bene, le alternative alla soluzione di mappa sarebbero una gigantesca dichiarazione di commutazione (che potrebbe essere generata automaticamente) o una ricerca binaria in una matrice contenente le stringhe. Credo che nessuno dei due batterà le prestazioni di HashMap con un ampio margine, anche se se è davvero importante, probabilmente starai meglio con il benchmarking.

Una cosa che non è stata menzionata è come Enum.valueOf() consente di trasformare una stringa in un valore enum, se ha il nome esatto di uno dei membri enum. Se questa è una possibilità nel tuo caso (osservando il tuo esempio, non vedo come Code.CODE_1 non possa essere facilmente rinominato Code.string1 ecc.), Suggerirei di usarlo, poiché non richiede alcuna codifica aggiuntiva a tutti e sarà quindi il più comprensibile.

Answer 5

Se il valore del codice stringa è un noto e formato coerente si potrebbe evitare l'uso di una cartina e la memoria che consuma e costruire il valore di ricerca CODE enum al volo:

public static Code convertFromString(String code) { 
    return valueOf("CODE_" + code.substring("string".length())); 
    }