Best approach for multilingual Java Enum

I would approach this problem as I would approach any localization issue: ResourceBundle. I use a class called L18n that has a static method called getMessage that takes a key and optionally a list of arguments. The key gets looked up in a ResourceBundle configured to use the default Locale or whatever you prefer (specifics here aren't important, so long as the caller to L18n doesn't have to know about what the Locale is.

The L18n class is as follows:

public class L18n {
    private L18n() {
    }

    private static ResourceBundle bundle;

    public static void getMessage(String key) {
        if(bundle == null) {
            bundle = ResourceBundle.getBundle("path.to.l18n.messages");
        }
        return bundle.getString(key);
    }

    public static void getMessage(String key, Object ... arguments) {
        return MessageFormat.format(getMessage(key), arguments);
    }
}

In your project, you would have in package path.to.l18n, files containing messages.properties (default), messages_en.properties (Locale en), messages_it.properties (Locale it), etc.

When you need to translate an enum value, you shouldn't have to treat it any differently than any other key, except the key is the enum term.

In other words, you have:

public enum AccountStatusEnum {
  Active,
  Inactive,
  Pending
}

When you call L18n.getMessage, you pass with AccountStatusEnum.Active.toString() and the translation will be found in a property file with key "Active". If you're like me, and you prefer to use lower-case keys, then you should perform toLowerCase() on the string. Better still, you create a new L18n.getMessage that takes an Enum rather than a key, and that method calls the String version of L18n.getMessage with the enum value converted to string and in lowercase.

So you'd then add this to the L18n class:

    public static void getMessage(Enum<?> enum) {
        return getMessage(enum.toString().toLowerCase());
    }

I prefer to use this method because it incorporates the same translation logic in the same part of the program without impacting your design. I hope that helps!

ResourceBundle is the way to go, but I would take advantage of the fact that enums are objects, and hide the details of i19n inside

public enum MyEnum {
  A,
  I,
  P;

  private String localeText = null;

  private MyEnum() {
    // Load resource bundle
    this.localeText = // get message;
  }

  public String getLocaleText() {
    return this.localeText();
  }
}

That would allow you to do:

MyEnum.A.getLocaleText();

directly, everywhere

An optimization would be loading the resource bundle as an static attribute, in an static initializer.

And in JEE, bonus points for making the resource bundle injectable (so you may change the localization strings easily).