Skip to main content

Simple Reverse Lookup Enum in Java



Documentation inline with the code.


import java.util.EnumSet;
import java.util.HashMap;
import java.util.Map;

/**
 *
 * @author Intesar Mohammed
 *
 *  Reverse Enum Lookup example using Map and EnumSet
 */
public enum Status {


    WAITING(0),
    READY(1),
    SKIPPED(-1),
    COMPLETED(5);
   

   /**
    *   code or your required variable can be of any type
    */ 
    private int code;

    private Status(int code) {
        this.code = code;
    }
  
    private static final Map<Integer, Status> lookup = 
                  new HashMap<Integer, Status>();
  
    /**
     * Stores all Enum's into lookup
     */
    static {
        for (Status s : EnumSet.allOf(Status.class)) {
            lookup.put(s.code, s);
        }
    }

    /**
     *
     * toString() is the only api to print Enum value
     * All Enum classes can consistently override toString() and provide a simple api
     * across different Enums
     *
     * @return
     */
    @Override
    public String toString() {
        return String.valueOf(code);
    }

    /**
     * Sample lookup code
     *
     * Status status = Status.get(0);
     * Status status = Status.get(5);
     * Status status = Status.get(10); // this will return null
     *
     * Also you can rename get() to reverseLookup() or lookup()
     * for readability convenience
     *
     * @param code
     * @return
     */
    public static Status get(int code) {
        return lookup.get(code);
    }
}



reference

Comments

Anonymous said…
What's the advantage of using EnumSet rather than values()?
Eric Jablow said…
This won't compile unless you use generics: Map<Integer, Status> and HashMap<Integer, Status>.

It seems like unnecessary overhead, but I prefer to wrap such maps with Collections.unmodifiableMap(). It makes the intent clear.
joonas said…
Even better would be to use EnumMap instead of HashMap.
tsachev said…
I usually do the static initialisation in a separate inner static class. I know it is not very pretty, but that way you should not bother about order of your declarations.
mtrovo said…
This is very useful when you need to use Enums with a database field with checked constraint.

Do you know the class EnumMap?
It's a map optimized for Enums and it's very suitable for what you're trying to do.


Regards.
EnumMap is not a good choice here as its a specialized Map implementation for use with enum type keys

also checkout jdk1.6 documentation
http://download.oracle.com/javase/6/docs/api/java/util/EnumMap.html
would have better if you could explain some usecases around it anyway something new to learn.

Javin
How Garbage collection works in Java
scardis said…
I do this type "lookup by code" logic in my enum(s) quite often, but rather than use a static block outside of the constructor, I add it to the static "lookup" Map in the constructor itself.
Indeed a useful one. Enum in Java are great feature and most versatile and very useful under certain scenario. In my opinion following are some of benefits of enum in java :
Best feature of Enum is you can use Enum in Java inside Switch statement like int or char primitive data type.we will also see example of using java enum in switch statement in this java enum tutorial.
By the way I have also blogged my experience as 10 examples of enum in java , let me know how do you find it.

Popular posts from this blog

Access multiple Databases in JPA

According to JPA specification we can define multiple "persistence-unit" elements (i.e. like below) in persistence.xml file and can easily refer them inside Dao layers as this. public class PolarDaoImpl {     @PersistenceContext(unitName="PolarPU")     protected EntityManager entityManager; -- } public class BearDaoImpl {     @PersistenceContext(unitName="BearPU")     protected EntityManager entityManager; -- } Checkout sample persistence.xml <?xml version="1.0" encoding="UTF-8"?> <persistence version="2.0" xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">     <!-- Database 1 -->     <persistence-unit name="PolarPU" transaction-type="RESOURCE_LOCAL">         <

JPA 2 new feature @ElementCollection explained

@ElementCollection is new annotation introduced in JPA 2.0, This will help us get rid of One-Many and Many-One shitty syntax. Example 1: Stores list of Strings in an Entity @Entity public class Users implements Serializable {     private static final long serialVersionUID = 1L;     @Id     @GeneratedValue(strategy = GenerationType.AUTO)     private Long id;     @ElementCollection     private List<String> certifications = new ArrayList <String> ();     public Long getId() {         return id;     }     public void setId(Long id) {         this.id = id;     }     public List <String> getCertifications() {         return certifications;     }     public void setCertifications(List <String> certifications) {         this.certifications = certifications;     } .. }         Users u = new Users();         u.getCertifications().add("Sun Certified Java Programmer");         em.persist(u); Generated Tables    Users    Co

Reuse JPA Entities as DTO

Note : Major design advantages of JPA Entities are they can detached and used across tiers and networks and later can by merged. Checkout this new way of querying entities in JPA 2.0 String ql = " SELECT new prepclass2.Employee (e.firstname, e.lastname) FROM Employee e "; List<Employee> dtos = em.createQuery(ql).getResultList(); The above query loads all Employee entities but with subset of data i.e. firstname, lastname. Employee entity looks like this. @Entity @Table(name="emp") public class Employee implements Serializable {     private static final long serialVersionUID = 1L;     @Id     @GeneratedValue(strategy = GenerationType.AUTO)     private Long id;     @Column     private String firstname;     @Column     private String lastname;     @Column     private String username;     @Column     private String street;     @Column     private String city;     @Column     private String state;     @Column     private String zipc